@rpcbase/ui 0.234.0 → 0.236.0

package/dist/index278.js

@@ -1,23 +1,91 @@
-import c, { getCountryCallingCode as b } from "./index164.js";
-import g from "./index273.js";
-import C from "./index274.js";
-import h from "./index256.js";
-function P(i, r, l, N, n) {
-  var e = r || l ? b(r || l, n) : N;
-  if (i.indexOf(e) === 0) {
-    n = new c(n), n.selectNumberingPlan(r || l, e);
-    var o = i.slice(e.length), f = C(o, r, n), m = f.nationalNumber, u = C(i, r, n), t = u.nationalNumber;
-    if (!g(t, n.nationalNumberPattern()) && g(m, n.nationalNumberPattern()) || h(t, r, n) === "TOO_LONG")
-      return {
-        countryCallingCode: e,
-        number: o
-      };
-  }
-  return {
-    number: i
-  };
+import { tzOffset as s } from "./index279.js";
+class o extends Date {
+  //#region static
+  constructor(...e) {
+    super(), e.length > 1 && typeof e[e.length - 1] == "string" && (this.timeZone = e.pop()), this.internal = /* @__PURE__ */ new Date(), isNaN(s(this.timeZone, this)) ? this.setTime(NaN) : e.length ? typeof e[0] == "number" && (e.length === 1 || e.length === 2 && typeof e[1] != "number") ? this.setTime(e[0]) : typeof e[0] == "string" ? this.setTime(+new Date(e[0])) : e[0] instanceof Date ? this.setTime(+e[0]) : (this.setTime(+new Date(...e)), z(this, e)) : this.setTime(Date.now());
+  }
+  static tz(e, ...n) {
+    return n.length ? new o(...n, e) : new o(Date.now(), e);
+  }
+  //#endregion
+  //#region time zone
+  withTimeZone(e) {
+    return new o(+this, e);
+  }
+  getTimezoneOffset() {
+    const e = -s(this.timeZone, this);
+    return e > 0 ? Math.floor(e) : Math.ceil(e);
+  }
+  //#endregion
+  //#region time
+  setTime(e) {
+    return Date.prototype.setTime.apply(this, arguments), p(this), +this;
+  }
+  //#endregion
+  //#region date-fns integration
+  [/* @__PURE__ */ Symbol.for("constructDateFrom")](e) {
+    return new o(+new Date(e), this.timeZone);
+  }
+  //#endregion
+}
+const Z = /^(get|set)(?!UTC)/;
+Object.getOwnPropertyNames(Date.prototype).forEach((t) => {
+  if (!Z.test(t)) return;
+  const e = t.replace(Z, "$1UTC");
+  o.prototype[e] && (t.startsWith("get") ? o.prototype[t] = function() {
+    return this.internal[e]();
+  } : (o.prototype[t] = function() {
+    return Date.prototype[e].apply(this.internal, arguments), j(this), +this;
+  }, o.prototype[e] = function() {
+    return Date.prototype[e].apply(this, arguments), p(this), +this;
+  }));
+});
+function p(t) {
+  t.internal.setTime(+t), t.internal.setUTCSeconds(t.internal.getUTCSeconds() - // Round after converting minutes to seconds to avoid fractional offset
+  // precision errors from historical offsets.
+  Math.round(-s(t.timeZone, t) * 60));
+}
+function j(t) {
+  Date.prototype.setFullYear.call(t, t.internal.getUTCFullYear(), t.internal.getUTCMonth(), t.internal.getUTCDate()), Date.prototype.setHours.call(t, t.internal.getUTCHours(), t.internal.getUTCMinutes(), t.internal.getUTCSeconds(), t.internal.getUTCMilliseconds()), z(t);
+}
+function z(t, e) {
+  const n = Array.isArray(e) ? v(e) : +t.internal, h = s(t.timeZone, t), i = h > 0 ? Math.floor(h) : Math.ceil(h), T = /* @__PURE__ */ new Date(+t);
+  T.setUTCHours(T.getUTCHours() - 1);
+  const r = -(/* @__PURE__ */ new Date(+t)).getTimezoneOffset(), S = -(/* @__PURE__ */ new Date(+T)).getTimezoneOffset(), b = r - S;
+  let M = r;
+  if (b && r !== i) {
+    const l = Date.prototype.getHours.apply(t), U = Array.isArray(e) ? e[3] || 0 : t.internal.getUTCHours();
+    if (l !== U) {
+      const f = /* @__PURE__ */ new Date(+t), H = r - i;
+      H && f.setUTCMinutes(f.getUTCMinutes() + H);
+      const O = s(t.timeZone, f);
+      (O > 0 ? Math.floor(O) : Math.ceil(O)) === i && (M = S);
+    }
+  }
+  const u = M - i;
+  u && Date.prototype.setUTCMinutes.call(t, Date.prototype.getUTCMinutes.call(t) + u);
+  const m = /* @__PURE__ */ new Date(+t);
+  m.setUTCSeconds(0);
+  const g = r > 0 ? m.getSeconds() : (m.getSeconds() - 60) % 60, a = Math.round(-(s(t.timeZone, t) * 60)) % 60;
+  (a || g) && Date.prototype.setUTCSeconds.call(t, Date.prototype.getUTCSeconds.call(t) + a + g);
+  const y = s(t.timeZone, t), c = y > 0 ? Math.floor(y) : Math.ceil(y), F = -(/* @__PURE__ */ new Date(+t)).getTimezoneOffset() - c, I = c !== i, D = F - u, w = c - i, N = n - c * 60 * 1e3, W = w > 0 && x(t) - n === w * 60 * 1e3 && x(t, N) !== n;
+  if (I && D && !W) {
+    Date.prototype.setUTCMinutes.call(t, Date.prototype.getUTCMinutes.call(t) + D);
+    const l = s(t.timeZone, t), U = l > 0 ? Math.floor(l) : Math.ceil(l), f = c - U;
+    f && D < 0 && Date.prototype.setUTCMinutes.call(t, Date.prototype.getUTCMinutes.call(t) + f);
+  }
+  p(t);
+  const C = (e ? n : n + a * 1e3) - +t.internal;
+  C && Math.abs(C) < 1800 * 1e3 && (Date.prototype.setTime.call(t, +t + C), p(t));
+}
+function v(t) {
+  return Date.UTC(t[0], t.length > 1 ? t[1] : 0, t.length > 2 ? t[2] : 1, ...t.slice(3));
+}
+function x(t, e) {
+  const n = new Date(e ?? +t);
+  return n.setUTCSeconds(n.getUTCSeconds() - Math.round(-s(t.timeZone, n) * 60)), +n;
 }
 export {
-  P as default
+  o as TZDateMini
 };
 //# sourceMappingURL=index278.js.map

package/dist/index278.js.map

@@ -1 +1 @@
-{"version":3,"file":"index278.js","sources":["../../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js"],"sourcesContent":["import Metadata from '../metadata.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport extractNationalNumber from './extractNationalNumber.js';\nimport checkNumberLength from './checkNumberLength.js';\nimport getCountryCallingCode from '../getCountryCallingCode.js';\n\n/**\r\n * Sometimes some people incorrectly input international phone numbers\r\n * without the leading `+`. This function corrects such input.\r\n * @param  {string} number — Phone number digits.\r\n * @param  {string} [country] — Exact country of the phone number.\r\n * @param  {string} [defaultCountry]\r\n * @param  {string} [defaultCallingCode]\r\n * @param  {object} metadata\r\n * @return {object} `{ countryCallingCode: string?, number: string }`.\r\n */\nexport default function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, defaultCountry, defaultCallingCode, metadata) {\n  var countryCallingCode = country || defaultCountry ? getCountryCallingCode(country || defaultCountry, metadata) : defaultCallingCode;\n  if (number.indexOf(countryCallingCode) === 0) {\n    metadata = new Metadata(metadata);\n    metadata.selectNumberingPlan(country || defaultCountry, countryCallingCode);\n    var possibleShorterNumber = number.slice(countryCallingCode.length);\n    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, country, metadata),\n      possibleShorterNationalNumber = _extractNationalNumbe.nationalNumber;\n    var _extractNationalNumbe2 = extractNationalNumber(number, country, metadata),\n      nationalNumber = _extractNationalNumbe2.nationalNumber;\n\n    // If the number was not valid before but is valid now,\n    // or if it was too long before, we consider the number\n    // with the country calling code stripped to be a better result\n    // and keep that instead.\n    // For example, in Germany (+49), `49` is a valid area code,\n    // so if a number starts with `49`, it could be both a valid\n    // national German number or an international number without\n    // a leading `+`.\n    if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) && matchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern()) || checkNumberLength(nationalNumber, country, metadata) === 'TOO_LONG') {\n      return {\n        countryCallingCode: countryCallingCode,\n        number: possibleShorterNumber\n      };\n    }\n  }\n  return {\n    number: number\n  };\n}\n//# sourceMappingURL=extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js.map"],"names":["extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","number","country","defaultCountry","defaultCallingCode","metadata","countryCallingCode","getCountryCallingCode","Metadata","possibleShorterNumber","_extractNationalNumbe","extractNationalNumber","possibleShorterNationalNumber","_extractNationalNumbe2","nationalNumber","matchesEntirely","checkNumberLength"],"mappings":";;;;AAgBe,SAASA,EAAgEC,GAAQC,GAASC,GAAgBC,GAAoBC,GAAU;AACrJ,MAAIC,IAAqBJ,KAAWC,IAAiBI,EAAsBL,KAAWC,GAAgBE,CAAQ,IAAID;AAClH,MAAIH,EAAO,QAAQK,CAAkB,MAAM,GAAG;AAC5C,IAAAD,IAAW,IAAIG,EAASH,CAAQ,GAChCA,EAAS,oBAAoBH,KAAWC,GAAgBG,CAAkB;AAC1E,QAAIG,IAAwBR,EAAO,MAAMK,EAAmB,MAAM,GAC9DI,IAAwBC,EAAsBF,GAAuBP,GAASG,CAAQ,GACxFO,IAAgCF,EAAsB,gBACpDG,IAAyBF,EAAsBV,GAAQC,GAASG,CAAQ,GAC1ES,IAAiBD,EAAuB;AAU1C,QAAI,CAACE,EAAgBD,GAAgBT,EAAS,sBAAqB,CAAE,KAAKU,EAAgBH,GAA+BP,EAAS,sBAAqB,CAAE,KAAKW,EAAkBF,GAAgBZ,GAASG,CAAQ,MAAM;AACrN,aAAO;AAAA,QACL,oBAAoBC;AAAA,QACpB,QAAQG;AAAA,MAChB;AAAA,EAEE;AACA,SAAO;AAAA,IACL,QAAQR;AAAA,EACZ;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"index278.js","sources":["../../../node_modules/@date-fns/tz/date/mini.js"],"sourcesContent":["import { tzOffset } from \"../tzOffset/index.js\";\n\n// TZDate stores time in two `Date` objects because native `Date` can only\n// expose local fields in the system time zone.\n//\n// The external date (`this`) stores the real timestamp. It is the value used by\n// `getTime()`, `valueOf()`, UTC getters/setters, comparisons, and arithmetic.\n// Its local getters are not used for target-zone fields because they would read\n// the timestamp through the system time zone.\n//\n// The internal date (`this.internal`) stores the target-zone wall-clock fields.\n// We read and write those fields through UTC getters/setters so the host system\n// time zone cannot reinterpret them. For example, `getHours()` returns\n// `internal.getUTCHours()`, and `setHours()` writes `internal.setUTCHours(...)`.\n//\n// Syncing moves data between the two representations:\n//\n// - `syncToInternal` starts from the external timestamp and rebuilds internal\n//   wall-clock fields using `this.timeZone` offset.\n//\n// - `syncFromInternal` starts from internal wall-clock fields, writes them into\n//   the external date, then adjusts that timestamp for the system/target offset\n//   difference and DST edge cases.\n//\n// The public TZDate value is the combination of both: external is the instant,\n// internal is the wall-clock view of that instant in `this.timeZone`.\n\nexport class TZDateMini extends Date {\n  //#region static\n\n  constructor(...args) {\n    super();\n\n    // Time zone string is always the last string argument unless date string\n    // is passed (as a single argument).\n    if (args.length > 1 && typeof args[args.length - 1] === \"string\") {\n      this.timeZone = args.pop();\n    }\n    this.internal = new Date();\n\n    // Validate the time zone by checking its offset.\n    if (isNaN(tzOffset(this.timeZone, this))) {\n      this.setTime(NaN);\n    } else {\n      if (!args.length) {\n        // No arguments passed: use current time\n        this.setTime(Date.now());\n      } else if (typeof args[0] === \"number\" && (args.length === 1 || args.length === 2 && typeof args[1] !== \"number\")) {\n        // Timestamp passed: use it as is\n        this.setTime(args[0]);\n      } else if (typeof args[0] === \"string\") {\n        // `Date` string passed: parse it as external date\n        this.setTime(+new Date(args[0]));\n      } else if (args[0] instanceof Date) {\n        // `Date` passed: use its timestamp\n        this.setTime(+args[0]);\n      } else {\n        // `Date` values passed:\n\n        // Set it as external date.\n        this.setTime(+new Date(...args));\n\n        // Adjust internal and external dates considering that we might have\n        // landed on the DST hour.\n        adjustToSystemTZ(this, args);\n      }\n    }\n  }\n  static tz(tz, ...args) {\n    return args.length ? new TZDateMini(...args, tz) : new TZDateMini(Date.now(), tz);\n  }\n\n  //#endregion\n\n  //#region time zone\n\n  withTimeZone(timeZone) {\n    return new TZDateMini(+this, timeZone);\n  }\n  getTimezoneOffset() {\n    const offset = -tzOffset(this.timeZone, this);\n    // Remove the seconds offset using `Math.floor` for negative UTC time zones\n    // and `Math.ceil` for positive UTC time zones.\n    return offset > 0 ? Math.floor(offset) : Math.ceil(offset);\n  }\n\n  //#endregion\n\n  //#region time\n\n  setTime(_time) {\n    // Use the native `setTime` to the external date time.\n    Date.prototype.setTime.apply(this, arguments);\n\n    // Then apply it to the internal date adjusting to the timezone offset.\n    syncToInternal(this);\n    return +this;\n  }\n\n  //#endregion\n\n  //#region date-fns integration\n\n  [Symbol.for(\"constructDateFrom\")](date) {\n    return new TZDateMini(+new Date(date), this.timeZone);\n  }\n\n  //#endregion\n}\n\n// Assign getters and setters\nconst re = /^(get|set)(?!UTC)/;\nObject.getOwnPropertyNames(Date.prototype).forEach(method => {\n  if (!re.test(method)) return;\n  const utcMethod = method.replace(re, \"$1UTC\");\n  // Filter out methods without UTC counterparts\n  if (!TZDateMini.prototype[utcMethod]) return;\n  if (method.startsWith(\"get\")) {\n    // Delegate to internal date's UTC method\n    TZDateMini.prototype[method] = function () {\n      return this.internal[utcMethod]();\n    };\n  } else {\n    // Assign regular setter\n    TZDateMini.prototype[method] = function () {\n      Date.prototype[utcMethod].apply(this.internal, arguments);\n      syncFromInternal(this);\n      return +this;\n    };\n\n    // Assign UTC setter\n    TZDateMini.prototype[utcMethod] = function () {\n      Date.prototype[utcMethod].apply(this, arguments);\n      syncToInternal(this);\n      return +this;\n    };\n  }\n});\n\n/**\n * @internal\n * Function syncs time to internal date, applying the current time zone offset.\n *\n * @param {Date} date - `Date` to sync\n */\nfunction syncToInternal(date) {\n  // Start internal from the same real timestamp as external.\n  date.internal.setTime(+date);\n\n  // Shift internal by the target offset so its UTC fields become the target-zone\n  // wall-clock fields for the external timestamp.\n  //\n  //   o internal UTC fields: 2024-02-11 00:00\n  //   |\n  //   | + Asia/Singapore offset (+08:00)\n  //   v\n  //   x internal UTC fields: 2024-02-11 08:00\n  //\n  date.internal.setUTCSeconds(date.internal.getUTCSeconds() -\n  // Round after converting minutes to seconds to avoid fractional offset\n  // precision errors from historical offsets.\n  Math.round(-tzOffset(date.timeZone, date) * 60));\n}\n\n/**\n * @internal\n * Function syncs internal wall-clock fields into the external date.\n *\n * @param {Date} date - The date to sync\n */\nfunction syncFromInternal(date) {\n  // Copy target-zone wall-clock fields from internal into external using native\n  // local setters. At this point external holds the right field values but they\n  // are interpreted in the system time zone; `adjustToSystemTZ` fixes that.\n  Date.prototype.setFullYear.call(date, date.internal.getUTCFullYear(), date.internal.getUTCMonth(), date.internal.getUTCDate());\n  Date.prototype.setHours.call(date, date.internal.getUTCHours(), date.internal.getUTCMinutes(), date.internal.getUTCSeconds(), date.internal.getUTCMilliseconds());\n\n  // Now we have to adjust the date to the system time zone\n  adjustToSystemTZ(date);\n}\n\n/**\n * @internal\n * Function adjusts the date to the system time zone. It uses the time zone\n * differences to calculate the offset and adjust the date.\n *\n * We use it when constructing `TZDate` and syncing the external date from\n * the internal one.\n *\n * @param {TZDate} date - `TZDate` to adjust.\n */\nfunction adjustToSystemTZ(date, constructorArgs) {\n  // Keep the intended target-zone wall-clock value before native Date/system\n  // time zone normalization can move it. Later corrections compare against this\n  // value to distinguish intended DST normalization from accidental drift.\n  const expectedInternalTime = Array.isArray(constructorArgs) ? constructorArgsToInternalTime(constructorArgs) : +date.internal;\n  //#region Initial offset calculation\n\n  // Current target time zone offset at the native timestamp. It may include\n  // historical offset seconds, which we preserve for the seconds adjustment.\n  const offsetWithSeconds = tzOffset(date.timeZone, date);\n\n  // Minute-precision target offset used by minute-based timestamp adjustments.\n  // Historical offsets can contain seconds, so we strip the fractional minute\n  // here and handle remaining seconds in the seconds adjustment below.\n  const offset = offsetWithSeconds > 0 ? Math.floor(offsetWithSeconds) : Math.ceil(offsetWithSeconds);\n\n  //#endregion\n\n  //#region System DST adjustment\n\n  // Native `Date` may normalize the requested wall time when the system time\n  // zone skips that hour for DST.\n  //\n  // We compare the system wall-clock hour represented by the external date with\n  // the wall-clock hour stored in the internal date. If they differ, the next\n  // offset-diff calculation may need the previous system offset, because the\n  // current external timestamp is already after the system DST jump.\n\n  // Previous-hour reference used to detect whether the system offset changed\n  // immediately before the current native timestamp.\n  const prevHour = new Date(+date);\n\n  // Use UTC math so subtracting one hour cannot be normalized back into the\n  // same missing local DST hour.\n  prevHour.setUTCHours(prevHour.getUTCHours() - 1);\n\n  // Current system offset at the native timestamp.\n  const systemOffset = -new Date(+date).getTimezoneOffset();\n\n  // System offset one real hour before the native timestamp.\n  const prevHourSystemOffset = -new Date(+prevHour).getTimezoneOffset();\n\n  // Non-zero when the system offset changed between `prevHour` and `date`.\n  const systemDSTChange = systemOffset - prevHourSystemOffset;\n\n  // System offset to use in the later system-target offset difference.\n  // Defaults to the current system offset and switches to the previous offset\n  // only when native `Date` normalized a missing system wall time.\n  let systemOffsetForDiff = systemOffset;\n  if (systemDSTChange && systemOffset !== offset) {\n    // System wall-clock hour represented by the current external timestamp.\n    const systemHour = Date.prototype.getHours.apply(date);\n\n    // Target wall-clock hour currently stored in internal fields. Constructors\n    // get it from arguments because internal may have already been synced from\n    // the normalized external timestamp; setters get it directly from internal.\n    const expectedHour = Array.isArray(constructorArgs) ? constructorArgs[3] || 0 : date.internal.getUTCHours();\n    if (systemHour !== expectedHour) {\n      // Check whether using the current system offset would keep the target\n      // offset unchanged. If so, the only DST jump we crossed is the system\n      // one, so the diff should use the pre-DST system offset.\n      const testDate = new Date(+date);\n\n      // Difference that the later offset-diff step would apply with the\n      // current system offset.\n      const testOffsetDiff = systemOffset - offset;\n      if (testOffsetDiff) testDate.setUTCMinutes(testDate.getUTCMinutes() + testOffsetDiff);\n\n      // Target offset after applying the current system offset difference.\n      const testOffsetWithSeconds = tzOffset(date.timeZone, testDate);\n\n      // Target offset without historical seconds, matching `offset`.\n      const testOffset = testOffsetWithSeconds > 0 ? Math.floor(testOffsetWithSeconds) : Math.ceil(testOffsetWithSeconds);\n      if (testOffset === offset) systemOffsetForDiff = prevHourSystemOffset;\n    }\n  }\n\n  //#endregion\n\n  //#region System diff adjustment\n\n  // Move external from the system-zone interpretation of internal fields toward\n  // the timestamp that represents those fields in the target time zone.\n  //\n  // At this point native `Date` has treated the internal wall-clock fields as if\n  // they belonged to the system zone. The system-target offset difference moves\n  // external by the distance between that system interpretation and the target\n  // interpretation.\n\n  // Difference between the system offset selected above and the minute-precision\n  // target offset. Positive values move external forward; negative values move\n  // it backward.\n  const offsetDiff = systemOffsetForDiff - offset;\n  if (offsetDiff)\n    // Apply the system-target minute difference to external. Internal is\n    // rebuilt from the final external timestamp after all adjustments are\n    // complete.\n    //\n    //   o  external as target: 2023-01-31 23:00\n    //   |\n    //   |  add `offsetDiff`\n    //   v\n    //   x  external as target: 2023-02-01 12:00\n    //\n    Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetDiff);\n\n  //#endregion\n\n  //#region Seconds system diff adjustment\n\n  // Historical time zone offsets can include seconds, but the minute-based\n  // offset adjustment above intentionally used minute precision.\n  //\n  // This adjustment applies the remaining seconds difference to external. For\n  // example, historical Singapore used UTC+06:55:25, while ISO formatting shows\n  // only `+06:55`; without the seconds correction, setter paths keep the wrong\n  // wall-clock seconds.\n\n  // Clone external as a native `Date` so we can inspect how the system time zone\n  // represents the same timestamp.\n  const systemDate = new Date(+date);\n\n  // Zero UTC seconds before reading system seconds. Any remaining local seconds\n  // then come from the system time zone offset rather than from the timestamp's\n  // own seconds value.\n  systemDate.setUTCSeconds(0);\n\n  // Seconds part contributed by the system time zone offset. Negative offsets\n  // need wrapping because `Date#getSeconds()` returns values in the 0..59 range.\n  const systemSecondsOffset = systemOffset > 0 ? systemDate.getSeconds() : (systemDate.getSeconds() - 60) % 60;\n\n  // Seconds part contributed by the target time zone offset.\n  const secondsOffset = Math.round(-(tzOffset(date.timeZone, date) * 60)) % 60;\n  if (secondsOffset || systemSecondsOffset)\n    // Apply the remaining second-level system-target difference to external.\n    //\n    //   o  external as Asia/Singapore: 1900-01-01 00:00:56\n    //   |\n    //   |  + `secondsOffset`\n    //   |  + `systemSecondsOffset`\n    //   v\n    //   x  external as Asia/Singapore: 1900-01-01 00:00:31\n    //\n    Date.prototype.setUTCSeconds.call(date, Date.prototype.getUTCSeconds.call(date) + secondsOffset + systemSecondsOffset);\n\n  //#endregion\n\n  //#region Post-adjustment DST fix\n\n  // The first system-target offset move can cross a target-zone DST boundary.\n  //\n  // When that happens, the target offset at the new external timestamp differs\n  // from the target offset used for `offsetDiff`. We compare the original move\n  // with the move that would be calculated at the new timestamp, then apply the\n  // difference to external.\n\n  // Target offset at the current external timestamp, including historical\n  // seconds for the later seconds adjustment.\n  const postOffsetWithSeconds = tzOffset(date.timeZone, date);\n\n  // Minute-precision target offset at the current external timestamp.\n  const postOffset = postOffsetWithSeconds > 0 ? Math.floor(postOffsetWithSeconds) : Math.ceil(postOffsetWithSeconds);\n\n  // System offset at the current external timestamp.\n  const postSystemOffset = -new Date(+date).getTimezoneOffset();\n\n  // System-target offset difference at the current external timestamp.\n  const postOffsetDiff = postSystemOffset - postOffset;\n\n  // Whether the target offset changed after the first offset move.\n  const offsetChanged = postOffset !== offset;\n\n  // Difference between the current offset move and the move already applied.\n  const postDiff = postOffsetDiff - offsetDiff;\n\n  // If the first offset move already normalized a target DST gap forward, the\n  // generic post-DST correction below would undo that valid normalization. This\n  // happens, for example, with America/New_York 02:00 during spring-forward when\n  // the system zone also changes offset around the same instant.\n  const targetDSTShift = postOffset - offset;\n\n  // Candidate timestamp that would represent the requested wall-clock time with\n  // the post-transition target offset. If it still does not round-trip to the\n  // requested wall-clock fields, the requested time is inside a target DST gap.\n  const postOffsetCandidate = expectedInternalTime - postOffset * 60 * 1000;\n\n  // Only positive target offset shifts are spring-forward gaps. Negative shifts\n  // are fall-back overlaps and still need the regular post-adjustment path.\n  const normalizedTargetDSTGap = targetDSTShift > 0 && targetInternalTime(date) - expectedInternalTime === targetDSTShift * 60 * 1000 && targetInternalTime(date, postOffsetCandidate) !== expectedInternalTime;\n  if (offsetChanged && postDiff && !normalizedTargetDSTGap) {\n    // Apply the target-DST correction to external. In the backward-crossing case\n    // shown here, this lands on an intermediate value that needs `offsetChange`\n    // below.\n    //\n    //   o  external as America/New_York: 2023-03-12 03:00 EDT\n    //   |\n    //   |  + `postDiff`\n    //   v\n    //   x  external as America/New_York: 2023-03-12 01:00 EST\n    //\n    Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + postDiff);\n\n    // Target offset after applying `postDiff`. It may change again if the\n    // correction itself crosses a target-zone DST boundary.\n    const newOffsetWithSeconds = tzOffset(date.timeZone, date);\n\n    // Minute-precision target offset after applying `postDiff`.\n    const newOffset = newOffsetWithSeconds > 0 ? Math.floor(newOffsetWithSeconds) : Math.ceil(newOffsetWithSeconds);\n\n    // Offset change caused by the `postDiff` move itself.\n    const offsetChange = postOffset - newOffset;\n\n    // If the correction moved external backward across the target DST boundary,\n    // apply the boundary change so external lands on the valid target-zone\n    // timestamp. Forward crossings are already normalized by native Date, and\n    // applying this correction there would undo the valid post-DST result.\n    if (offsetChange && postDiff < 0) {\n      // Apply the second target-DST correction to external.\n      //\n      //   o  external as America/New_York: 2023-03-12 01:00 EST\n      //   |\n      //   |  + `offsetChange`\n      //   v\n      //   x  external as America/New_York: 2023-03-12 03:00 EDT\n      //\n      Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetChange);\n    }\n  }\n\n  //#endregion\n\n  // Rebuild internal wall-clock fields from the final external timestamp.\n  syncToInternal(date);\n\n  // Native Date can normalize historical system offsets with minute and second\n  // precision before we adjust to the target time zone. Correct only small\n  // historical drift so DST gap normalization (usually one hour) remains intact.\n  const expectedTime = constructorArgs ? expectedInternalTime : expectedInternalTime + secondsOffset * 1000;\n  const drift = expectedTime - +date.internal;\n  if (drift && Math.abs(drift) < 30 * 60 * 1000) {\n    Date.prototype.setTime.call(date, +date + drift);\n    syncToInternal(date);\n  }\n}\nfunction constructorArgsToInternalTime(args) {\n  // Mirror Date's date-value constructor defaults while preserving explicit\n  // `undefined` behavior. Missing month/day default, but passed `undefined`\n  // should remain invalid just like `Date.UTC(year, undefined, ...)`.\n  return Date.UTC(args[0], args.length > 1 ? args[1] : 0, args.length > 2 ? args[2] : 1, ...args.slice(3));\n}\nfunction targetInternalTime(date, time) {\n  // Compute the target-zone wall-clock representation for a timestamp without\n  // mutating the TZDate. This mirrors syncToInternal for temporary checks.\n  const internal = new Date(time ?? +date);\n  internal.setUTCSeconds(internal.getUTCSeconds() - Math.round(-tzOffset(date.timeZone, internal) * 60));\n  return +internal;\n}"],"names":["TZDateMini","args","tzOffset","adjustToSystemTZ","tz","timeZone","offset","_time","syncToInternal","date","re","method","utcMethod","syncFromInternal","constructorArgs","expectedInternalTime","constructorArgsToInternalTime","offsetWithSeconds","prevHour","systemOffset","prevHourSystemOffset","systemDSTChange","systemOffsetForDiff","systemHour","expectedHour","testDate","testOffsetDiff","testOffsetWithSeconds","offsetDiff","systemDate","systemSecondsOffset","secondsOffset","postOffsetWithSeconds","postOffset","postOffsetDiff","offsetChanged","postDiff","targetDSTShift","postOffsetCandidate","normalizedTargetDSTGap","targetInternalTime","newOffsetWithSeconds","newOffset","offsetChange","drift","time","internal"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index279.js

@@ -1,32 +1,23 @@
-function F(l, i) {
-  if (l && i.numberingPlan.nationalPrefixForParsing()) {
-    var g = new RegExp("^(?:" + i.numberingPlan.nationalPrefixForParsing() + ")"), n = g.exec(l);
-    if (n) {
-      var r, P, v = n.length - 1, e = v > 0 && n[v];
-      if (i.nationalPrefixTransformRule() && e)
-        r = l.replace(g, i.nationalPrefixTransformRule()), v > 1 && (P = n[1]);
-      else {
-        var o = n[0];
-        r = l.slice(o.length), e && (P = n[1]);
-      }
-      var f;
-      if (e) {
-        var s = l.indexOf(n[1]), a = l.slice(0, s);
-        a === i.numberingPlan.nationalPrefix() && (f = i.numberingPlan.nationalPrefix());
-      } else
-        f = n[0];
-      return {
-        nationalNumber: r,
-        nationalPrefix: f,
-        carrierCode: P
-      };
-    }
+const e = {}, s = {};
+function u(t, r) {
+  try {
+    const n = (e[t] ||= new Intl.DateTimeFormat("en-US", {
+      timeZone: t,
+      timeZoneName: "longOffset"
+    }).format)(r).split("GMT")[1];
+    return n in s ? s[n] : o(n, n.split(":"));
+  } catch {
+    if (t in s) return s[t];
+    const f = t?.match(a);
+    return f ? o(t, f.slice(1)) : NaN;
   }
-  return {
-    nationalNumber: l
-  };
+}
+const a = /([+-]\d\d):?(\d\d)?/;
+function o(t, r) {
+  const f = +(r[0] || 0), n = +(r[1] || 0), c = +(r[2] || 0) / 60;
+  return s[t] = f * 60 + n > 0 ? f * 60 + n + c : f * 60 - n - c;
 }
 export {
-  F as default
+  u as tzOffset
 };
 //# sourceMappingURL=index279.js.map

package/dist/index279.js.map

@@ -1 +1 @@
-{"version":3,"file":"index279.js","sources":["../../../node_modules/libphonenumber-js/es6/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js"],"sourcesContent":["/**\r\n * Strips any national prefix (such as 0, 1) present in a\r\n * (possibly incomplete) number provided.\r\n * \"Carrier codes\" are only used  in Colombia and Brazil,\r\n * and only when dialing within those countries from a mobile phone to a fixed line number.\r\n * Sometimes it won't actually strip national prefix\r\n * and will instead prepend some digits to the `number`:\r\n * for example, when number `2345678` is passed with `VI` country selected,\r\n * it will return `{ number: \"3402345678\" }`, because `340` area code is prepended.\r\n * @param {string} number — National number digits.\r\n * @param {object} metadata — Metadata with country selected.\r\n * @return {object} `{ nationalNumber: string, nationalPrefix: string? carrierCode: string? }`. Even if a national prefix was extracted, it's not necessarily present in the returned object, so don't rely on its presence in the returned object in order to find out whether a national prefix has been extracted or not.\r\n */\nexport default function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {\n  if (number && metadata.numberingPlan.nationalPrefixForParsing()) {\n    // See METADATA.md for the description of\n    // `national_prefix_for_parsing` and `national_prefix_transform_rule`.\n    // Attempt to parse the first digits as a national prefix.\n    var prefixPattern = new RegExp('^(?:' + metadata.numberingPlan.nationalPrefixForParsing() + ')');\n    var prefixMatch = prefixPattern.exec(number);\n    if (prefixMatch) {\n      var nationalNumber;\n      var carrierCode;\n      // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\n      // If a `national_prefix_for_parsing` has any \"capturing groups\"\n      // then it means that the national (significant) number is equal to\n      // those \"capturing groups\" transformed via `national_prefix_transform_rule`,\n      // and nothing could be said about the actual national prefix:\n      // what is it and was it even there.\n      // If a `national_prefix_for_parsing` doesn't have any \"capturing groups\",\n      // then everything it matches is a national prefix.\n      // To determine whether `national_prefix_for_parsing` matched any\n      // \"capturing groups\", the value of the result of calling `.exec()`\n      // is looked at, and if it has non-undefined values where there're\n      // \"capturing groups\" in the regular expression, then it means\n      // that \"capturing groups\" have been matched.\n      // It's not possible to tell whether there'll be any \"capturing gropus\"\n      // before the matching process, because a `national_prefix_for_parsing`\n      // could exhibit both behaviors.\n      var capturedGroupsCount = prefixMatch.length - 1;\n      var hasCapturedGroups = capturedGroupsCount > 0 && prefixMatch[capturedGroupsCount];\n      if (metadata.nationalPrefixTransformRule() && hasCapturedGroups) {\n        nationalNumber = number.replace(prefixPattern, metadata.nationalPrefixTransformRule());\n        // If there's more than one captured group,\n        // then carrier code is the second one.\n        if (capturedGroupsCount > 1) {\n          carrierCode = prefixMatch[1];\n        }\n      }\n      // If there're no \"capturing groups\",\n      // or if there're \"capturing groups\" but no\n      // `national_prefix_transform_rule`,\n      // then just strip the national prefix from the number,\n      // and possibly a carrier code.\n      // Seems like there could be more.\n      else {\n        // `prefixBeforeNationalNumber` is the whole substring matched by\n        // the `national_prefix_for_parsing` regular expression.\n        // There seem to be no guarantees that it's just a national prefix.\n        // For example, if there's a carrier code, it's gonna be a\n        // part of `prefixBeforeNationalNumber` too.\n        var prefixBeforeNationalNumber = prefixMatch[0];\n        nationalNumber = number.slice(prefixBeforeNationalNumber.length);\n        // If there's at least one captured group,\n        // then carrier code is the first one.\n        if (hasCapturedGroups) {\n          carrierCode = prefixMatch[1];\n        }\n      }\n      // Tries to guess whether a national prefix was present in the input.\n      // This is not something copy-pasted from Google's library:\n      // they don't seem to have an equivalent for that.\n      // So this isn't an \"officially approved\" way of doing something like that.\n      // But since there seems no other existing method, this library uses it.\n      var nationalPrefix;\n      if (hasCapturedGroups) {\n        var possiblePositionOfTheFirstCapturedGroup = number.indexOf(prefixMatch[1]);\n        var possibleNationalPrefix = number.slice(0, possiblePositionOfTheFirstCapturedGroup);\n        // Example: an Argentinian (AR) phone number `0111523456789`.\n        // `prefixMatch[0]` is `01115`, and `$1` is `11`,\n        // and the rest of the phone number is `23456789`.\n        // The national number is transformed via `9$1` to `91123456789`.\n        // National prefix `0` is detected being present at the start.\n        // if (possibleNationalPrefix.indexOf(metadata.numberingPlan.nationalPrefix()) === 0) {\n        if (possibleNationalPrefix === metadata.numberingPlan.nationalPrefix()) {\n          nationalPrefix = metadata.numberingPlan.nationalPrefix();\n        }\n      } else {\n        nationalPrefix = prefixMatch[0];\n      }\n      return {\n        nationalNumber: nationalNumber,\n        nationalPrefix: nationalPrefix,\n        carrierCode: carrierCode\n      };\n    }\n  }\n  return {\n    nationalNumber: number\n  };\n}\n//# sourceMappingURL=extractNationalNumberFromPossiblyIncompleteNumber.js.map"],"names":["extractNationalNumberFromPossiblyIncompleteNumber","number","metadata","prefixPattern","prefixMatch","nationalNumber","carrierCode","capturedGroupsCount","hasCapturedGroups","prefixBeforeNationalNumber","nationalPrefix","possiblePositionOfTheFirstCapturedGroup","possibleNationalPrefix"],"mappings":"AAae,SAASA,EAAkDC,GAAQC,GAAU;AAC1F,MAAID,KAAUC,EAAS,cAAc,yBAAwB,GAAI;AAI/D,QAAIC,IAAgB,IAAI,OAAO,SAASD,EAAS,cAAc,yBAAwB,IAAK,GAAG,GAC3FE,IAAcD,EAAc,KAAKF,CAAM;AAC3C,QAAIG,GAAa;AACf,UAAIC,GACAC,GAiBAC,IAAsBH,EAAY,SAAS,GAC3CI,IAAoBD,IAAsB,KAAKH,EAAYG,CAAmB;AAClF,UAAIL,EAAS,4BAA2B,KAAMM;AAC5C,QAAAH,IAAiBJ,EAAO,QAAQE,GAAeD,EAAS,4BAA2B,CAAE,GAGjFK,IAAsB,MACxBD,IAAcF,EAAY,CAAC;AAAA,WAS1B;AAMH,YAAIK,IAA6BL,EAAY,CAAC;AAC9C,QAAAC,IAAiBJ,EAAO,MAAMQ,EAA2B,MAAM,GAG3DD,MACFF,IAAcF,EAAY,CAAC;AAAA,MAE/B;AAMA,UAAIM;AACJ,UAAIF,GAAmB;AACrB,YAAIG,IAA0CV,EAAO,QAAQG,EAAY,CAAC,CAAC,GACvEQ,IAAyBX,EAAO,MAAM,GAAGU,CAAuC;AAOpF,QAAIC,MAA2BV,EAAS,cAAc,eAAc,MAClEQ,IAAiBR,EAAS,cAAc,eAAc;AAAA,MAE1D;AACE,QAAAQ,IAAiBN,EAAY,CAAC;AAEhC,aAAO;AAAA,QACL,gBAAgBC;AAAA,QAChB,gBAAgBK;AAAA,QAChB,aAAaJ;AAAA,MACrB;AAAA,IACI;AAAA,EACF;AACA,SAAO;AAAA,IACL,gBAAgBL;AAAA,EACpB;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"index279.js","sources":["../../../node_modules/@date-fns/tz/tzOffset/index.js"],"sourcesContent":["const offsetFormatCache = {};\nconst offsetCache = {};\n\n/**\n * The function returns UTC offset in minutes for the given date in specified\n * time zone.\n *\n * Unlike `Date.prototype.getTimezoneOffset`, this function returns the value\n * mirrored to the sign of the offset in the time zone. For Asia/Singapore\n * (UTC+8), `tzOffset` returns `480`, while `getTimezoneOffset` returns `-480`.\n *\n * It uses `Intl.DateTimeFormat` internally to access otherwise unavailable\n * runtime's time zone data, and falls back to basic manual parsing if Intl API\n * is not supported (e.g., older Node.js versions, React Native's Hermes, etc.).\n *\n * @param timeZone - Time zone name (IANA or UTC offset).\n * @param date - Date to check the offset for.\n *\n * @returns UTC offset in minutes (e.g., `480` for date in UTC+8).\n */\nexport function tzOffset(timeZone, date) {\n  try {\n    // Create `Intl.DateTimeFormat` with `\"longOffset\"` that gives us consistent\n    // date strings like `\"5/19/2026, GMT-08:00\"`.\n    const format = offsetFormatCache[timeZone] ||= new Intl.DateTimeFormat(\"en-US\", {\n      timeZone,\n      timeZoneName: \"longOffset\"\n    }).format;\n\n    // Get `\"-08:00\"`.\n    const offsetStr = format(date).split(\"GMT\")[1];\n\n    // Avoid parsing the same offset string.\n    if (offsetStr in offsetCache) return offsetCache[offsetStr];\n\n    // Calculate offset from `[\"-08\", \"00\"]` and cache it.\n    return calcOffset(offsetStr, offsetStr.split(\":\"));\n  } catch {\n    // Fallback to manual parsing if the runtime doesn't support\n    // `±HH:MM/±HHMM/±HH`. See: https://github.com/nodejs/node/issues/53419.\n    if (timeZone in offsetCache) return offsetCache[timeZone];\n    const captures = timeZone?.match(offsetRe);\n    if (captures) return calcOffset(timeZone, captures.slice(1));\n    return NaN;\n  }\n}\nconst offsetRe = /([+-]\\d\\d):?(\\d\\d)?/;\nfunction calcOffset(cacheStr, values) {\n  const hours = +(values[0] || 0);\n  const minutes = +(values[1] || 0);\n  // Convert seconds to minutes by dividing by 60 to keep the function return in minutes.\n  const seconds = +(values[2] || 0) / 60;\n  return offsetCache[cacheStr] = hours * 60 + minutes > 0 ? hours * 60 + minutes + seconds : hours * 60 - minutes - seconds;\n}"],"names":["offsetFormatCache","offsetCache","tzOffset","timeZone","date","offsetStr","calcOffset","captures","offsetRe","cacheStr","values","hours","minutes","seconds"],"mappings":"AAAA,MAAMA,IAAoB,CAAA,GACpBC,IAAc,CAAA;AAmBb,SAASC,EAASC,GAAUC,GAAM;AACvC,MAAI;AASF,UAAMC,KANSL,EAAkBG,CAAQ,MAAM,IAAI,KAAK,eAAe,SAAS;AAAA,MAC9E,UAAAA;AAAA,MACA,cAAc;AAAA,IACpB,CAAK,EAAE,QAGsBC,CAAI,EAAE,MAAM,KAAK,EAAE,CAAC;AAG7C,WAAIC,KAAaJ,IAAoBA,EAAYI,CAAS,IAGnDC,EAAWD,GAAWA,EAAU,MAAM,GAAG,CAAC;AAAA,EACnD,QAAQ;AAGN,QAAIF,KAAYF,EAAa,QAAOA,EAAYE,CAAQ;AACxD,UAAMI,IAAWJ,GAAU,MAAMK,CAAQ;AACzC,WAAID,IAAiBD,EAAWH,GAAUI,EAAS,MAAM,CAAC,CAAC,IACpD;AAAA,EACT;AACF;AACA,MAAMC,IAAW;AACjB,SAASF,EAAWG,GAAUC,GAAQ;AACpC,QAAMC,IAAQ,EAAED,EAAO,CAAC,KAAK,IACvBE,IAAU,EAAEF,EAAO,CAAC,KAAK,IAEzBG,IAAU,EAAEH,EAAO,CAAC,KAAK,KAAK;AACpC,SAAOT,EAAYQ,CAAQ,IAAIE,IAAQ,KAAKC,IAAU,IAAID,IAAQ,KAAKC,IAAUC,IAAUF,IAAQ,KAAKC,IAAUC;AACpH;","x_google_ignoreList":[0]}

package/dist/index280.js

@@ -1,20 +1,20 @@
-import I from "./index164.js";
-import { VALID_DIGITS as l } from "./index160.js";
-var c = new RegExp("([" + l + "])");
-function D(t, r, f, n) {
-  if (r) {
-    var a = new I(n);
-    a.selectNumberingPlan(r, f);
-    var i = new RegExp(a.IDDPrefix());
-    if (t.search(i) === 0) {
-      t = t.slice(t.match(i)[0].length);
-      var e = t.match(c);
-      if (!(e && e[1] != null && e[1].length > 0 && e[1] === "0"))
-        return t;
-    }
+import { defaultDateLib as o } from "./index127.js";
+class y {
+  constructor(t, i, s = o) {
+    this.date = t, this.displayMonth = i, this.outside = !!(i && !s.isSameMonth(t, i)), this.dateLib = s, this.isoDate = s.format(t, "yyyy-MM-dd"), this.displayMonthId = s.format(i, "yyyy-MM"), this.dateMonthId = s.format(t, "yyyy-MM");
+  }
+  /**
+   * Checks if this day is equal to another `CalendarDay`, considering both the
+   * date and the displayed month.
+   *
+   * @param day The `CalendarDay` to compare with.
+   * @returns `true` if the days are equal, otherwise `false`.
+   */
+  isEqualTo(t) {
+    return this.dateLib.isSameDay(t.date, this.date) && this.dateLib.isSameMonth(t.displayMonth, this.displayMonth);
   }
 }
 export {
-  D as default
+  y as CalendarDay
 };
 //# sourceMappingURL=index280.js.map

package/dist/index280.js.map

@@ -1 +1 @@
-{"version":3,"file":"index280.js","sources":["../../../node_modules/libphonenumber-js/es6/helpers/stripIddPrefix.js"],"sourcesContent":["import Metadata from '../metadata.js';\nimport { VALID_DIGITS } from '../constants.js';\nvar CAPTURING_DIGIT_PATTERN = new RegExp('([' + VALID_DIGITS + '])');\nexport default function stripIddPrefix(number, country, callingCode, metadata) {\n  if (!country) {\n    return;\n  }\n  // Check if the number is IDD-prefixed.\n  var countryMetadata = new Metadata(metadata);\n  countryMetadata.selectNumberingPlan(country, callingCode);\n  var IDDPrefixPattern = new RegExp(countryMetadata.IDDPrefix());\n  if (number.search(IDDPrefixPattern) !== 0) {\n    return;\n  }\n  // Strip IDD prefix.\n  number = number.slice(number.match(IDDPrefixPattern)[0].length);\n  // If there're any digits after an IDD prefix,\n  // then those digits are a country calling code.\n  // Since no country code starts with a `0`,\n  // the code below validates that the next digit (if present) is not `0`.\n  var matchedGroups = number.match(CAPTURING_DIGIT_PATTERN);\n  if (matchedGroups && matchedGroups[1] != null && matchedGroups[1].length > 0) {\n    if (matchedGroups[1] === '0') {\n      return;\n    }\n  }\n  return number;\n}\n//# sourceMappingURL=stripIddPrefix.js.map"],"names":["CAPTURING_DIGIT_PATTERN","VALID_DIGITS","stripIddPrefix","number","country","callingCode","metadata","countryMetadata","Metadata","IDDPrefixPattern","matchedGroups"],"mappings":";;AAEA,IAAIA,IAA0B,IAAI,OAAO,OAAOC,IAAe,IAAI;AACpD,SAASC,EAAeC,GAAQC,GAASC,GAAaC,GAAU;AAC7E,MAAKF,GAIL;AAAA,QAAIG,IAAkB,IAAIC,EAASF,CAAQ;AAC3C,IAAAC,EAAgB,oBAAoBH,GAASC,CAAW;AACxD,QAAII,IAAmB,IAAI,OAAOF,EAAgB,UAAS,CAAE;AAC7D,QAAIJ,EAAO,OAAOM,CAAgB,MAAM,GAIxC;AAAA,MAAAN,IAASA,EAAO,MAAMA,EAAO,MAAMM,CAAgB,EAAE,CAAC,EAAE,MAAM;AAK9D,UAAIC,IAAgBP,EAAO,MAAMH,CAAuB;AACxD,UAAI,EAAAU,KAAiBA,EAAc,CAAC,KAAK,QAAQA,EAAc,CAAC,EAAE,SAAS,KACrEA,EAAc,CAAC,MAAM;AAI3B,eAAOP;AAAA;AAAA;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"index280.js","sources":["../../../node_modules/react-day-picker/dist/esm/classes/CalendarDay.js"],"sourcesContent":["import { defaultDateLib } from \"./DateLib.js\";\n/**\n * Represents a day displayed in the calendar.\n *\n * In DayPicker, a `CalendarDay` is a wrapper around a `Date` object that\n * provides additional information about the day, such as whether it belongs to\n * the displayed month.\n */\nexport class CalendarDay {\n    constructor(date, displayMonth, dateLib = defaultDateLib) {\n        this.date = date;\n        this.displayMonth = displayMonth;\n        this.outside = Boolean(displayMonth && !dateLib.isSameMonth(date, displayMonth));\n        this.dateLib = dateLib;\n        this.isoDate = dateLib.format(date, \"yyyy-MM-dd\");\n        this.displayMonthId = dateLib.format(displayMonth, \"yyyy-MM\");\n        this.dateMonthId = dateLib.format(date, \"yyyy-MM\");\n    }\n    /**\n     * Checks if this day is equal to another `CalendarDay`, considering both the\n     * date and the displayed month.\n     *\n     * @param day The `CalendarDay` to compare with.\n     * @returns `true` if the days are equal, otherwise `false`.\n     */\n    isEqualTo(day) {\n        return (this.dateLib.isSameDay(day.date, this.date) &&\n            this.dateLib.isSameMonth(day.displayMonth, this.displayMonth));\n    }\n}\n"],"names":["CalendarDay","date","displayMonth","dateLib","defaultDateLib","day"],"mappings":";AAQO,MAAMA,EAAY;AAAA,EACrB,YAAYC,GAAMC,GAAcC,IAAUC,GAAgB;AACtD,SAAK,OAAOH,GACZ,KAAK,eAAeC,GACpB,KAAK,UAAU,GAAQA,KAAgB,CAACC,EAAQ,YAAYF,GAAMC,CAAY,IAC9E,KAAK,UAAUC,GACf,KAAK,UAAUA,EAAQ,OAAOF,GAAM,YAAY,GAChD,KAAK,iBAAiBE,EAAQ,OAAOD,GAAc,SAAS,GAC5D,KAAK,cAAcC,EAAQ,OAAOF,GAAM,SAAS;AAAA,EACrD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,UAAUI,GAAK;AACX,WAAQ,KAAK,QAAQ,UAAUA,EAAI,MAAM,KAAK,IAAI,KAC9C,KAAK,QAAQ,YAAYA,EAAI,cAAc,KAAK,YAAY;AAAA,EACpE;AACJ;","x_google_ignoreList":[0]}

package/dist/index281.js

@@ -1,23 +1,9 @@
-const i = {
-  clipPath: "inset(50%)",
-  overflow: "hidden",
-  whiteSpace: "nowrap",
-  border: 0,
-  padding: 0,
-  width: 1,
-  height: 1,
-  margin: -1
-}, e = {
-  ...i,
-  position: "fixed",
-  top: 0,
-  left: 0
-}, t = {
-  ...i,
-  position: "absolute"
-};
+class a {
+  constructor(t, s) {
+    this.date = t, this.weeks = s;
+  }
+}
 export {
-  e as visuallyHidden,
-  t as visuallyHiddenInput
+  a as CalendarMonth
 };
 //# sourceMappingURL=index281.js.map

package/dist/index281.js.map

@@ -1 +1 @@
-{"version":3,"file":"index281.js","sources":["../../../node_modules/@base-ui/utils/esm/visuallyHidden.js"],"sourcesContent":["const visuallyHiddenBase = {\n  clipPath: 'inset(50%)',\n  overflow: 'hidden',\n  whiteSpace: 'nowrap',\n  border: 0,\n  padding: 0,\n  width: 1,\n  height: 1,\n  margin: -1\n};\nexport const visuallyHidden = {\n  ...visuallyHiddenBase,\n  position: 'fixed',\n  top: 0,\n  left: 0\n};\nexport const visuallyHiddenInput = {\n  ...visuallyHiddenBase,\n  position: 'absolute'\n};"],"names":["visuallyHiddenBase","visuallyHidden","visuallyHiddenInput"],"mappings":"AAAA,MAAMA,IAAqB;AAAA,EACzB,UAAU;AAAA,EACV,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AACV,GACaC,IAAiB;AAAA,EAC5B,GAAGD;AAAA,EACH,UAAU;AAAA,EACV,KAAK;AAAA,EACL,MAAM;AACR,GACaE,IAAsB;AAAA,EACjC,GAAGF;AAAA,EACH,UAAU;AACZ;","x_google_ignoreList":[0]}
+{"version":3,"file":"index281.js","sources":["../../../node_modules/react-day-picker/dist/esm/classes/CalendarMonth.js"],"sourcesContent":["/**\n * Represents a month in a calendar year.\n *\n * A `CalendarMonth` contains the weeks within the month and the date of the\n * month.\n */\nexport class CalendarMonth {\n    constructor(month, weeks) {\n        this.date = month;\n        this.weeks = weeks;\n    }\n}\n"],"names":["CalendarMonth","month","weeks"],"mappings":"AAMO,MAAMA,EAAc;AAAA,EACvB,YAAYC,GAAOC,GAAO;AACtB,SAAK,OAAOD,GACZ,KAAK,QAAQC;AAAA,EACjB;AACJ;","x_google_ignoreList":[0]}

package/dist/index282.js

@@ -1,70 +1,9 @@
-import { useRefWithInit as r } from "./index283.js";
-function b(n, e, c, t) {
-  const l = r(i).current;
-  return s(l, n, e, c, t) && o(l, [n, e, c, t]), l.callback;
-}
-function h(n) {
-  const e = r(i).current;
-  return f(e, n) && o(e, n), e.callback;
-}
-function i() {
-  return {
-    callback: null,
-    cleanup: null,
-    refs: []
-  };
-}
-function s(n, e, c, t, l) {
-  return n.refs[0] !== e || n.refs[1] !== c || n.refs[2] !== t || n.refs[3] !== l;
-}
-function f(n, e) {
-  return n.refs.length !== e.length || n.refs.some((c, t) => c !== e[t]);
-}
-function o(n, e) {
-  if (n.refs = e, e.every((c) => c == null)) {
-    n.callback = null;
-    return;
+class t {
+  constructor(e, s) {
+    this.days = s, this.weekNumber = e;
   }
-  n.callback = (c) => {
-    if (n.cleanup && (n.cleanup(), n.cleanup = null), c != null) {
-      const t = Array(e.length).fill(null);
-      for (let l = 0; l < e.length; l += 1) {
-        const u = e[l];
-        if (u != null)
-          switch (typeof u) {
-            case "function": {
-              const a = u(c);
-              typeof a == "function" && (t[l] = a);
-              break;
-            }
-            case "object": {
-              u.current = c;
-              break;
-            }
-          }
-      }
-      n.cleanup = () => {
-        for (let l = 0; l < e.length; l += 1) {
-          const u = e[l];
-          if (u != null)
-            switch (typeof u) {
-              case "function": {
-                const a = t[l];
-                typeof a == "function" ? a() : u(null);
-                break;
-              }
-              case "object": {
-                u.current = null;
-                break;
-              }
-            }
-        }
-      };
-    }
-  };
 }
 export {
-  b as useMergedRefs,
-  h as useMergedRefsN
+  t as CalendarWeek
 };
 //# sourceMappingURL=index282.js.map

package/dist/index282.js.map

@@ -1 +1 @@
-{"version":3,"file":"index282.js","sources":["../../../node_modules/@base-ui/utils/esm/useMergedRefs.js"],"sourcesContent":["import { useRefWithInit } from \"./useRefWithInit.js\";\n\n/**\n * Merges refs into a single memoized callback ref or `null`.\n * This makes sure multiple refs are updated together and have the same value.\n *\n * This function accepts up to four refs. If you need to merge more, or have an unspecified number of refs to merge,\n * use `useMergedRefsN` instead.\n */\n\nexport function useMergedRefs(a, b, c, d) {\n  const forkRef = useRefWithInit(createForkRef).current;\n  if (didChange(forkRef, a, b, c, d)) {\n    update(forkRef, [a, b, c, d]);\n  }\n  return forkRef.callback;\n}\n\n/**\n * Merges an array of refs into a single memoized callback ref or `null`.\n *\n * If you need to merge a fixed number (up to four) of refs, use `useMergedRefs` instead for better performance.\n */\nexport function useMergedRefsN(refs) {\n  const forkRef = useRefWithInit(createForkRef).current;\n  if (didChangeN(forkRef, refs)) {\n    update(forkRef, refs);\n  }\n  return forkRef.callback;\n}\nfunction createForkRef() {\n  return {\n    callback: null,\n    cleanup: null,\n    refs: []\n  };\n}\nfunction didChange(forkRef, a, b, c, d) {\n  // prettier-ignore\n  return forkRef.refs[0] !== a || forkRef.refs[1] !== b || forkRef.refs[2] !== c || forkRef.refs[3] !== d;\n}\nfunction didChangeN(forkRef, newRefs) {\n  return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index) => ref !== newRefs[index]);\n}\nfunction update(forkRef, refs) {\n  forkRef.refs = refs;\n  if (refs.every(ref => ref == null)) {\n    forkRef.callback = null;\n    return;\n  }\n  forkRef.callback = instance => {\n    if (forkRef.cleanup) {\n      forkRef.cleanup();\n      forkRef.cleanup = null;\n    }\n    if (instance != null) {\n      const cleanupCallbacks = Array(refs.length).fill(null);\n      for (let i = 0; i < refs.length; i += 1) {\n        const ref = refs[i];\n        if (ref == null) {\n          continue;\n        }\n        switch (typeof ref) {\n          case 'function':\n            {\n              const refCleanup = ref(instance);\n              if (typeof refCleanup === 'function') {\n                cleanupCallbacks[i] = refCleanup;\n              }\n              break;\n            }\n          case 'object':\n            {\n              ref.current = instance;\n              break;\n            }\n          default:\n        }\n      }\n      forkRef.cleanup = () => {\n        for (let i = 0; i < refs.length; i += 1) {\n          const ref = refs[i];\n          if (ref == null) {\n            continue;\n          }\n          switch (typeof ref) {\n            case 'function':\n              {\n                const cleanupCallback = cleanupCallbacks[i];\n                if (typeof cleanupCallback === 'function') {\n                  cleanupCallback();\n                } else {\n                  ref(null);\n                }\n                break;\n              }\n            case 'object':\n              {\n                ref.current = null;\n                break;\n              }\n            default:\n          }\n        }\n      };\n    }\n  };\n}"],"names":["useMergedRefs","a","b","d","forkRef","useRefWithInit","createForkRef","didChange","update","useMergedRefsN","refs","didChangeN","c","newRefs","ref","index","instance","cleanupCallbacks","i","refCleanup","cleanupCallback"],"mappings":";AAUO,SAASA,EAAcC,GAAGC,GAAG,GAAGC,GAAG;AACxC,QAAMC,IAAUC,EAAeC,CAAa,EAAE;AAC9C,SAAIC,EAAUH,GAASH,GAAGC,GAAG,GAAGC,CAAC,KAC/BK,EAAOJ,GAAS,CAACH,GAAGC,GAAG,GAAGC,CAAC,CAAC,GAEvBC,EAAQ;AACjB;AAOO,SAASK,EAAeC,GAAM;AACnC,QAAMN,IAAUC,EAAeC,CAAa,EAAE;AAC9C,SAAIK,EAAWP,GAASM,CAAI,KAC1BF,EAAOJ,GAASM,CAAI,GAEfN,EAAQ;AACjB;AACA,SAASE,IAAgB;AACvB,SAAO;AAAA,IACL,UAAU;AAAA,IACV,SAAS;AAAA,IACT,MAAM,CAAA;AAAA,EACV;AACA;AACA,SAASC,EAAUH,GAASH,GAAGC,GAAGU,GAAGT,GAAG;AAEtC,SAAOC,EAAQ,KAAK,CAAC,MAAMH,KAAKG,EAAQ,KAAK,CAAC,MAAMF,KAAKE,EAAQ,KAAK,CAAC,MAAMQ,KAAKR,EAAQ,KAAK,CAAC,MAAMD;AACxG;AACA,SAASQ,EAAWP,GAASS,GAAS;AACpC,SAAOT,EAAQ,KAAK,WAAWS,EAAQ,UAAUT,EAAQ,KAAK,KAAK,CAACU,GAAKC,MAAUD,MAAQD,EAAQE,CAAK,CAAC;AAC3G;AACA,SAASP,EAAOJ,GAASM,GAAM;AAE7B,MADAN,EAAQ,OAAOM,GACXA,EAAK,MAAM,CAAAI,MAAOA,KAAO,IAAI,GAAG;AAClC,IAAAV,EAAQ,WAAW;AACnB;AAAA,EACF;AACA,EAAAA,EAAQ,WAAW,CAAAY,MAAY;AAK7B,QAJIZ,EAAQ,YACVA,EAAQ,QAAO,GACfA,EAAQ,UAAU,OAEhBY,KAAY,MAAM;AACpB,YAAMC,IAAmB,MAAMP,EAAK,MAAM,EAAE,KAAK,IAAI;AACrD,eAASQ,IAAI,GAAGA,IAAIR,EAAK,QAAQQ,KAAK,GAAG;AACvC,cAAMJ,IAAMJ,EAAKQ,CAAC;AAClB,YAAIJ,KAAO;AAGX,kBAAQ,OAAOA,GAAG;AAAA,YAChB,KAAK,YACH;AACE,oBAAMK,IAAaL,EAAIE,CAAQ;AAC/B,cAAI,OAAOG,KAAe,eACxBF,EAAiBC,CAAC,IAAIC;AAExB;AAAA,YACF;AAAA,YACF,KAAK,UACH;AACE,cAAAL,EAAI,UAAUE;AACd;AAAA,YACF;AAAA,UAEZ;AAAA,MACM;AACA,MAAAZ,EAAQ,UAAU,MAAM;AACtB,iBAASc,IAAI,GAAGA,IAAIR,EAAK,QAAQQ,KAAK,GAAG;AACvC,gBAAMJ,IAAMJ,EAAKQ,CAAC;AAClB,cAAIJ,KAAO;AAGX,oBAAQ,OAAOA,GAAG;AAAA,cAChB,KAAK,YACH;AACE,sBAAMM,IAAkBH,EAAiBC,CAAC;AAC1C,gBAAI,OAAOE,KAAoB,aAC7BA,EAAe,IAEfN,EAAI,IAAI;AAEV;AAAA,cACF;AAAA,cACF,KAAK,UACH;AACE,gBAAAA,EAAI,UAAU;AACd;AAAA,cACF;AAAA,YAEd;AAAA,QACQ;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","x_google_ignoreList":[0]}
+{"version":3,"file":"index282.js","sources":["../../../node_modules/react-day-picker/dist/esm/classes/CalendarWeek.js"],"sourcesContent":["/**\n * Represents a week in a calendar month.\n *\n * A `CalendarWeek` contains the days within the week and the week number.\n */\nexport class CalendarWeek {\n    constructor(weekNumber, days) {\n        this.days = days;\n        this.weekNumber = weekNumber;\n    }\n}\n"],"names":["CalendarWeek","weekNumber","days"],"mappings":"AAKO,MAAMA,EAAa;AAAA,EACtB,YAAYC,GAAYC,GAAM;AAC1B,SAAK,OAAOA,GACZ,KAAK,aAAaD;AAAA,EACtB;AACJ;","x_google_ignoreList":[0]}

package/dist/index283.js

@@ -1,10 +1,10 @@
-import * as c from "react";
-const e = {};
-function f(r, n) {
-  const t = c.useRef(e);
-  return t.current === e && (t.current = r(n)), t;
+import { getBroadcastWeeksInMonth as n } from "./index370.js";
+import { startOfBroadcastWeek as s } from "./index284.js";
+function d(e, t) {
+  const o = s(e, t), r = n(e, t);
+  return t.addDays(o, r * 7 - 1);
 }
 export {
-  f as useRefWithInit
+  d as endOfBroadcastWeek
 };
 //# sourceMappingURL=index283.js.map

package/dist/index283.js.map

@@ -1 +1 @@
-{"version":3,"file":"index283.js","sources":["../../../node_modules/@base-ui/utils/esm/useRefWithInit.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nconst UNINITIALIZED = {};\n\n/**\n * A React.useRef() that is initialized with a function. Note that it accepts an optional\n * initialization argument, so the initialization function doesn't need to be an inline closure.\n *\n * @usage\n *   const ref = useRefWithInit(sortColumns, columns)\n */\n\nexport function useRefWithInit(init, initArg) {\n  const ref = React.useRef(UNINITIALIZED);\n  if (ref.current === UNINITIALIZED) {\n    ref.current = init(initArg);\n  }\n  return ref;\n}"],"names":["UNINITIALIZED","useRefWithInit","init","initArg","ref","React"],"mappings":";AAGA,MAAMA,IAAgB,CAAA;AAUf,SAASC,EAAeC,GAAMC,GAAS;AAC5C,QAAMC,IAAMC,EAAM,OAAOL,CAAa;AACtC,SAAII,EAAI,YAAYJ,MAClBI,EAAI,UAAUF,EAAKC,CAAO,IAErBC;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"index283.js","sources":["../../../node_modules/react-day-picker/dist/esm/helpers/endOfBroadcastWeek.js"],"sourcesContent":["import { getBroadcastWeeksInMonth } from \"./getBroadcastWeeksInMonth.js\";\nimport { startOfBroadcastWeek } from \"./startOfBroadcastWeek.js\";\n/**\n * Returns the end date of the week in the broadcast calendar.\n *\n * The broadcast week ends on the last day of the last broadcast week for the\n * given date.\n *\n * @since 9.4.0\n * @param date The date for which to calculate the end of the broadcast week.\n * @param dateLib The date library to use for date manipulation.\n * @returns The end date of the broadcast week.\n */\nexport function endOfBroadcastWeek(date, dateLib) {\n    const startDate = startOfBroadcastWeek(date, dateLib);\n    const numberOfWeeks = getBroadcastWeeksInMonth(date, dateLib);\n    const endDate = dateLib.addDays(startDate, numberOfWeeks * 7 - 1);\n    return endDate;\n}\n"],"names":["endOfBroadcastWeek","date","dateLib","startDate","startOfBroadcastWeek","numberOfWeeks","getBroadcastWeeksInMonth"],"mappings":";;AAaO,SAASA,EAAmBC,GAAMC,GAAS;AAC9C,QAAMC,IAAYC,EAAqBH,GAAMC,CAAO,GAC9CG,IAAgBC,EAAyBL,GAAMC,CAAO;AAE5D,SADgBA,EAAQ,QAAQC,GAAWE,IAAgB,IAAI,CAAC;AAEpE;","x_google_ignoreList":[0]}

package/dist/index284.js

@@ -1,15 +1,8 @@
-import * as u from "react";
-function s(r) {
-  const [t, e] = u.useState({
-    current: r,
-    previous: null
-  });
-  return r !== t.current && e({
-    current: r,
-    previous: t.current
-  }), t.previous;
+function n(s, e) {
+  const t = e.startOfMonth(s), r = t.getDay();
+  return r === 1 ? t : r === 0 ? e.addDays(t, -6) : e.addDays(t, -1 * (r - 1));
 }
 export {
-  s as usePreviousValue
+  n as startOfBroadcastWeek
 };
 //# sourceMappingURL=index284.js.map

package/dist/index284.js.map

@@ -1 +1 @@
-{"version":3,"file":"index284.js","sources":["../../../node_modules/@base-ui/utils/esm/usePreviousValue.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\n\n/**\n * Returns a previous value of its argument.\n * @param value Current value.\n * @returns Previous value, or null if there is no previous value.\n */\nexport function usePreviousValue(value) {\n  const [state, setState] = React.useState({\n    current: value,\n    previous: null\n  });\n  if (value !== state.current) {\n    setState({\n      current: value,\n      previous: state.current\n    });\n  }\n  return state.previous;\n}"],"names":["usePreviousValue","value","state","setState","React"],"mappings":";AASO,SAASA,EAAiBC,GAAO;AACtC,QAAM,CAACC,GAAOC,CAAQ,IAAIC,EAAM,SAAS;AAAA,IACvC,SAASH;AAAA,IACT,UAAU;AAAA,EACd,CAAG;AACD,SAAIA,MAAUC,EAAM,WAClBC,EAAS;AAAA,IACP,SAASF;AAAA,IACT,UAAUC,EAAM;AAAA,EACtB,CAAK,GAEIA,EAAM;AACf;","x_google_ignoreList":[0]}
+{"version":3,"file":"index284.js","sources":["../../../node_modules/react-day-picker/dist/esm/helpers/startOfBroadcastWeek.js"],"sourcesContent":["/**\n * Returns the start date of the week in the broadcast calendar.\n *\n * The broadcast week starts on Monday. If the first day of the month is not a\n * Monday, this function calculates the previous Monday as the start of the\n * broadcast week.\n *\n * @since 9.4.0\n * @param date The date for which to calculate the start of the broadcast week.\n * @param dateLib The date library to use for date manipulation.\n * @returns The start date of the broadcast week.\n */\nexport function startOfBroadcastWeek(date, dateLib) {\n    const firstOfMonth = dateLib.startOfMonth(date);\n    const dayOfWeek = firstOfMonth.getDay();\n    if (dayOfWeek === 1) {\n        return firstOfMonth;\n    }\n    else if (dayOfWeek === 0) {\n        return dateLib.addDays(firstOfMonth, -1 * 6);\n    }\n    else {\n        return dateLib.addDays(firstOfMonth, -1 * (dayOfWeek - 1));\n    }\n}\n"],"names":["startOfBroadcastWeek","date","dateLib","firstOfMonth","dayOfWeek"],"mappings":"AAYO,SAASA,EAAqBC,GAAMC,GAAS;AAChD,QAAMC,IAAeD,EAAQ,aAAaD,CAAI,GACxCG,IAAYD,EAAa,OAAM;AACrC,SAAIC,MAAc,IACPD,IAEFC,MAAc,IACZF,EAAQ,QAAQC,GAAc,EAAM,IAGpCD,EAAQ,QAAQC,GAAc,MAAMC,IAAY,EAAE;AAEjE;","x_google_ignoreList":[0]}

package/dist/index285.js

@@ -1,54 +1,10 @@
-import * as r from "react";
-import { error as l } from "./index355.js";
-function _({
-  controlled: n,
-  default: o,
-  name: t,
-  state: s = "value"
-}) {
-  const {
-    current: i
-  } = r.useRef(n !== void 0), [f, e] = r.useState(o), c = i ? n : f;
-  if (process.env.NODE_ENV !== "production") {
-    r.useEffect(() => {
-      i !== (n !== void 0) && l([`A component is changing the ${i ? "" : "un"}controlled ${s} state of ${t} to be ${i ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${t} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
-`));
-    }, [s, t, n]);
-    const {
-      current: u
-    } = r.useRef(o);
-    r.useEffect(() => {
-      !i && d(u) !== d(o) && l([`A component is changing the default ${s} state of an uncontrolled ${t} after being initialized. To suppress this warning opt to use a controlled ${t}.`].join(`
-`));
-    }, [o]);
-  }
-  const a = r.useCallback((u) => {
-    i || e(u);
-  }, []);
-  return [c, a];
-}
-function d(n) {
-  let o = 0;
-  const t = /* @__PURE__ */ new WeakMap();
-  try {
-    return JSON.stringify(n, function(f, e) {
-      if (!(f === "_owner" && this != null && typeof this == "object" && "$$typeof" in this)) {
-        if (typeof e == "bigint")
-          return `__bigint__:${e}`;
-        if (e !== null && typeof e == "object") {
-          const c = t.get(e);
-          if (c !== void 0)
-            return `__object__:${c}`;
-          t.set(e, o), o += 1;
-        }
-        return e;
-      }
-    }) ?? `__top__:${typeof n}`;
-  } catch {
-    return "__unserializable__";
-  }
+import { constructFrom as i } from "./index389.js";
+import { toDate as n } from "./index390.js";
+function s(e, r, o) {
+  const t = n(e, o?.in);
+  return isNaN(r) ? i(e, NaN) : (r && t.setDate(t.getDate() + r), t);
 }
 export {
-  _ as useControlled
+  s as addDays
 };
 //# sourceMappingURL=index285.js.map