Initial project upload

frontend/node_modules/react-timezone-select/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Nico Domino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

frontend/node_modules/react-timezone-select/README.md

@@ -0,0 +1,236 @@
+# 🌐⌚ react-timezone-select
+
+[![npm](https://img.shields.io/npm/v/react-timezone-select?style=flat-square)](https://www.npmjs.com/package/react-timezone-select)
+[![NPM Downloads](https://img.shields.io/npm/dm/react-timezone-select?style=flat-square)](https://www.npmjs.com/package/react-timezone-select)
+[![Skypack](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg?style=flat-square)](https://skypack.dev/view/react-timezone-select)
+[![Test CI](https://flat.badgen.net/github/checks/ndom91/react-timezone-select/main?style=flat-square&label=tests)](https://github.com/ndom91/react-timezone-select/actions?query=workflow%3A%22Tests+CI%22)
+[![MIT](https://flat.badgen.net/badge/license/MIT/blue?style=flat-square)](https://github.com/ndom91/react-timezone-select/blob/main/LICENSE)
+
+Another react timezone select component, I know.. However this one has a few key benefits!
+
+While looking around for a good option, I had trouble finding a timezone select components which:
+
+1. Adjusted the choices automatically with Daylight Savings Time (DST)
+2. Didn't have a huge list of choices to scroll through when technically only 24 (ish) are necessary
+
+> [!IMPORTANT]
+>
+> ### Demo: [ndom91.github.io/react-timezone-select](https://ndom91.github.io/react-timezone-select/)
+>
+> This demo is also available in the `./examples` directory. Simply run `pnpm dev` in the root of the repository and the vite dev server will start, where you can then find the example app at [`localhost:3001`](http://localhost:3001).
+
+## 🏗️ Installing
+
+```bash
+npm install react-timezone-select react-select
+```
+
+> [!CAUTION]
+> The package `react-select` is optional. It is unnecessary if you're only using [the hook](#-timezone-hook).
+
+## 🔭 Usage
+
+```tsx
+import React, { useState } from "react"
+import ReactDOM from "react-dom"
+import TimezoneSelect, { type ITimezone } from "react-timezone-select"
+
+const App = () => {
+  const [selectedTimezone, setSelectedTimezone] = useState<ITimezone>(
+    Intl.DateTimeFormat().resolvedOptions().timeZone,
+  )
+
+  return (
+    <div className="App">
+      <h2>react-timezone-select</h2>
+      <blockquote>Please make a selection</blockquote>
+      <div className="select-wrapper">
+        <TimezoneSelect value={selectedTimezone} onChange={setSelectedTimezone} />
+      </div>
+      <h3>Output:</h3>
+      <div
+        style={{
+          backgroundColor: "#ccc",
+          padding: "20px",
+          margin: "20px auto",
+          borderRadius: "5px",
+          maxWidth: "600px",
+        }}
+      >
+        <pre
+          style={{
+            margin: "0 20px",
+            fontWeight: 500,
+            fontFamily: "monospace",
+          }}
+        >
+          {JSON.stringify(selectedTimezone, null, 2)}
+        </pre>
+      </div>
+    </div>
+  )
+}
+
+const rootElement = document.getElementById("root")
+ReactDOM.render(<App />, rootElement)
+```
+
+## 🎨 Timezone Hook
+
+By default, `react-timezone-select` uses [`react-select`](https://github.com/jedwatson/react-select) as underlying select component. If you'd like to bring your own select component, you can use the `useTimezoneSelect` hook instead of the `TimezoneSelect` component to render the timezones using your self-provided select component.
+
+```tsx
+import { useTimezoneSelect, allTimezones } from "react-timezone-select"
+
+const labelStyle = "original"
+const timezones = {
+  ...allTimezones,
+  "Europe/Berlin": "Frankfurt",
+}
+
+const customSelect = () => {
+  const { options, parseTimezone } = useTimezoneSelect({ labelStyle, timezones })
+
+  return (
+    <select onChange={(e) => onChange(parseTimezone(e.currentTarget.value))}>
+      {options.map((option) => (
+        <option value={option.value}>{option.label}</option>
+      ))}
+    </select>
+  )
+}
+```
+
+## 🕹️ Props
+
+<table>
+  <tbody>
+    <tr>
+      <th>Prop</th>
+      <th>Type</th>
+      <th>Default</th>
+      <th>Note</th>
+    </tr>
+    <tr>
+      <td><code>value</code></td>
+      <td><code>string | ITimezoneOption<string, string></code></td>
+      <td>null</td>
+      <td>Initial/current Timezone</td>
+    </tr>
+    <tr>
+      <td><code>onBlur</code></td>
+      <td><code>() => void</code></td>
+      <td>null</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td><code>onChange</code></td>
+      <td><code>(timezone: ITimezoneOption) => void</code></td>
+      <td>null</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td><code>labelStyle</code></td>
+      <td><code>'original' | 'altName' | 'abbrev' | 'offsetHidden'</code></td>
+      <td><code>'original'</code></td>
+      <td></td>
+    </tr>
+    <tr>
+      <td><code>displayValue</code></td>
+      <td><code>'GMT' | 'UTC'</code></td>
+      <td><code>'GMT'</code></td>
+      <td>Prefix for the label (i.e. <code>"(GMT+2:00)"</code> or <code>"(UTC+2:00)"</code>)</td>
+    </tr>
+    <tr>
+      <td><code>timezones</code></td>
+      <td><code>Record<string,string></code></td>
+      <td><code>allTimezones</code></td>
+      <td></td>
+    </tr>
+    <tr>
+      <td><code>currentDatetime</code></td>
+      <td><code>Date | string</code></td>
+      <td>null</td>
+      <td>Override datetime used to calculate timezone values (alternative to current datetime), useful for calculating different summer / winter times, etc.</td>
+    </tr>
+  </tbody>
+</table>
+
+#### Example `value`s:
+
+```ts
+// string
+value='America/Juneau'
+// ITimezoneOption; i.e. `onChange` return value
+value={{
+  value: 'America/Juneau'
+  label: '(GMT-8:00) Alaska,
+  abbrev: 'AHST',
+  offset: -8,
+  altName: 'Alaskan Standard Time'
+}}
+```
+
+#### Example `timezones`:
+
+```ts
+timezones={{
+  ...allTimezones,
+  'America/Lima': 'Pittsburgh',
+  'Europe/Berlin': 'Frankfurt',
+}}
+```
+
+## ✨ Tips
+
+### 👤 Default Users Timezone
+
+If you'd like the user's own timezone to be set as the initially selected option on render, we can make use of the new `Intl` browser API by setting the default state value to `Intl.DateTimeFormat().resolvedOptions().timeZone`.
+
+```tsx
+const [timezone, setTimezone] = useState(Intl.DateTimeFormat().resolvedOptions().timeZone)
+```
+
+### 🕒 Custom Timezones
+
+You can append custom choices of your own, or fully replace the listed timezone options.
+
+The `timezones` prop takes a dictionary of timezones in the format of "`{ tzIdentifier: Label }`" ([Timezone Identifiers](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)). 
+
+```tsx
+import TimezoneSelect, { type ITimezone, allTimezones } from 'react-timezone-select'
+
+const [selectedTimezone, setSelectedTimezone] = useState<ITimezone>('Europe/Berlin')
+
+<TimezoneSelect
+  value={selectedTimezone}
+  onChange={setSelectedTimezone}
+  timezones={{
+    ...allTimezones,
+    'America/Lima': 'Pittsburgh',
+    'Europe/Berlin': 'Frankfurt',
+  }}
+/>
+```
+
+The example above will include all original timezones and generate two additional choices:
+
+- `'(GMT-5:00) Pittsburgh'`
+- `'(GMT+1:00) Frankfurt'`
+
+We'll prepend the correct `(GMT...)` part to the generated label, you just have to provide the string you want in your label. Also, you can omit spreading in the `allTimezones` object for a select dropdown consisting of only your custom choices.
+
+## 🚧 Contributing
+
+Pull requests are always welcome! Please stick to repo formatting/linting settings, and if adding new features, please consider adding test(s) and documentation where appropriate!
+
+## 🙏 Thanks
+
+- [All Contributors](https://github.com/ndom91/react-timezone-select/graphs/contributors)
+- [Carlos Matallin](https://github.com/matallo/)
+- [spacetime](https://github.com/spencermountain/spacetime)
+- [react-select](https://react-select.com)
+
+## 📝 License
+
+MIT

frontend/node_modules/react-timezone-select/dist/index.d.ts

@@ -0,0 +1,42 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Props as Props$1 } from 'react-select';
+
+type ICustomTimezone = {
+    [key: string]: string;
+};
+type ILabelStyle = "original" | "altName" | "abbrev" | "offsetHidden";
+type IDisplayValue = "GMT" | "UTC";
+type ITimezoneOption = {
+    value: string;
+    label: string;
+    abbrev?: string;
+    altName?: string;
+    offset?: number;
+    searchTerms?: string;
+};
+type ITimezone = ITimezoneOption | string;
+type TimezoneSelectOptions = {
+    labelStyle?: ILabelStyle;
+    displayValue?: IDisplayValue;
+    timezones?: ICustomTimezone;
+    currentDatetime?: Date | string;
+};
+type Props = Omit<Props$1<ITimezone>, "onChange"> & TimezoneSelectOptions & {
+    value: ITimezone;
+    onChange?: (timezone: ITimezoneOption) => void;
+};
+
+declare const allTimezones: ICustomTimezone;
+
+declare function useTimezoneSelect({ timezones, labelStyle, displayValue, currentDatetime, }: TimezoneSelectOptions): {
+    parseTimezone: (zone: ITimezone) => ITimezoneOption;
+    options: ITimezoneOption[];
+    filterOption: (option: {
+        label: string;
+        value: string;
+        data: ITimezone;
+    }, inputValue: string) => boolean;
+};
+declare const TimezoneSelect: ({ value, onBlur, onChange, labelStyle, displayValue, timezones, currentDatetime, ...props }: Props) => react_jsx_runtime.JSX.Element;
+
+export { type ILabelStyle, type ITimezone, type ITimezoneOption, type Props, type TimezoneSelectOptions, allTimezones, TimezoneSelect as default, useTimezoneSelect };

frontend/node_modules/react-timezone-select/dist/index.js

@@ -0,0 +1,281 @@
+"use client"
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/index.tsx
+import { useMemo } from "react";
+import Select from "react-select";
+import spacetime from "spacetime";
+import soft from "timezone-soft";
+
+// src/timezone-list.ts
+var allTimezones = {
+  "Pacific/Midway": "Midway Island, Samoa",
+  "Pacific/Honolulu": "Hawaii",
+  "America/Juneau": "Alaska",
+  "America/Boise": "Mountain Time",
+  "America/Dawson": "Dawson, Yukon",
+  "America/Chihuahua": "Chihuahua, La Paz, Mazatlan",
+  "America/Phoenix": "Arizona",
+  "America/Los_Angeles": "Pacific Time",
+  "America/Chicago": "Central Time",
+  "America/Regina": "Saskatchewan",
+  "America/Mexico_City": "Guadalajara, Mexico City, Monterrey",
+  "America/Belize": "Central America",
+  "America/Detroit": "Eastern Time",
+  "America/Bogota": "Bogota, Lima, Quito",
+  "America/Caracas": "Caracas, La Paz",
+  "America/Santiago": "Santiago",
+  "America/St_Johns": "Newfoundland and Labrador",
+  "America/Sao_Paulo": "Brasilia",
+  "America/Tijuana": "Tijuana",
+  "America/Montevideo": "Montevideo",
+  "America/Argentina/Buenos_Aires": "Buenos Aires, Georgetown",
+  "America/Godthab": "Greenland",
+  "Atlantic/Azores": "Azores",
+  "Atlantic/Cape_Verde": "Cape Verde Islands",
+  GMT: "UTC",
+  "Europe/London": "Edinburgh, London",
+  "Europe/Dublin": "Dublin",
+  "Europe/Lisbon": "Lisbon",
+  "Africa/Casablanca": "Casablanca, Monrovia",
+  "Atlantic/Canary": "Canary Islands",
+  "Europe/Belgrade": "Belgrade, Bratislava, Budapest, Ljubljana, Prague",
+  "Europe/Sarajevo": "Sarajevo, Skopje, Warsaw, Zagreb",
+  "Europe/Brussels": "Brussels, Copenhagen, Madrid, Paris",
+  "Europe/Amsterdam": "Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna",
+  "Africa/Algiers": "West Central Africa",
+  "Europe/Bucharest": "Bucharest",
+  "Africa/Cairo": "Cairo",
+  "Europe/Helsinki": "Helsinki, Kyiv, Riga, Sofia, Tallinn, Vilnius",
+  "Europe/Athens": "Athens",
+  "Asia/Jerusalem": "Jerusalem",
+  "Africa/Harare": "Harare, Pretoria",
+  "Europe/Moscow": "Istanbul, Minsk, Moscow, St. Petersburg, Volgograd",
+  "Asia/Kuwait": "Kuwait, Riyadh",
+  "Africa/Nairobi": "Nairobi",
+  "Asia/Baghdad": "Baghdad",
+  "Asia/Tehran": "Tehran",
+  "Asia/Dubai": "Abu Dhabi, Muscat",
+  "Asia/Baku": "Baku, Tbilisi, Yerevan",
+  "Asia/Kabul": "Kabul",
+  "Asia/Yekaterinburg": "Ekaterinburg",
+  "Asia/Karachi": "Islamabad, Karachi, Tashkent",
+  "Asia/Kolkata": "Chennai, Kolkata, Mumbai, New Delhi",
+  "Asia/Kathmandu": "Kathmandu",
+  "Asia/Dhaka": "Astana, Dhaka",
+  "Asia/Colombo": "Sri Jayawardenepura",
+  "Asia/Almaty": "Almaty, Novosibirsk",
+  "Asia/Rangoon": "Yangon Rangoon",
+  "Asia/Bangkok": "Bangkok, Hanoi, Jakarta",
+  "Asia/Krasnoyarsk": "Krasnoyarsk",
+  "Asia/Shanghai": "Beijing, Chongqing, Hong Kong SAR, Urumqi",
+  "Asia/Kuala_Lumpur": "Kuala Lumpur, Singapore",
+  "Asia/Taipei": "Taipei",
+  "Australia/Perth": "Perth",
+  "Asia/Irkutsk": "Irkutsk, Ulaanbaatar",
+  "Asia/Seoul": "Seoul",
+  "Asia/Tokyo": "Osaka, Sapporo, Tokyo",
+  "Asia/Yakutsk": "Yakutsk",
+  "Australia/Darwin": "Darwin",
+  "Australia/Adelaide": "Adelaide",
+  "Australia/Sydney": "Canberra, Melbourne, Sydney",
+  "Australia/Brisbane": "Brisbane",
+  "Australia/Hobart": "Hobart",
+  "Asia/Vladivostok": "Vladivostok",
+  "Pacific/Guam": "Guam, Port Moresby",
+  "Asia/Magadan": "Magadan, Solomon Islands, New Caledonia",
+  "Asia/Kamchatka": "Kamchatka, Marshall Islands",
+  "Pacific/Fiji": "Fiji Islands",
+  "Pacific/Auckland": "Auckland, Wellington",
+  "Pacific/Tongatapu": "Nuku'alofa"
+};
+var timezone_list_default = allTimezones;
+
+// src/index.tsx
+import { jsx } from "react/jsx-runtime";
+function useTimezoneSelect({
+  timezones = timezone_list_default,
+  labelStyle = "original",
+  displayValue = "GMT",
+  currentDatetime
+}) {
+  const allOptions = useMemo(() => {
+    return Object.entries(timezones).map((zone) => {
+      var _a, _b, _c, _d;
+      try {
+        const now = (currentDatetime ? spacetime(currentDatetime) : spacetime.now()).goto(zone[0]);
+        const isDstString = now.isDST() ? "daylight" : "standard";
+        const tz = now.timezone();
+        const tzStrings = soft(zone[0]);
+        const abbr = (_b = (_a = tzStrings == null ? void 0 : tzStrings[0]) == null ? void 0 : _a[isDstString]) == null ? void 0 : _b.abbr;
+        const altName = (_d = (_c = tzStrings == null ? void 0 : tzStrings[0]) == null ? void 0 : _c[isDstString]) == null ? void 0 : _d.name;
+        const min = tz.current.offset * 60;
+        const hr = `${min / 60 ^ 0}:${min % 60 === 0 ? "00" : Math.abs(min % 60)}`;
+        const prefix = `(${displayValue}${hr.includes("-") ? hr : `+${hr}`}) ${zone[1]}`;
+        let label = "";
+        switch (labelStyle) {
+          case "original":
+            label = prefix;
+            break;
+          case "altName":
+            label = `${prefix} ${altName ? `(${altName})` : ""}`;
+            break;
+          case "abbrev":
+            label = `${prefix} ${abbr ? `(${abbr})` : ""}`;
+            break;
+          case "offsetHidden":
+            label = `${prefix.replace(/^\(.*?\)\s*/, "")}`;
+            break;
+          default:
+            label = `${prefix}`;
+        }
+        return {
+          value: tz.name,
+          label,
+          offset: tz.current.offset,
+          abbrev: abbr,
+          altName,
+          hasDst: tz.hasDst
+        };
+      } catch (e) {
+        return null;
+      }
+    }).filter(Boolean).sort((a, b) => a.offset - b.offset);
+  }, [labelStyle, timezones, currentDatetime]);
+  const customTimezoneKeys = useMemo(() => {
+    const defaultKeys = new Set(Object.keys(timezone_list_default));
+    return new Set(Object.keys(timezones).filter((key) => !defaultKeys.has(key)));
+  }, [timezones]);
+  const options = useMemo(() => {
+    return allOptions.filter((item, idx, arr) => {
+      if (customTimezoneKeys.has(item.value)) return true;
+      return arr.findIndex((t) => t.offset === item.offset && t.hasDst === item.hasDst) === idx;
+    }).map((_a) => {
+      var _b = _a, { hasDst: _ } = _b, item = __objRest(_b, ["hasDst"]);
+      return __spreadProps(__spreadValues({}, item), {
+        searchTerms: allOptions.filter((t) => t.offset === item.offset && t.hasDst === _).map((t) => t.label).join(" ")
+      });
+    });
+  }, [allOptions, customTimezoneKeys]);
+  const filterOption = (option, inputValue) => {
+    var _a, _b, _c;
+    const data = option.data;
+    const term = inputValue.toLowerCase();
+    return ((_a = data.label) == null ? void 0 : _a.toLowerCase().includes(term)) || ((_c = (_b = data.searchTerms) == null ? void 0 : _b.toLowerCase().includes(term)) != null ? _c : false);
+  };
+  const findFuzzyTz = (zone) => {
+    var _a, _b;
+    let currentTime;
+    try {
+      currentTime = (currentDatetime ? spacetime(currentDatetime) : spacetime.now()).goto(zone);
+    } catch (err) {
+      currentTime = (currentDatetime ? spacetime(currentDatetime) : spacetime.now()).goto("GMT");
+    }
+    return (_b = (_a = allOptions.filter((tz) => tz.offset === currentTime.timezone().current.offset).map((tz) => {
+      let score = 0;
+      if (currentTime.timezones[tz.value.toLowerCase()] && !!currentTime.timezones[tz.value.toLowerCase()].dst === currentTime.timezone().hasDst) {
+        if (tz.value.toLowerCase().indexOf(currentTime.tz.substring(currentTime.tz.indexOf("/") + 1)) !== -1) {
+          score += 8;
+        }
+        if (tz.label.toLowerCase().indexOf(currentTime.tz.substring(currentTime.tz.indexOf("/") + 1)) !== -1) {
+          score += 4;
+        }
+        if (tz.value.toLowerCase().indexOf(currentTime.tz.substring(0, currentTime.tz.indexOf("/"))) !== -1) {
+          score += 2;
+        }
+        score += 1;
+      } else if (tz.value === "GMT") {
+        score += 1;
+      }
+      return { tz, score };
+    }).sort((a, b) => b.score - a.score)) == null ? void 0 : _a[0]) == null ? void 0 : _b.tz;
+  };
+  function isObject(item) {
+    return typeof item === "object" && !Array.isArray(item) && item !== null;
+  }
+  const parseTimezone = (zone) => {
+    if (typeof zone === "string") {
+      return allOptions.find((tz) => tz.value === zone) || zone.indexOf("/") !== -1 && findFuzzyTz(zone);
+    } else if (isObject(zone) && !zone.label) {
+      return allOptions.find((tz) => tz.value === zone.value);
+    } else {
+      return zone;
+    }
+  };
+  return { options, parseTimezone, filterOption };
+}
+var TimezoneSelect = (_a) => {
+  var _b = _a, {
+    value,
+    onBlur,
+    onChange,
+    labelStyle,
+    displayValue,
+    timezones,
+    currentDatetime
+  } = _b, props = __objRest(_b, [
+    "value",
+    "onBlur",
+    "onChange",
+    "labelStyle",
+    "displayValue",
+    "timezones",
+    "currentDatetime"
+  ]);
+  const { options, parseTimezone, filterOption } = useTimezoneSelect({
+    timezones,
+    labelStyle,
+    displayValue,
+    currentDatetime
+  });
+  const handleChange = (tz) => {
+    if (!onChange) return;
+    const _a2 = tz, { searchTerms: _ } = _a2, rest = __objRest(_a2, ["searchTerms"]);
+    onChange(rest);
+  };
+  return /* @__PURE__ */ jsx(
+    Select,
+    __spreadValues({
+      value: parseTimezone(value),
+      onChange: handleChange,
+      options,
+      filterOption,
+      onBlur
+    }, props)
+  );
+};
+export {
+  timezone_list_default as allTimezones,
+  TimezoneSelect as default,
+  useTimezoneSelect
+};

frontend/node_modules/react-timezone-select/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "react-timezone-select",
+  "version": "3.3.3",
+  "description": "Usable, dynamic React Timezone Select",
+  "scripts": {
+    "dev": "concurrently \"tsup --watch\" \"cd example && pnpm dev\"",
+    "prepublishOnly": "pnpm run build",
+    "postpublish": "pnpm run build:example && npm run deploy",
+    "build": "tsup",
+    "build:example": "cd example && pnpm run build",
+    "deploy": "gh-pages -d example/dist",
+    "pretest": "pnpm run build",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:ci": "pnpm run build && pnpm test",
+    "tsc": "tsc",
+    "lint": "biome lint",
+    "lint:fix": "biome lint --fix",
+    "format": "biome check",
+    "format:fix": "biome check --write"
+  },
+  "author": "Nico Domino <yo@ndo.dev>",
+  "homepage": "https://github.com/ndom91/react-timezone-select",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ndom91/react-timezone-select.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ndom91/react-timezone-select/issues"
+  },
+  "license": "MIT",
+  "keywords": ["react", "timezone", "select", "react-select"],
+  "files": ["dist/**/*", "package.json"],
+  "type": "module",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "react": "^16 || ^17.0.1 || ^18 || ^19",
+    "react-dom": "^16 || ^17.0.1 || ^18 || ^19",
+    "react-select": "^5.9.0"
+  },
+  "dependencies": {
+    "spacetime": "^7.12.0",
+    "timezone-soft": "^1.5.2"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^20.19.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.4",
+    "concurrently": "^9.2.1",
+    "esbuild": "^0.27.3",
+    "gh-pages": "^6.3.0",
+    "jsdom": "^26.1.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.0.18"
+  },
+  "packageManager": "pnpm@9.0.6+sha256.0624e30eff866cdeb363b15061bdb7fd9425b17bc1bb42c22f5f4efdea21f6b3"
+}