@acronis-platform/shadcn-uikit 0.34.0 → 0.36.3

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/lib/utils.js

@@ -1,5 +1,5 @@
 import { clsx as o } from "../node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
-import { twMerge as t } from "../node_modules/.pnpm/tailwind-merge@2.6.0/node_modules/tailwind-merge/dist/bundle-mjs.js";
+import { twMerge as t } from "../node_modules/.pnpm/tailwind-merge@3.6.0/node_modules/tailwind-merge/dist/bundle-mjs.js";
 function n(...r) {
   return t(o(r));
 }

package/dist/lib/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../src/lib/utils.ts"],"sourcesContent":["import { type ClassValue, clsx } from 'clsx'\nimport { twMerge } from 'tailwind-merge'\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs))\n}\n"],"names":["cn","inputs","twMerge","clsx"],"mappings":";;AAGO,SAASA,KAAMC,GAAsB;AAC1C,SAAOC,EAAQC,EAAKF,CAAM,CAAC;AAC7B;"}
+{"version":3,"file":"utils.js","sources":["../../src/lib/utils.ts"],"sourcesContent":["import { type ClassValue, clsx } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}\n"],"names":["cn","inputs","twMerge","clsx"],"mappings":";;AAGO,SAASA,KAAMC,GAAsB;AAC1C,SAAOC,EAAQC,EAAKF,CAAM,CAAC;AAC7B;"}

package/dist/llms.txt

@@ -20,9 +20,9 @@ A React component library built on shadcn/ui principles with Radix UI primitives
 
 ## Getting Started
 
-- [Installation Guide](https://github.com/acronis/shadcn-uikit/blob/main/packages/docs/GETTING_STARTED.md): Complete setup instructions with Tailwind configuration
-- [Architecture Overview](https://github.com/acronis/shadcn-uikit/blob/main/packages/docs/ARCHITECTURE.md): Project structure and design decisions
-- [Main README](https://github.com/acronis/shadcn-uikit/blob/main/README.md): Project overview and quick start
+- [Installation Guide](https://github.com/acronis/uikit/blob/main/apps/docs/GETTING_STARTED.md): Complete setup instructions with Tailwind configuration
+- [Architecture Overview](https://github.com/acronis/uikit/blob/main/apps/docs/ARCHITECTURE.md): Project structure and design decisions
+- [Main README](https://github.com/acronis/uikit/blob/main/README.md): Project overview and quick start
 
 ## Usage Examples
 
@@ -135,7 +135,7 @@ import { Dialog, DialogTrigger, DialogContent, DialogHeader, DialogTitle, Button
 
 ## Styling & Customization
 
-- [Tailwind Configuration](https://github.com/acronis/shadcn-uikit/blob/main/packages/docs/GETTING_STARTED.md#configure-tailwind-css): Required Tailwind setup
+- [Tailwind Configuration](https://github.com/acronis/uikit/blob/main/apps/docs/GETTING_STARTED.md#configure-tailwind-css): Required Tailwind setup
 - CSS Variables: Override theme colors using `--av-primary`, `--av-background`, etc.
 - Dark Mode: Add `dark` class to root element
 - Custom Variants: Use `cn()` utility to merge classes

package/dist/node_modules/.pnpm/@date-fns_tz@1.5.0/node_modules/@date-fns/tz/date/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/@date-fns+tz@1.5.0/node_modules/@date-fns/tz/date/index.js"],"sourcesContent":["import { tzName } from \"../tzName/index.js\";\nimport { TZDateMini } from \"./mini.js\";\nexport class TZDate extends TZDateMini {\n  //#region static\n\n  static tz(tz, ...args) {\n    return args.length ? new TZDate(...args, tz) : new TZDate(Date.now(), tz);\n  }\n\n  //#endregion\n\n  //#region representation\n\n  toISOString() {\n    const [sign, hours, minutes] = this.tzComponents();\n    const tz = `${sign}${hours}:${minutes}`;\n    return this.internal.toISOString().slice(0, -1) + tz;\n  }\n  toString() {\n    // \"Tue Aug 13 2024 07:50:19 GMT+0800 (Singapore Standard Time)\";\n    return `${this.toDateString()} ${this.toTimeString()}`;\n  }\n  toDateString() {\n    // toUTCString returns RFC 7231 (\"Mon, 12 Aug 2024 23:36:08 GMT\")\n    const [day, date, month, year] = this.internal.toUTCString().split(\" \");\n    // \"Tue Aug 13 2024\"\n    return `${day?.slice(0, -1) /* Remove \",\" */} ${month} ${date} ${year}`;\n  }\n  toTimeString() {\n    // toUTCString returns RFC 7231 (\"Mon, 12 Aug 2024 23:36:08 GMT\")\n    const time = this.internal.toUTCString().split(\" \")[4];\n    const [sign, hours, minutes] = this.tzComponents();\n    // \"07:42:23 GMT+0800 (Singapore Standard Time)\"\n    return `${time} GMT${sign}${hours}${minutes} (${tzName(this.timeZone, this)})`;\n  }\n  toLocaleString(locales, options) {\n    return Date.prototype.toLocaleString.call(this, locales, {\n      ...options,\n      timeZone: options?.timeZone || this.timeZone\n    });\n  }\n  toLocaleDateString(locales, options) {\n    return Date.prototype.toLocaleDateString.call(this, locales, {\n      ...options,\n      timeZone: options?.timeZone || this.timeZone\n    });\n  }\n  toLocaleTimeString(locales, options) {\n    return Date.prototype.toLocaleTimeString.call(this, locales, {\n      ...options,\n      timeZone: options?.timeZone || this.timeZone\n    });\n  }\n\n  //#endregion\n\n  //#region private\n\n  tzComponents() {\n    const offset = this.getTimezoneOffset();\n    const sign = offset > 0 ? \"-\" : \"+\";\n    const hours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, \"0\");\n    const minutes = String(Math.abs(offset) % 60).padStart(2, \"0\");\n    return [sign, hours, minutes];\n  }\n\n  //#endregion\n\n  withTimeZone(timeZone) {\n    return new TZDate(+this, timeZone);\n  }\n\n  //#region date-fns integration\n\n  [Symbol.for(\"constructDateFrom\")](date) {\n    return new TZDate(+new Date(date), this.timeZone);\n  }\n\n  //#endregion\n}"],"names":["TZDate","TZDateMini","tz","args","sign","hours","minutes","day","date","month","year","time","tzName","locales","options","offset","timeZone"],"mappings":";;AAEO,MAAMA,UAAeC,EAAW;AAAA;AAAA,EAGrC,OAAO,GAAGC,MAAOC,GAAM;AACrB,WAAOA,EAAK,SAAS,IAAIH,EAAO,GAAGG,GAAMD,CAAE,IAAI,IAAIF,EAAO,KAAK,IAAG,GAAIE,CAAE;AAAA,EAC1E;AAAA;AAAA;AAAA,EAMA,cAAc;AACZ,UAAM,CAACE,GAAMC,GAAOC,CAAO,IAAI,KAAK,aAAY,GAC1CJ,IAAK,GAAGE,CAAI,GAAGC,CAAK,IAAIC,CAAO;AACrC,WAAO,KAAK,SAAS,YAAW,EAAG,MAAM,GAAG,EAAE,IAAIJ;AAAA,EACpD;AAAA,EACA,WAAW;AAET,WAAO,GAAG,KAAK,aAAY,CAAE,IAAI,KAAK,aAAY,CAAE;AAAA,EACtD;AAAA,EACA,eAAe;AAEb,UAAM,CAACK,GAAKC,GAAMC,GAAOC,CAAI,IAAI,KAAK,SAAS,cAAc,MAAM,GAAG;AAEtE,WAAO,GAAGH,KAAA,gBAAAA,EAAK,MAAM,GAAG,GAAG,IAAqBE,CAAK,IAAID,CAAI,IAAIE,CAAI;AAAA,EACvE;AAAA,EACA,eAAe;AAEb,UAAMC,IAAO,KAAK,SAAS,YAAW,EAAG,MAAM,GAAG,EAAE,CAAC,GAC/C,CAACP,GAAMC,GAAOC,CAAO,IAAI,KAAK,aAAY;AAEhD,WAAO,GAAGK,CAAI,OAAOP,CAAI,GAAGC,CAAK,GAAGC,CAAO,KAAKM,EAAO,KAAK,UAAU,IAAI,CAAC;AAAA,EAC7E;AAAA,EACA,eAAeC,GAASC,GAAS;AAC/B,WAAO,KAAK,UAAU,eAAe,KAAK,MAAMD,GAAS;AAAA,MACvD,GAAGC;AAAA,MACH,WAAUA,KAAA,gBAAAA,EAAS,aAAY,KAAK;AAAA,IAC1C,CAAK;AAAA,EACH;AAAA,EACA,mBAAmBD,GAASC,GAAS;AACnC,WAAO,KAAK,UAAU,mBAAmB,KAAK,MAAMD,GAAS;AAAA,MAC3D,GAAGC;AAAA,MACH,WAAUA,KAAA,gBAAAA,EAAS,aAAY,KAAK;AAAA,IAC1C,CAAK;AAAA,EACH;AAAA,EACA,mBAAmBD,GAASC,GAAS;AACnC,WAAO,KAAK,UAAU,mBAAmB,KAAK,MAAMD,GAAS;AAAA,MAC3D,GAAGC;AAAA,MACH,WAAUA,KAAA,gBAAAA,EAAS,aAAY,KAAK;AAAA,IAC1C,CAAK;AAAA,EACH;AAAA;AAAA;AAAA,EAMA,eAAe;AACb,UAAMC,IAAS,KAAK,kBAAiB,GAC/BX,IAAOW,IAAS,IAAI,MAAM,KAC1BV,IAAQ,OAAO,KAAK,MAAM,KAAK,IAAIU,CAAM,IAAI,EAAE,CAAC,EAAE,SAAS,GAAG,GAAG,GACjET,IAAU,OAAO,KAAK,IAAIS,CAAM,IAAI,EAAE,EAAE,SAAS,GAAG,GAAG;AAC7D,WAAO,CAACX,GAAMC,GAAOC,CAAO;AAAA,EAC9B;AAAA;AAAA,EAIA,aAAaU,GAAU;AACrB,WAAO,IAAIhB,EAAO,CAAC,MAAMgB,CAAQ;AAAA,EACnC;AAAA;AAAA,EAIA,CAAC,OAAO,IAAI,mBAAmB,CAAC,EAAER,GAAM;AACtC,WAAO,IAAIR,EAAO,CAAC,IAAI,KAAKQ,CAAI,GAAG,KAAK,QAAQ;AAAA,EAClD;AAAA;AAGF;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@date-fns_tz@1.5.0/node_modules/@date-fns/tz/date/mini.js

@@ -0,0 +1,91 @@
+import { tzOffset as s } from "../tzOffset/index.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
+  [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 {
+  o as TZDateMini
+};
+//# sourceMappingURL=mini.js.map

package/dist/node_modules/.pnpm/@date-fns_tz@1.5.0/node_modules/@date-fns/tz/date/mini.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mini.js","sources":["../../../../../../../../../../node_modules/.pnpm/@date-fns+tz@1.5.0/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":";AA2BO,MAAMA,UAAmB,KAAK;AAAA;AAAA,EAGnC,eAAeC,GAAM;AACnB,UAAK,GAIDA,EAAK,SAAS,KAAK,OAAOA,EAAKA,EAAK,SAAS,CAAC,KAAM,aACtD,KAAK,WAAWA,EAAK,IAAG,IAE1B,KAAK,WAAW,oBAAI,KAAI,GAGpB,MAAMC,EAAS,KAAK,UAAU,IAAI,CAAC,IACrC,KAAK,QAAQ,GAAG,IAEXD,EAAK,SAGC,OAAOA,EAAK,CAAC,KAAM,aAAaA,EAAK,WAAW,KAAKA,EAAK,WAAW,KAAK,OAAOA,EAAK,CAAC,KAAM,YAEtG,KAAK,QAAQA,EAAK,CAAC,CAAC,IACX,OAAOA,EAAK,CAAC,KAAM,WAE5B,KAAK,QAAQ,CAAC,IAAI,KAAKA,EAAK,CAAC,CAAC,CAAC,IACtBA,EAAK,CAAC,aAAa,OAE5B,KAAK,QAAQ,CAACA,EAAK,CAAC,CAAC,KAKrB,KAAK,QAAQ,CAAC,IAAI,KAAK,GAAGA,CAAI,CAAC,GAI/BE,EAAiB,MAAMF,CAAI,KAlB3B,KAAK,QAAQ,KAAK,KAAK;AAAA,EAqB7B;AAAA,EACA,OAAO,GAAGG,MAAOH,GAAM;AACrB,WAAOA,EAAK,SAAS,IAAID,EAAW,GAAGC,GAAMG,CAAE,IAAI,IAAIJ,EAAW,KAAK,IAAG,GAAII,CAAE;AAAA,EAClF;AAAA;AAAA;AAAA,EAMA,aAAaC,GAAU;AACrB,WAAO,IAAIL,EAAW,CAAC,MAAMK,CAAQ;AAAA,EACvC;AAAA,EACA,oBAAoB;AAClB,UAAMC,IAAS,CAACJ,EAAS,KAAK,UAAU,IAAI;AAG5C,WAAOI,IAAS,IAAI,KAAK,MAAMA,CAAM,IAAI,KAAK,KAAKA,CAAM;AAAA,EAC3D;AAAA;AAAA;AAAA,EAMA,QAAQC,GAAO;AAEb,gBAAK,UAAU,QAAQ,MAAM,MAAM,SAAS,GAG5CC,EAAe,IAAI,GACZ,CAAC;AAAA,EACV;AAAA;AAAA;AAAA,EAMA,CAAC,OAAO,IAAI,mBAAmB,CAAC,EAAEC,GAAM;AACtC,WAAO,IAAIT,EAAW,CAAC,IAAI,KAAKS,CAAI,GAAG,KAAK,QAAQ;AAAA,EACtD;AAAA;AAGF;AAGA,MAAMC,IAAK;AACX,OAAO,oBAAoB,KAAK,SAAS,EAAE,QAAQ,CAAAC,MAAU;AAC3D,MAAI,CAACD,EAAG,KAAKC,CAAM,EAAG;AACtB,QAAMC,IAAYD,EAAO,QAAQD,GAAI,OAAO;AAE5C,EAAKV,EAAW,UAAUY,CAAS,MAC/BD,EAAO,WAAW,KAAK,IAEzBX,EAAW,UAAUW,CAAM,IAAI,WAAY;AACzC,WAAO,KAAK,SAASC,CAAS,EAAC;AAAA,EACjC,KAGAZ,EAAW,UAAUW,CAAM,IAAI,WAAY;AACzC,gBAAK,UAAUC,CAAS,EAAE,MAAM,KAAK,UAAU,SAAS,GACxDC,EAAiB,IAAI,GACd,CAAC;AAAA,EACV,GAGAb,EAAW,UAAUY,CAAS,IAAI,WAAY;AAC5C,gBAAK,UAAUA,CAAS,EAAE,MAAM,MAAM,SAAS,GAC/CJ,EAAe,IAAI,GACZ,CAAC;AAAA,EACV;AAEJ,CAAC;AAQD,SAASA,EAAeC,GAAM;AAE5B,EAAAA,EAAK,SAAS,QAAQ,CAACA,CAAI,GAW3BA,EAAK,SAAS,cAAcA,EAAK,SAAS,cAAa;AAAA;AAAA,EAGvD,KAAK,MAAM,CAACP,EAASO,EAAK,UAAUA,CAAI,IAAI,EAAE,CAAC;AACjD;AAQA,SAASI,EAAiBJ,GAAM;AAI9B,OAAK,UAAU,YAAY,KAAKA,GAAMA,EAAK,SAAS,eAAc,GAAIA,EAAK,SAAS,YAAW,GAAIA,EAAK,SAAS,YAAY,GAC7H,KAAK,UAAU,SAAS,KAAKA,GAAMA,EAAK,SAAS,eAAeA,EAAK,SAAS,cAAa,GAAIA,EAAK,SAAS,cAAa,GAAIA,EAAK,SAAS,oBAAoB,GAGhKN,EAAiBM,CAAI;AACvB;AAYA,SAASN,EAAiBM,GAAMK,GAAiB;AAI/C,QAAMC,IAAuB,MAAM,QAAQD,CAAe,IAAIE,EAA8BF,CAAe,IAAI,CAACL,EAAK,UAK/GQ,IAAoBf,EAASO,EAAK,UAAUA,CAAI,GAKhDH,IAASW,IAAoB,IAAI,KAAK,MAAMA,CAAiB,IAAI,KAAK,KAAKA,CAAiB,GAgB5FC,IAAW,oBAAI,KAAK,CAACT,CAAI;AAI/B,EAAAS,EAAS,YAAYA,EAAS,YAAW,IAAK,CAAC;AAG/C,QAAMC,IAAe,EAAC,oBAAI,KAAK,CAACV,CAAI,GAAE,kBAAiB,GAGjDW,IAAuB,EAAC,oBAAI,KAAK,CAACF,CAAQ,GAAE,kBAAiB,GAG7DG,IAAkBF,IAAeC;AAKvC,MAAIE,IAAsBH;AAC1B,MAAIE,KAAmBF,MAAiBb,GAAQ;AAE9C,UAAMiB,IAAa,KAAK,UAAU,SAAS,MAAMd,CAAI,GAK/Ce,IAAe,MAAM,QAAQV,CAAe,IAAIA,EAAgB,CAAC,KAAK,IAAIL,EAAK,SAAS,YAAW;AACzG,QAAIc,MAAeC,GAAc;AAI/B,YAAMC,IAAW,oBAAI,KAAK,CAAChB,CAAI,GAIzBiB,IAAiBP,IAAeb;AACtC,MAAIoB,KAAgBD,EAAS,cAAcA,EAAS,cAAa,IAAKC,CAAc;AAGpF,YAAMC,IAAwBzB,EAASO,EAAK,UAAUgB,CAAQ;AAI9D,OADmBE,IAAwB,IAAI,KAAK,MAAMA,CAAqB,IAAI,KAAK,KAAKA,CAAqB,OAC/FrB,MAAQgB,IAAsBF;AAAA,IACnD;AAAA,EACF;AAiBA,QAAMQ,IAAaN,IAAsBhB;AACzC,EAAIsB,KAWF,KAAK,UAAU,cAAc,KAAKnB,GAAM,KAAK,UAAU,cAAc,KAAKA,CAAI,IAAImB,CAAU;AAgB9F,QAAMC,IAAa,oBAAI,KAAK,CAACpB,CAAI;AAKjC,EAAAoB,EAAW,cAAc,CAAC;AAI1B,QAAMC,IAAsBX,IAAe,IAAIU,EAAW,gBAAgBA,EAAW,eAAe,MAAM,IAGpGE,IAAgB,KAAK,MAAM,EAAE7B,EAASO,EAAK,UAAUA,CAAI,IAAI,GAAG,IAAI;AAC1E,GAAIsB,KAAiBD,MAUnB,KAAK,UAAU,cAAc,KAAKrB,GAAM,KAAK,UAAU,cAAc,KAAKA,CAAI,IAAIsB,IAAgBD,CAAmB;AAevH,QAAME,IAAwB9B,EAASO,EAAK,UAAUA,CAAI,GAGpDwB,IAAaD,IAAwB,IAAI,KAAK,MAAMA,CAAqB,IAAI,KAAK,KAAKA,CAAqB,GAM5GE,IAHmB,EAAC,oBAAI,KAAK,CAACzB,CAAI,GAAE,kBAAiB,IAGjBwB,GAGpCE,IAAgBF,MAAe3B,GAG/B8B,IAAWF,IAAiBN,GAM5BS,IAAiBJ,IAAa3B,GAK9BgC,IAAsBvB,IAAuBkB,IAAa,KAAK,KAI/DM,IAAyBF,IAAiB,KAAKG,EAAmB/B,CAAI,IAAIM,MAAyBsB,IAAiB,KAAK,OAAQG,EAAmB/B,GAAM6B,CAAmB,MAAMvB;AACzL,MAAIoB,KAAiBC,KAAY,CAACG,GAAwB;AAWxD,SAAK,UAAU,cAAc,KAAK9B,GAAM,KAAK,UAAU,cAAc,KAAKA,CAAI,IAAI2B,CAAQ;AAI1F,UAAMK,IAAuBvC,EAASO,EAAK,UAAUA,CAAI,GAGnDiC,IAAYD,IAAuB,IAAI,KAAK,MAAMA,CAAoB,IAAI,KAAK,KAAKA,CAAoB,GAGxGE,IAAeV,IAAaS;AAMlC,IAAIC,KAAgBP,IAAW,KAS7B,KAAK,UAAU,cAAc,KAAK3B,GAAM,KAAK,UAAU,cAAc,KAAKA,CAAI,IAAIkC,CAAY;AAAA,EAElG;AAKA,EAAAnC,EAAeC,CAAI;AAMnB,QAAMmC,KADe9B,IAAkBC,IAAuBA,IAAuBgB,IAAgB,OACxE,CAACtB,EAAK;AACnC,EAAImC,KAAS,KAAK,IAAIA,CAAK,IAAI,OAAU,QACvC,KAAK,UAAU,QAAQ,KAAKnC,GAAM,CAACA,IAAOmC,CAAK,GAC/CpC,EAAeC,CAAI;AAEvB;AACA,SAASO,EAA8Bf,GAAM;AAI3C,SAAO,KAAK,IAAIA,EAAK,CAAC,GAAGA,EAAK,SAAS,IAAIA,EAAK,CAAC,IAAI,GAAGA,EAAK,SAAS,IAAIA,EAAK,CAAC,IAAI,GAAG,GAAGA,EAAK,MAAM,CAAC,CAAC;AACzG;AACA,SAASuC,EAAmB/B,GAAMoC,GAAM;AAGtC,QAAMC,IAAW,IAAI,KAAKD,KAAQ,CAACpC,CAAI;AACvC,SAAAqC,EAAS,cAAcA,EAAS,cAAa,IAAK,KAAK,MAAM,CAAC5C,EAASO,EAAK,UAAUqC,CAAQ,IAAI,EAAE,CAAC,GAC9F,CAACA;AACV;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@date-fns_tz@1.5.0/node_modules/@date-fns/tz/tzName/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/@date-fns+tz@1.5.0/node_modules/@date-fns/tz/tzName/index.js"],"sourcesContent":["/**\n * Time zone name format.\n */\n\n/**\n * The function returns the time zone name for the given date in the specified\n * time zone.\n *\n * It uses the `Intl.DateTimeFormat` API and by default outputs the time zone\n * name in a long format, e.g. \"Pacific Standard Time\" or\n * \"Singapore Standard Time\".\n *\n * It is possible to specify the format as the third argument using one of the following options\n *\n * - \"short\": e.g. \"EDT\" or \"GMT+8\".\n * - \"long\": e.g. \"Eastern Daylight Time\".\n * - \"shortGeneric\": e.g. \"ET\" or \"Singapore Time\".\n * - \"longGeneric\": e.g. \"Eastern Time\" or \"Singapore Standard Time\".\n *\n * These options correspond to TR35 tokens `z..zzz`, `zzzz`, `v`, and `vvvv` respectively: https://www.unicode.org/reports/tr35/tr35-dates.html#dfst-zone\n *\n * @param timeZone - Time zone name (IANA or UTC offset)\n * @param date - Date object to get the time zone name for\n * @param format - Optional format of the time zone name. Defaults to \"long\". Can be \"short\", \"long\", \"shortGeneric\", or \"longGeneric\".\n *\n * @returns Time zone name (e.g. \"Singapore Standard Time\")\n */\nexport function tzName(timeZone, date, format = \"long\") {\n  return new Intl.DateTimeFormat(\"en-US\", {\n    // Enforces engine to render the time. Without the option JavaScriptCore omits it.\n    hour: \"numeric\",\n    timeZone: timeZone,\n    timeZoneName: format\n  }).format(date).split(/\\s/g) // Format.JS uses non-breaking spaces\n  .slice(2) // Skip the hour and AM/PM parts\n  .join(\" \");\n}"],"names":["tzName","timeZone","date","format"],"mappings":"AA2BO,SAASA,EAAOC,GAAUC,GAAMC,IAAS,QAAQ;AACtD,SAAO,IAAI,KAAK,eAAe,SAAS;AAAA;AAAA,IAEtC,MAAM;AAAA,IACN,UAAUF;AAAA,IACV,cAAcE;AAAA,EAClB,CAAG,EAAE,OAAOD,CAAI,EAAE,MAAM,KAAK,EAC1B,MAAM,CAAC,EACP,KAAK,GAAG;AACX;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@date-fns_tz@1.5.0/node_modules/@date-fns/tz/tzOffset/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/@date-fns+tz@1.5.0/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,EAAAG,OAAAH,EAAAG,KAAgC,IAAI,KAAK,eAAe,SAAS;AAAA,MAC9E,UAAAA;AAAA,MACA,cAAc;AAAA,IACpB,CAAK,EAAE,SAGsBC,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,KAAA,gBAAAA,EAAU,MAAMK;AACjC,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/node_modules/.pnpm/@radix-ui_react-compose-refs@1.1.2_@types_react@19.2.15_react@19.2.6/node_modules/@radix-ui/react-compose-refs/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/@radix-ui+react-compose-refs@1.1.2_@types+react@19.2.15_react@19.2.6/node_modules/@radix-ui/react-compose-refs/dist/index.mjs"],"sourcesContent":["// packages/react/compose-refs/src/compose-refs.tsx\nimport * as React from \"react\";\nfunction setRef(ref, value) {\n  if (typeof ref === \"function\") {\n    return ref(value);\n  } else if (ref !== null && ref !== void 0) {\n    ref.current = value;\n  }\n}\nfunction composeRefs(...refs) {\n  return (node) => {\n    let hasCleanup = false;\n    const cleanups = refs.map((ref) => {\n      const cleanup = setRef(ref, node);\n      if (!hasCleanup && typeof cleanup == \"function\") {\n        hasCleanup = true;\n      }\n      return cleanup;\n    });\n    if (hasCleanup) {\n      return () => {\n        for (let i = 0; i < cleanups.length; i++) {\n          const cleanup = cleanups[i];\n          if (typeof cleanup == \"function\") {\n            cleanup();\n          } else {\n            setRef(refs[i], null);\n          }\n        }\n      };\n    }\n  };\n}\nfunction useComposedRefs(...refs) {\n  return React.useCallback(composeRefs(...refs), refs);\n}\nexport {\n  composeRefs,\n  useComposedRefs\n};\n//# sourceMappingURL=index.mjs.map\n"],"names":["setRef","ref","value","composeRefs","refs","node","hasCleanup","cleanups","cleanup","i"],"mappings":";AAEA,SAASA,EAAOC,GAAKC,GAAO;AAC1B,MAAI,OAAOD,KAAQ;AACjB,WAAOA,EAAIC,CAAK;AACX,EAAID,KAAQ,SACjBA,EAAI,UAAUC;AAElB;AACA,SAASC,KAAeC,GAAM;AAC5B,SAAO,CAACC,MAAS;AACf,QAAIC,IAAa;AACjB,UAAMC,IAAWH,EAAK,IAAI,CAACH,MAAQ;AACjC,YAAMO,IAAUR,EAAOC,GAAKI,CAAI;AAChC,aAAI,CAACC,KAAc,OAAOE,KAAW,eACnCF,IAAa,KAERE;AAAA,IACT,CAAC;AACD,QAAIF;AACF,aAAO,MAAM;AACX,iBAASG,IAAI,GAAGA,IAAIF,EAAS,QAAQE,KAAK;AACxC,gBAAMD,IAAUD,EAASE,CAAC;AAC1B,UAAI,OAAOD,KAAW,aACpBA,EAAO,IAEPR,EAAOI,EAAKK,CAAC,GAAG,IAAI;AAAA,QAExB;AAAA,MACF;AAAA,EAEJ;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@radix-ui_react-id@1.1.1_@types_react@19.2.15_react@19.2.6/node_modules/@radix-ui/react-id/dist/index.js

@@ -0,0 +1,14 @@
+import * as e from "react";
+import { useLayoutEffect as a } from "../../../../../@radix-ui_react-use-layout-effect@1.1.1_@types_react@19.2.15_react@19.2.6/node_modules/@radix-ui/react-use-layout-effect/dist/index.js";
+var s = e[" useId ".trim().toString()] || (() => {
+}), i = 0;
+function d(r) {
+  const [t, o] = e.useState(s());
+  return a(() => {
+    o((u) => u ?? String(i++));
+  }, [r]), t ? `radix-${t}` : "";
+}
+export {
+  d as useId
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/.pnpm/@radix-ui_react-id@1.1.1_@types_react@19.2.15_react@19.2.6/node_modules/@radix-ui/react-id/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/@radix-ui+react-id@1.1.1_@types+react@19.2.15_react@19.2.6/node_modules/@radix-ui/react-id/dist/index.mjs"],"sourcesContent":["// packages/react/id/src/id.tsx\nimport * as React from \"react\";\nimport { useLayoutEffect } from \"@radix-ui/react-use-layout-effect\";\nvar useReactId = React[\" useId \".trim().toString()] || (() => void 0);\nvar count = 0;\nfunction useId(deterministicId) {\n  const [id, setId] = React.useState(useReactId());\n  useLayoutEffect(() => {\n    if (!deterministicId) setId((reactId) => reactId ?? String(count++));\n  }, [deterministicId]);\n  return deterministicId || (id ? `radix-${id}` : \"\");\n}\nexport {\n  useId\n};\n//# sourceMappingURL=index.mjs.map\n"],"names":["useReactId","React","count","useId","deterministicId","id","setId","useLayoutEffect","reactId"],"mappings":";;AAGA,IAAIA,IAAaC,EAAM,UAAU,KAAI,EAAG,SAAQ,CAAE,MAAM,MAAA;AAAA,IACpDC,IAAQ;AACZ,SAASC,EAAMC,GAAiB;AAC9B,QAAM,CAACC,GAAIC,CAAK,IAAIL,EAAM,SAASD,GAAY;AAC/CO,SAAAA,EAAgB,MAAM;AACE,IAAAD,EAAM,CAACE,MAAYA,KAAW,OAAON,GAAO,CAAC;AAAA,EACrE,GAAG,CAACE,CAAe,CAAC,GACOC,IAAK,SAASA,CAAE,KAAK;AAClD;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@radix-ui_react-primitive@2.1.4_@types_react-dom@19.2.3_@types_react@19.2.15__@types_re_3dd09aa148d7cdb7a15dc8a5d6e8bba3/node_modules/@radix-ui/react-primitive/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/@radix-ui+react-primitive@2.1.4_@types+react-dom@19.2.3_@types+react@19.2.15__@types+re_3dd09aa148d7cdb7a15dc8a5d6e8bba3/node_modules/@radix-ui/react-primitive/dist/index.mjs"],"sourcesContent":["// src/primitive.tsx\nimport * as React from \"react\";\nimport * as ReactDOM from \"react-dom\";\nimport { createSlot } from \"@radix-ui/react-slot\";\nimport { jsx } from \"react/jsx-runtime\";\nvar NODES = [\n  \"a\",\n  \"button\",\n  \"div\",\n  \"form\",\n  \"h2\",\n  \"h3\",\n  \"img\",\n  \"input\",\n  \"label\",\n  \"li\",\n  \"nav\",\n  \"ol\",\n  \"p\",\n  \"select\",\n  \"span\",\n  \"svg\",\n  \"ul\"\n];\nvar Primitive = NODES.reduce((primitive, node) => {\n  const Slot = createSlot(`Primitive.${node}`);\n  const Node = React.forwardRef((props, forwardedRef) => {\n    const { asChild, ...primitiveProps } = props;\n    const Comp = asChild ? Slot : node;\n    if (typeof window !== \"undefined\") {\n      window[Symbol.for(\"radix-ui\")] = true;\n    }\n    return /* @__PURE__ */ jsx(Comp, { ...primitiveProps, ref: forwardedRef });\n  });\n  Node.displayName = `Primitive.${node}`;\n  return { ...primitive, [node]: Node };\n}, {});\nfunction dispatchDiscreteCustomEvent(target, event) {\n  if (target) ReactDOM.flushSync(() => target.dispatchEvent(event));\n}\nvar Root = Primitive;\nexport {\n  Primitive,\n  Root,\n  dispatchDiscreteCustomEvent\n};\n//# sourceMappingURL=index.mjs.map\n"],"names":["NODES","Primitive","primitive","node","Slot","createSlot","Node","React","props","forwardedRef","asChild","primitiveProps","Comp","jsx"],"mappings":";;;;AAKA,IAAIA,IAAQ;AAAA,EACV;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GACIC,IAAYD,EAAM,OAAO,CAACE,GAAWC,MAAS;AAChD,QAAMC,IAAOC,EAAW,aAAaF,CAAI,EAAE,GACrCG,IAAOC,EAAM,WAAW,CAACC,GAAOC,MAAiB;AACrD,UAAM,EAAE,SAAAC,GAAS,GAAGC,EAAc,IAAKH,GACjCI,IAAOF,IAAUN,IAAOD;AAC9B,WAAI,OAAO,SAAW,QACpB,OAAO,OAAO,IAAI,UAAU,CAAC,IAAI,KAEZ,gBAAAU,EAAID,GAAM,EAAE,GAAGD,GAAgB,KAAKF,GAAc;AAAA,EAC3E,CAAC;AACD,SAAAH,EAAK,cAAc,aAAaH,CAAI,IAC7B,EAAE,GAAGD,GAAW,CAACC,CAAI,GAAGG,EAAI;AACrC,GAAG,CAAA,CAAE;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@radix-ui_react-use-layout-effect@1.1.1_@types_react@19.2.15_react@19.2.6/node_modules/@radix-ui/react-use-layout-effect/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/@radix-ui+react-use-layout-effect@1.1.1_@types+react@19.2.15_react@19.2.6/node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs"],"sourcesContent":["// packages/react/use-layout-effect/src/use-layout-effect.tsx\nimport * as React from \"react\";\nvar useLayoutEffect2 = globalThis?.document ? React.useLayoutEffect : () => {\n};\nexport {\n  useLayoutEffect2 as useLayoutEffect\n};\n//# sourceMappingURL=index.mjs.map\n"],"names":["useLayoutEffect2","React"],"mappings":";AAEG,IAACA,IAAmB,iCAAY,WAAWC,EAAM,kBAAkB,MAAM;AAC5E;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@reduxjs_toolkit@2.12.0_react-redux@9.3.0_@types_react@19.2.15_react@19.2.6_redux@5.0.1__react@19.2.6/node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.js

@@ -0,0 +1,362 @@
+import { isAction as P } from "../../../../../redux@5.0.1/node_modules/redux/dist/redux.js";
+import { isPlainObject as ne } from "../../../../../redux@5.0.1/node_modules/redux/dist/redux.js";
+import { isDraftable as M, produce as k, isDraft as I } from "../../../../../immer@11.1.8/node_modules/immer/dist/immer.js";
+import { current as ce, freeze as ie } from "../../../../../immer@11.1.8/node_modules/immer/dist/immer.js";
+function S(e, r) {
+  function c(...o) {
+    if (r) {
+      let t = r(...o);
+      if (!t)
+        throw new Error(process.env.NODE_ENV === "production" ? f(0) : "prepareAction did not return an object");
+      return {
+        type: e,
+        payload: t.payload,
+        ..."meta" in t && {
+          meta: t.meta
+        },
+        ..."error" in t && {
+          error: t.error
+        }
+      };
+    }
+    return {
+      type: e,
+      payload: o[0]
+    };
+  }
+  return c.toString = () => `${e}`, c.type = e, c.match = (o) => P(o) && o.type === e, c;
+}
+function j(e) {
+  return M(e) ? k(e, () => {
+  }) : e;
+}
+function m(e, r, c) {
+  return e.has(r) ? e.get(r) : e.set(r, c(r)).get(r);
+}
+var $ = "RTK_autoBatch", Z = () => (e) => ({
+  payload: e,
+  meta: {
+    [$]: !0
+  }
+});
+function x(e) {
+  const r = {}, c = [];
+  let o;
+  const t = {
+    addCase(n, i) {
+      if (process.env.NODE_ENV !== "production") {
+        if (c.length > 0)
+          throw new Error(process.env.NODE_ENV === "production" ? f(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
+        if (o)
+          throw new Error(process.env.NODE_ENV === "production" ? f(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
+      }
+      const u = typeof n == "string" ? n : n.type;
+      if (!u)
+        throw new Error(process.env.NODE_ENV === "production" ? f(28) : "`builder.addCase` cannot be called with an empty action type");
+      if (u in r)
+        throw new Error(process.env.NODE_ENV === "production" ? f(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${u}'`);
+      return r[u] = i, t;
+    },
+    addAsyncThunk(n, i) {
+      if (process.env.NODE_ENV !== "production" && o)
+        throw new Error(process.env.NODE_ENV === "production" ? f(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
+      return i.pending && (r[n.pending.type] = i.pending), i.rejected && (r[n.rejected.type] = i.rejected), i.fulfilled && (r[n.fulfilled.type] = i.fulfilled), i.settled && c.push({
+        matcher: n.settled,
+        reducer: i.settled
+      }), t;
+    },
+    addMatcher(n, i) {
+      if (process.env.NODE_ENV !== "production" && o)
+        throw new Error(process.env.NODE_ENV === "production" ? f(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
+      return c.push({
+        matcher: n,
+        reducer: i
+      }), t;
+    },
+    addDefaultCase(n) {
+      if (process.env.NODE_ENV !== "production" && o)
+        throw new Error(process.env.NODE_ENV === "production" ? f(31) : "`builder.addDefaultCase` can only be called once");
+      return o = n, t;
+    }
+  };
+  return e(t), [r, c, o];
+}
+function z(e) {
+  return typeof e == "function";
+}
+function U(e, r) {
+  if (process.env.NODE_ENV !== "production" && typeof r == "object")
+    throw new Error(process.env.NODE_ENV === "production" ? f(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
+  let [c, o, t] = x(r), n;
+  if (z(e))
+    n = () => j(e());
+  else {
+    const u = j(e);
+    n = () => u;
+  }
+  function i(u = n(), N) {
+    let l = [c[N.type], ...o.filter(({
+      matcher: a
+    }) => a(N)).map(({
+      reducer: a
+    }) => a)];
+    return l.filter((a) => !!a).length === 0 && (l = [t]), l.reduce((a, E) => {
+      if (E)
+        if (I(a)) {
+          const b = E(a, N);
+          return b === void 0 ? a : b;
+        } else {
+          if (M(a))
+            return k(a, (D) => E(D, N));
+          {
+            const D = E(a, N);
+            if (D === void 0) {
+              if (a === null)
+                return a;
+              throw Error("A case reducer on a non-draftable value must not return undefined");
+            }
+            return D;
+          }
+        }
+      return a;
+    }, u);
+  }
+  return i.getInitialState = n, i;
+}
+var H = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
+function Y(e, r) {
+  return `${e}/${r}`;
+}
+function q({
+  creators: e
+} = {}) {
+  var c;
+  const r = (c = e == null ? void 0 : e.asyncThunk) == null ? void 0 : c[H];
+  return function(t) {
+    const {
+      name: n,
+      reducerPath: i = n
+    } = t;
+    if (!n)
+      throw new Error(process.env.NODE_ENV === "production" ? f(11) : "`name` is a required option for createSlice");
+    typeof process < "u" && process.env.NODE_ENV === "development" && t.initialState === void 0 && console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
+    const u = (typeof t.reducers == "function" ? t.reducers(K()) : t.reducers) || {}, N = Object.keys(u), l = {
+      sliceCaseReducersByName: {},
+      sliceCaseReducersByType: {},
+      actionCreators: {},
+      sliceMatchers: []
+    }, a = {
+      addCase(s, d) {
+        const p = typeof s == "string" ? s : s.type;
+        if (!p)
+          throw new Error(process.env.NODE_ENV === "production" ? f(12) : "`context.addCase` cannot be called with an empty action type");
+        if (p in l.sliceCaseReducersByType)
+          throw new Error(process.env.NODE_ENV === "production" ? f(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + p);
+        return l.sliceCaseReducersByType[p] = d, a;
+      },
+      addMatcher(s, d) {
+        return l.sliceMatchers.push({
+          matcher: s,
+          reducer: d
+        }), a;
+      },
+      exposeAction(s, d) {
+        return l.actionCreators[s] = d, a;
+      },
+      exposeCaseReducer(s, d) {
+        return l.sliceCaseReducersByName[s] = d, a;
+      }
+    };
+    N.forEach((s) => {
+      const d = u[s], p = {
+        reducerName: s,
+        type: Y(n, s),
+        createNotation: typeof t.reducers == "function"
+      };
+      W(d) ? J(p, d, a, r) : L(p, d, a);
+    });
+    function E() {
+      if (process.env.NODE_ENV !== "production" && typeof t.extraReducers == "object")
+        throw new Error(process.env.NODE_ENV === "production" ? f(14) : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
+      const [s = {}, d = [], p = void 0] = typeof t.extraReducers == "function" ? x(t.extraReducers) : [t.extraReducers], w = {
+        ...s,
+        ...l.sliceCaseReducersByType
+      };
+      return U(t.initialState, (y) => {
+        for (let h in w)
+          y.addCase(h, w[h]);
+        for (let h of l.sliceMatchers)
+          y.addMatcher(h.matcher, h.reducer);
+        for (let h of d)
+          y.addMatcher(h.matcher, h.reducer);
+        p && y.addDefaultCase(p);
+      });
+    }
+    const D = (s) => s, b = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new WeakMap();
+    let C;
+    function R(s, d) {
+      return C || (C = E()), C(s, d);
+    }
+    function _() {
+      return C || (C = E()), C.getInitialState();
+    }
+    function O(s, d = !1) {
+      function p(y) {
+        let h = y[s];
+        if (typeof h > "u") {
+          if (d)
+            h = m(g, p, _);
+          else if (process.env.NODE_ENV !== "production")
+            throw new Error(process.env.NODE_ENV === "production" ? f(15) : "selectSlice returned undefined for an uninjected slice reducer");
+        }
+        return h;
+      }
+      function w(y = D) {
+        const h = m(b, d, () => /* @__PURE__ */ new WeakMap());
+        return m(h, y, () => {
+          const V = {};
+          for (const [B, A] of Object.entries(t.selectors ?? {}))
+            V[B] = F(A, y, () => m(g, y, _), d);
+          return V;
+        });
+      }
+      return {
+        reducerPath: s,
+        getSelectors: w,
+        get selectors() {
+          return w(p);
+        },
+        selectSlice: p
+      };
+    }
+    const T = {
+      name: n,
+      reducer: R,
+      actions: l.actionCreators,
+      caseReducers: l.sliceCaseReducersByName,
+      getInitialState: _,
+      ...O(i),
+      injectInto(s, {
+        reducerPath: d,
+        ...p
+      } = {}) {
+        const w = d ?? i;
+        return s.inject({
+          reducerPath: w,
+          reducer: R
+        }, p), {
+          ...T,
+          ...O(w, !0)
+        };
+      }
+    };
+    return T;
+  };
+}
+function F(e, r, c, o) {
+  function t(n, ...i) {
+    let u = r(n);
+    if (typeof u > "u") {
+      if (o)
+        u = c();
+      else if (process.env.NODE_ENV !== "production")
+        throw new Error(process.env.NODE_ENV === "production" ? f(16) : "selectState returned undefined for an uninjected slice reducer");
+    }
+    return e(u, ...i);
+  }
+  return t.unwrapped = e, t;
+}
+var ee = /* @__PURE__ */ q();
+function K() {
+  function e(r, c) {
+    return {
+      _reducerDefinitionType: "asyncThunk",
+      payloadCreator: r,
+      ...c
+    };
+  }
+  return e.withTypes = () => e, {
+    reducer(r) {
+      return Object.assign({
+        // hack so the wrapping function has the same name as the original
+        // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
+        [r.name](...c) {
+          return r(...c);
+        }
+      }[r.name], {
+        _reducerDefinitionType: "reducer"
+        /* reducer */
+      });
+    },
+    preparedReducer(r, c) {
+      return {
+        _reducerDefinitionType: "reducerWithPrepare",
+        prepare: r,
+        reducer: c
+      };
+    },
+    asyncThunk: e
+  };
+}
+function L({
+  type: e,
+  reducerName: r,
+  createNotation: c
+}, o, t) {
+  let n, i;
+  if ("reducer" in o) {
+    if (c && !G(o))
+      throw new Error(process.env.NODE_ENV === "production" ? f(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
+    n = o.reducer, i = o.prepare;
+  } else
+    n = o;
+  t.addCase(e, n).exposeCaseReducer(r, n).exposeAction(r, i ? S(e, i) : S(e));
+}
+function W(e) {
+  return e._reducerDefinitionType === "asyncThunk";
+}
+function G(e) {
+  return e._reducerDefinitionType === "reducerWithPrepare";
+}
+function J({
+  type: e,
+  reducerName: r
+}, c, o, t) {
+  if (!t)
+    throw new Error(process.env.NODE_ENV === "production" ? f(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
+  const {
+    payloadCreator: n,
+    fulfilled: i,
+    pending: u,
+    rejected: N,
+    settled: l,
+    options: a
+  } = c, E = t(e, n, a);
+  o.exposeAction(r, E), i && o.addCase(E.fulfilled, i), u && o.addCase(E.pending, u), N && o.addCase(E.rejected, N), l && o.addMatcher(E.settled, l), o.exposeCaseReducer(r, {
+    fulfilled: i || v,
+    pending: u || v,
+    rejected: N || v,
+    settled: l || v
+  });
+}
+function v() {
+}
+function f(e) {
+  return `Minified Redux Toolkit error #${e}; visit https://redux-toolkit.js.org/Errors?code=${e} for the full message or use the non-minified dev environment for full errors. `;
+}
+export {
+  $ as SHOULD_AUTOBATCH,
+  q as buildCreateSlice,
+  S as createAction,
+  k as createNextState,
+  U as createReducer,
+  ee as createSlice,
+  ce as current,
+  f as formatProdErrorMessage,
+  ie as freeze,
+  P as isAction,
+  I as isDraft,
+  ne as isPlainObject,
+  Z as prepareAutoBatched
+};
+//# sourceMappingURL=redux-toolkit.modern.js.map