@trilogy-ds/react 0.0.17-esm-cjs → 0.0.18-esm-cjs

package/lib/components/datepicker/DatePicker.js

@@ -0,0 +1,2356 @@
+"use client";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// components/datepicker/DatePicker.tsx
+var DatePicker_exports = {};
+__export(DatePicker_exports, {
+  default: () => DatePicker_default
+});
+module.exports = __toCommonJS(DatePicker_exports);
+
+// context/index.tsx
+var React = __toESM(require("react"));
+var TrilogyContext = React.createContext({
+  styled: false,
+  setStyled: () => void 0
+});
+var useTrilogyContext = () => {
+  const context = React.useContext(TrilogyContext);
+  if (context === void 0) {
+    throw new Error("useTrilogyContext must be used within a TrilogyProvider");
+  }
+  return context;
+};
+
+// helpers/hashClassesHelpers/index.tsx
+var hashClass = (addHash = false, classes) => {
+  const { hash, styled } = useTrilogyContext();
+  if (classes.trim().length < 1) return "";
+  if (styled) {
+    return classes.split(" ").map((classe) => classe = `${classe}_${hash}`).join(" ");
+  }
+  return classes;
+};
+
+// helpers/device/index.ts
+var Device = /* @__PURE__ */ ((Device2) => {
+  Device2["Browser"] = "browser";
+  Device2["Server"] = "server";
+  Device2["Native"] = "native";
+  return Device2;
+})(Device || {});
+var { Browser, Server, Native } = Device;
+var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
+var canUseNative = typeof navigator != "undefined" && navigator.product == "ReactNative";
+var device = canUseNative ? Native : canUseDOM ? Browser : Server;
+var SSRObjectDefined = {
+  isBrowser: device === Browser,
+  isServer: device === Server,
+  isNative: device === Native,
+  device,
+  canUseWorkers: typeof Worker !== "undefined",
+  canUseEventListeners: device === Browser && !!window.addEventListener,
+  canUseViewport: device === Browser && !!window.screen
+};
+var assign = (...args) => Object.assign({}, ...args);
+var values = (obj) => Object.values(obj);
+var toArrayObject = () => assign((values(SSRObjectDefined), SSRObjectDefined));
+var SSRObject = toArrayObject();
+
+// services/classify/index.ts
+function classify(prefix) {
+  return (classname) => classname !== "" ? `${prefix}-${classname.toLowerCase()}` : "";
+}
+var is = classify("is");
+var has = classify("has");
+
+// components/calendar/Calendar.tsx
+var import_locales2 = require("@trilogy-ds/locales");
+var import_clsx8 = __toESM(require("clsx"));
+var import_react9 = __toESM(require("react"));
+
+// context/providerTheme/index.tsx
+var import_react = __toESM(require("react"));
+var defaultTheme = {
+  icons: {},
+  colors: {},
+  fontFamily: {}
+};
+var defaultContextValue = {
+  theme: defaultTheme,
+  setTheme: () => void 0
+};
+var TrilogyThemeContext = import_react.default.createContext(defaultContextValue);
+
+// objects/facets/Color/index.tsx
+var import_react2 = require("react");
+var colors = {
+  ["WHITE" /* BACKGROUND */]: ["#fff", "white", "main"],
+  ["MAIN" /* MAIN */]: ["#3d5d7e", "main", "white"],
+  ["MAIN_FADE" /* MAIN_FADE */]: ["#BBC6CD", "main-fade", "white"],
+  ["ACCENT" /* ACCENT */]: ["#da641b", "accent", "white"],
+  ["ACCENT_FADE" /* ACCENT_FADE */]: ["#faebe3", "accent-fade", "white"],
+  ["FONT" /* FONT */]: ["#3d5d7e", "main", "white"],
+  ["FONT_PLACEHOLDER" /* FONT_PLACEHOLDER */]: ["#687a87", "font-placeholder", "white"],
+  ["SUCCESS" /* SUCCESS */]: ["#007B52", "success", "white"],
+  ["SUCCESS_FADE" /* SUCCESS_FADE */]: ["#cae8ca", "success-fade", "white"],
+  ["INFO" /* INFO */]: ["#1A688A", "info", "white"],
+  ["INFO_FADE" /* INFO_FADE */]: ["#c8dbec", "info-fade", "white"],
+  ["WARNING" /* WARNING */]: ["#FFBB33", "warning", "white"],
+  ["WARNING_FADE" /* WARNING_FADE */]: ["#ecdbc6", "warning-fade", "white"],
+  ["ERROR" /* ERROR */]: ["#D42D02", "error", "white"],
+  ["ERROR_FADE" /* ERROR_FADE */]: ["#eecccc", "error-fade", "white"],
+  ["DISABLED" /* DISABLED */]: ["#646464", "disabled", "white"],
+  ["DISABLED_FADE" /* DISABLED_FADE */]: ["#D1D1D1", "disabled-fade", "white"],
+  ["NEUTRAL" /* NEUTRAL */]: ["#707070", "grey", "white"],
+  ["NEUTRAL_FADE" /* NEUTRAL_FADE */]: ["#F4F4F4", "grey-fade", "white"],
+  ["STROKE" /* STROKE */]: ["#BBC1CE", "stroke", "white"]
+};
+var getColorClassName = (trilogyColor) => {
+  const color = colors[trilogyColor];
+  return color[1];
+};
+var getButtonVariantClassName = (trilogyColor) => {
+  switch (trilogyColor) {
+    case "CONVERSION":
+      return "conversion";
+    case "PRIMARY":
+      return "primary";
+    case "SECONDARY":
+      return "secondary";
+    case "GHOST":
+      return "ghost";
+    case "SUCCESS":
+      return "success";
+    case "INFO":
+      return "info";
+    case "WARNING":
+      return "warning";
+    case "ERROR":
+      return "error";
+    case "DISABLED":
+      return "disabled";
+    default:
+      return "primary";
+  }
+};
+var getColorStyle = (trilogyColor) => {
+  if (typeof navigator !== "undefined" && navigator.userAgent === void 0) {
+    const { theme } = (0, import_react2.useContext)(TrilogyThemeContext);
+    const colorsStyle = (theme == null ? void 0 : theme.colors) || colors;
+    const colorArray = colorsStyle[trilogyColor] || colorsStyle.default;
+    if (trilogyColor === "transparent") return "transparent";
+    if (!trilogyColor || !colors[trilogyColor]) {
+      return colorsStyle.default;
+    }
+    return colorArray[0];
+  } else {
+    if (trilogyColor === "transparent") return "transparent";
+    return colors[trilogyColor][0] || colors["MAIN" /* MAIN */][0];
+  }
+};
+
+// objects/atoms/Background/index.ts
+var getBackgroundClassName = (backgroundType) => {
+  return `background-${getColorClassName(backgroundType)}`;
+};
+
+// objects/facets/Justifiable/index.ts
+var getJustifiedClassName = (justifyContent) => {
+  switch (justifyContent) {
+    case "ALIGNED_CENTER":
+      return "justified-center";
+    case "ALIGNED_START":
+      return "justified-start";
+    case "ALIGNED_END":
+      return "justified-end";
+    default:
+      return "justified-start";
+  }
+};
+var getJustifySelfClassName = (justifyContent) => {
+  switch (justifyContent) {
+    case "ALIGNED_CENTER":
+      return "justified-self-center";
+    case "ALIGNED_START":
+      return "justified-self-start";
+    case "ALIGNED_END":
+      return "justified-selfend";
+    default:
+      return "justified-selfstart";
+  }
+};
+
+// components/icon/Icon.tsx
+var import_clsx = __toESM(require("clsx"));
+var React3 = __toESM(require("react"));
+var Icon = React3.forwardRef(
+  ({ className, id, size, name, circled, stretched, color, backgroundColor, onClick, skeleton, align, ...others }, ref) => {
+    const { styled } = useTrilogyContext();
+    const background = backgroundColor && has(getBackgroundClassName(backgroundColor)) || circled && has(getBackgroundClassName("MAIN" /* MAIN */)) || "";
+    const classes = hashClass(
+      styled,
+      (0, import_clsx.default)(
+        "icon",
+        stretched && is("stretched"),
+        size && is(size),
+        circled && is("circled"),
+        circled && !color && has("text-white"),
+        color && is(`${getColorClassName(color)}`),
+        skeleton && is("loading"),
+        align && (0, import_clsx.default)(is("flex"), is(getJustifySelfClassName(align))),
+        background,
+        className
+      )
+    );
+    return /* @__PURE__ */ React3.createElement("span", { id, onClick: onClick && onClick, className: classes, ...others, ref }, /* @__PURE__ */ React3.createElement("i", { className: hashClass(styled, (0, import_clsx.default)(name)), "aria-hidden": "true" }));
+  }
+);
+Icon.displayName = "Icon" /* Icon */;
+var Icon_default = Icon;
+
+// components/select/Select.tsx
+var React11 = __toESM(require("react"));
+
+// components/select/context/index.tsx
+var import_react3 = __toESM(require("react"));
+var SelectContext = import_react3.default.createContext({
+  selectedOptionValues: [],
+  multiple: false,
+  custom: false,
+  isVisibleOptions: false,
+  setIsVisibleOptions: () => false,
+  setSelectedOptionValues: () => []
+});
+
+// components/select/web/SelectDynamic.tsx
+var import_clsx5 = __toESM(require("clsx"));
+var import_react8 = __toESM(require("react"));
+var import_react_dom = __toESM(require("react-dom"));
+
+// components/input/Input.tsx
+var import_locales = require("@trilogy-ds/locales");
+var import_clsx4 = __toESM(require("clsx"));
+var import_react7 = __toESM(require("react"));
+
+// components/text/Text.tsx
+var React5 = __toESM(require("react"));
+var import_clsx2 = __toESM(require("clsx"));
+
+// components/text/TextEnum.ts
+var TextMarkup = /* @__PURE__ */ ((TextMarkup2) => {
+  TextMarkup2["P"] = "p";
+  TextMarkup2["SPAN"] = "span";
+  return TextMarkup2;
+})(TextMarkup || {});
+
+// components/text/Text.tsx
+var Text = React5.forwardRef(({
+  level,
+  markup,
+  children,
+  className,
+  id,
+  typo,
+  inverted,
+  skeleton,
+  accessibilityLabel,
+  marginless,
+  numberOfLines,
+  ...others
+}, ref) => {
+  const { styled } = useTrilogyContext();
+  const levelText = () => {
+    if (level) {
+      switch (level) {
+        case 1 /* ONE */:
+          return is("level-1");
+        case 2 /* TWO */:
+          return is("level-2");
+        case 3 /* THREE */:
+          return is("level-3");
+        case 4 /* FOUR */:
+          return is("level-4");
+        default:
+          return is(`level-${level}`);
+      }
+    }
+  };
+  const classes = hashClass(
+    styled,
+    (0, import_clsx2.default)(
+      "text",
+      level && levelText(),
+      inverted && is("inverted"),
+      typo,
+      skeleton && is("loading"),
+      marginless && is("marginless"),
+      numberOfLines && is("text-ellipsis"),
+      className
+    )
+  );
+  const isCorrectMarkup2 = (stringMarkup) => {
+    if (stringMarkup in TextMarkup || Object.values(TextMarkup).includes(stringMarkup)) return true;
+  };
+  const Tag = markup && isCorrectMarkup2(markup) ? markup : "p";
+  return /* @__PURE__ */ React5.createElement(
+    Tag,
+    {
+      ref,
+      id,
+      style: numberOfLines ? { WebkitLineClamp: numberOfLines } : {},
+      "aria-label": accessibilityLabel,
+      className: classes,
+      ...others
+    },
+    children
+  );
+});
+Text.displayName = "Text" /* Text */;
+var Text_default = Text;
+
+// objects/facets/Status/index.ts
+var STATUS_COLORS = {
+  SUCCESS: { color: "SUCCESS" /* SUCCESS */, backgroundColor: "SUCCESS_FADE" /* SUCCESS_FADE */ },
+  INFO: { color: "INFO" /* INFO */, backgroundColor: "INFO_FADE" /* INFO_FADE */ },
+  WARNING: { color: "WARNING" /* WARNING */, backgroundColor: "WARNING_FADE" /* WARNING_FADE */ },
+  ERROR: { color: "ERROR" /* ERROR */, backgroundColor: "ERROR_FADE" /* ERROR_FADE */ },
+  DEFAULT: { color: "MAIN" /* MAIN */, backgroundColor: "MAIN_FADE" /* MAIN_FADE */ }
+};
+
+// objects/Typography/TypographyBold/index.tsx
+var import_react4 = require("react");
+
+// components/input/gauge/InputGauge.tsx
+var import_clsx3 = __toESM(require("clsx"));
+var import_react6 = __toESM(require("react"));
+
+// components/input/gauge/hook/useGauge.tsx
+var import_react5 = __toESM(require("react"));
+var useGauge = ({ validationRules, inputValue, securityRules }) => {
+  var _a, _b;
+  const [points, setPoints] = import_react5.default.useState(0);
+  const initStateVerifies = { isVerify: false, color: "NEUTRAL" /* NEUTRAL */ };
+  const [isLengthVerify, setIsLengthVerify] = import_react5.default.useState(initStateVerifies);
+  const [isSpecialCharsVerify, setIsSpecialCharsVerify] = import_react5.default.useState(initStateVerifies);
+  const [isNumberVerify, setIsNumberVerify] = import_react5.default.useState(initStateVerifies);
+  const [isUppercaseVerify, setIsUppercaseVerify] = import_react5.default.useState(initStateVerifies);
+  const [isLowerercaseVerify, setisLowerercaseVerify] = import_react5.default.useState(initStateVerifies);
+  const nbAllVerifies = import_react5.default.useMemo(
+    () => validationRules && Object.values(validationRules).filter((rule) => rule).length || securityRules && securityRules.length || 0,
+    [validationRules, securityRules]
+  );
+  const rules = import_react5.default.useMemo(
+    () => securityRules && securityRules.map(({ label, patternValidator, dataAttribute }) => ({
+      label,
+      validate: !!(patternValidator == null ? void 0 : patternValidator.test(inputValue)),
+      dataAttribute
+    })),
+    [inputValue, securityRules]
+  );
+  const calcPoints = import_react5.default.useMemo(() => {
+    if (validationRules) {
+      return Number((points / nbAllVerifies * 100).toFixed(0));
+    }
+    if (securityRules) {
+      const pts = (rules == null ? void 0 : rules.filter((rule) => rule.validate).length) || 0;
+      return Number((pts / nbAllVerifies * 100).toFixed(0));
+    }
+    return 0;
+  }, [points, nbAllVerifies, rules, validationRules, securityRules]);
+  const widthGauge = import_react5.default.useMemo(() => {
+    if (calcPoints <= 50 && calcPoints > 0) return "50%";
+    if (calcPoints <= 99 && calcPoints > 50) return "75%";
+    if (calcPoints === 100) return "100%";
+    return "0%";
+  }, [calcPoints, nbAllVerifies]);
+  const colorGauge = () => {
+    if (calcPoints <= 50 && calcPoints > 0) return getColorStyle("ERROR" /* ERROR */);
+    if (calcPoints <= 99 && calcPoints > 50) return getColorStyle("WARNING" /* WARNING */);
+    if (calcPoints === 100) return getColorStyle("SUCCESS" /* SUCCESS */);
+    return getColorStyle("NEUTRAL_FADE" /* NEUTRAL_FADE */);
+  };
+  const LengthvalidationRulesText = (0, import_react5.useMemo)(() => {
+    var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j;
+    switch (true) {
+      case (((_a2 = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _a2.min) !== void 0 && ((_b2 = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _b2.max) !== void 0):
+        return `Entre ${(_g = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _g.min} et ${(_h = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _h.max} caract\xE8res`;
+      case (((_c = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _c.min) && !((_d = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _d.max)):
+        return `Minimum ${(_i = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _i.min} caract\xE8res`;
+      case (((_e = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _e.max) && !((_f = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _f.min)):
+        return `Maximum ${(_j = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _j.max} caract\xE8res`;
+      default:
+        return "";
+    }
+  }, [(_a = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _a.min, (_b = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _b.max]);
+  (0, import_react5.useEffect)(() => {
+    var _a2, _b2;
+    const min = ((_a2 = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _a2.min) || 0;
+    const max = ((_b2 = validationRules == null ? void 0 : validationRules.length) == null ? void 0 : _b2.max) || "";
+    const regex = new RegExp(`^.{${min},${max}}$`);
+    const validations = [];
+    (validationRules == null ? void 0 : validationRules.specialChars) && validations.push({ test: /[^\w]/.test(inputValue), setState: setIsSpecialCharsVerify });
+    (validationRules == null ? void 0 : validationRules.number) && validations.push({ test: /[0-9]/.test(inputValue), setState: setIsNumberVerify });
+    (validationRules == null ? void 0 : validationRules.uppercase) && validations.push({ test: /[A-Z]/.test(inputValue), setState: setIsUppercaseVerify });
+    (validationRules == null ? void 0 : validationRules.lowercase) && validations.push({ test: /[a-z]/.test(inputValue), setState: setisLowerercaseVerify });
+    (validationRules == null ? void 0 : validationRules.length) && validations.push({ test: regex.test(inputValue), setState: setIsLengthVerify });
+    validations.forEach(({ test, setState }) => {
+      if (test) return setState({ isVerify: true, color: "SUCCESS" /* SUCCESS */ });
+      return setState(initStateVerifies);
+    });
+    setPoints(validations.filter((item) => item.test).length);
+  }, [inputValue, validationRules]);
+  return {
+    LengthvalidationRulesText,
+    colorGauge,
+    widthGauge,
+    isLengthVerify,
+    isLowerercaseVerify,
+    isNumberVerify,
+    isSpecialCharsVerify,
+    isUppercaseVerify,
+    rules
+  };
+};
+
+// components/input/gauge/InputGauge.tsx
+var InputGauge = ({ validationRules, styled, inputValue, securityRules }) => {
+  const id = (0, import_react6.useId)();
+  const {
+    widthGauge,
+    colorGauge,
+    LengthvalidationRulesText,
+    isLengthVerify,
+    isLowerercaseVerify,
+    isNumberVerify,
+    isSpecialCharsVerify,
+    isUppercaseVerify,
+    rules
+  } = useGauge({ validationRules, inputValue, securityRules });
+  return /* @__PURE__ */ import_react6.default.createElement("div", { "data-testid": "security-gauge", className: hashClass(styled, (0, import_clsx3.default)("security-gauge-container")) }, /* @__PURE__ */ import_react6.default.createElement("div", { className: hashClass(styled, (0, import_clsx3.default)("security-gauge")) }, /* @__PURE__ */ import_react6.default.createElement(
+    "div",
+    {
+      "data-gauge": true,
+      style: { width: widthGauge, backgroundColor: colorGauge() },
+      className: hashClass(styled, (0, import_clsx3.default)("gauge"))
+    }
+  )), /* @__PURE__ */ import_react6.default.createElement("div", { className: hashClass(styled, (0, import_clsx3.default)("security-gauge-verifies")) }, validationRules && /* @__PURE__ */ import_react6.default.createElement(import_react6.default.Fragment, null, /* @__PURE__ */ import_react6.default.createElement(
+    DataVerify,
+    {
+      display: !!(validationRules == null ? void 0 : validationRules.length),
+      dataAttribute: { "data-security-length": true },
+      type: LengthvalidationRulesText,
+      classes: "security-length",
+      color: isLengthVerify.color,
+      iconName: isLengthVerify.isVerify ? "tri-check-circle" /* CHECK_CIRCLE */ : "tri-times" /* TIMES */,
+      styled
+    }
+  ), /* @__PURE__ */ import_react6.default.createElement(
+    DataVerify,
+    {
+      display: !!(validationRules == null ? void 0 : validationRules.uppercase),
+      dataAttribute: { "data-security-uppercase": true },
+      classes: "security-uppercase",
+      type: "Majuscule",
+      color: isUppercaseVerify.color,
+      iconName: isUppercaseVerify.isVerify ? "tri-check-circle" /* CHECK_CIRCLE */ : "tri-times" /* TIMES */,
+      styled
+    }
+  ), /* @__PURE__ */ import_react6.default.createElement(
+    DataVerify,
+    {
+      display: !!(validationRules == null ? void 0 : validationRules.specialChars),
+      dataAttribute: { "data-security-special-chars": true },
+      classes: "security-special-chars",
+      type: "Caract\xE8res sp\xE9ciaux",
+      color: isSpecialCharsVerify.color,
+      iconName: isSpecialCharsVerify.isVerify ? "tri-check-circle" /* CHECK_CIRCLE */ : "tri-times" /* TIMES */,
+      styled
+    }
+  ), /* @__PURE__ */ import_react6.default.createElement(
+    DataVerify,
+    {
+      display: !!(validationRules == null ? void 0 : validationRules.lowercase),
+      dataAttribute: { "data-security-lowercase": true },
+      classes: "security-lowercase",
+      type: "Minuscule",
+      color: isLowerercaseVerify.color,
+      iconName: isLowerercaseVerify.isVerify ? "tri-check-circle" /* CHECK_CIRCLE */ : "tri-times" /* TIMES */,
+      styled
+    }
+  ), /* @__PURE__ */ import_react6.default.createElement(
+    DataVerify,
+    {
+      display: !!(validationRules == null ? void 0 : validationRules.number),
+      dataAttribute: { "data-security-number": true },
+      classes: "security-number",
+      type: "Chiffre",
+      color: isNumberVerify.color,
+      iconName: isNumberVerify.isVerify ? "tri-check-circle" /* CHECK_CIRCLE */ : "tri-times" /* TIMES */,
+      styled
+    }
+  )), securityRules && rules && rules.map((rule) => /* @__PURE__ */ import_react6.default.createElement(
+    DataVerify,
+    {
+      key: `${id}_${rule.label}`,
+      display: true,
+      type: rule.label,
+      color: rule.validate ? "SUCCESS" /* SUCCESS */ : "NEUTRAL" /* NEUTRAL */,
+      iconName: rule.validate ? "tri-check-circle" /* CHECK_CIRCLE */ : "tri-times" /* TIMES */,
+      styled,
+      dataAttribute: rule.dataAttribute
+    }
+  ))));
+};
+var DataVerify = ({
+  dataAttribute,
+  type,
+  display,
+  color,
+  iconName,
+  classes,
+  styled
+}) => {
+  if (!display) return null;
+  return /* @__PURE__ */ import_react6.default.createElement("div", { ...dataAttribute, className: hashClass(styled, (0, import_clsx3.default)("security", classes)) }, /* @__PURE__ */ import_react6.default.createElement(Icon_default, { color, name: iconName, size: "smaller" /* SMALLER */ }), /* @__PURE__ */ import_react6.default.createElement("span", null, type));
+};
+var InputGauge_default = InputGauge;
+
+// components/input/Input.tsx
+var Input = import_react7.default.forwardRef(
+  ({
+    forceControl,
+    label,
+    sample,
+    className,
+    id = import_react7.default.useId(),
+    disabled,
+    onChange,
+    onKeyPress,
+    onKeyUp,
+    onIconClick,
+    onClick,
+    onFocus,
+    onBlur,
+    patternValidator,
+    onMouseEnter,
+    onMouseLeave,
+    name,
+    placeholder,
+    type = "text" /* TEXT */,
+    defaultValue,
+    value,
+    loading,
+    focused,
+    status,
+    help,
+    onStatusChange,
+    customValidator,
+    onSubmit,
+    minLength,
+    maxLength,
+    accessibilityLabel,
+    autoCompleteType,
+    iconNameLeft,
+    iconNameRight,
+    securityGauge,
+    validationRules,
+    securityRules,
+    required,
+    readOnly,
+    autoCapitalize,
+    ...others
+  }, ref) => {
+    const { styled } = useTrilogyContext();
+    const idHelp = (0, import_react7.useId)();
+    const idSample = (0, import_react7.useId)();
+    const inputIcon = /* @__PURE__ */ new Map();
+    inputIcon.set("success" /* SUCCESS */, "tri-check-circle" /* CHECK_CIRCLE */);
+    inputIcon.set("warning" /* WARNING */, "tri-exclamation-circle" /* EXCLAMATION_CIRCLE */);
+    inputIcon.set("error" /* ERROR */, "tri-exclamation-circle" /* EXCLAMATION_CIRCLE */);
+    const [_value, setValue] = (0, import_react7.useState)(defaultValue != null ? defaultValue : "");
+    const [isFocused, setIsFocused] = (0, import_react7.useState)(focused != null ? focused : false);
+    const [isDirty, setIsDirty] = (0, import_react7.useState)(false);
+    const [isTouched, setIsTouched] = (0, import_react7.useState)(false);
+    const [localStatus, setLocalStatus] = (0, import_react7.useState)(status || "default" /* DEFAULT */);
+    const [inputType, setInputType] = (0, import_react7.useState)(type);
+    const [isShowPwd, setIsShowPwd] = (0, import_react7.useState)(false);
+    const helpClasses = (0, import_clsx4.default)("help", localStatus && is(localStatus));
+    const loader = hashClass(styled, (0, import_clsx4.default)(is("searching")));
+    const inputLabelClasses = hashClass(styled, "input-label");
+    const iconTimesClasses = hashClass(styled, (0, import_clsx4.default)(is("justified-self")));
+    const srOnlyClasses = hashClass(styled, (0, import_clsx4.default)("sr-only"));
+    const classes = hashClass(styled, (0, import_clsx4.default)("input", localStatus && is(localStatus)));
+    const wrapperClasses = hashClass(
+      styled,
+      (0, import_clsx4.default)("field", className, type === "password" /* PASSWORD */ && securityGauge && has("gauge"))
+    );
+    const hasIcon = iconNameLeft || iconNameRight;
+    const controlClasses = hashClass(
+      styled,
+      (0, import_clsx4.default)("control", {
+        [has("icons-right")]: hasIcon != null ? hasIcon : iconNameRight || type === "password" /* PASSWORD */,
+        [has("icons-left")]: iconNameLeft || type === "search" /* SEARCH */
+      })
+    );
+    const onPressKey = (0, import_react7.useCallback)((e) => {
+      const target = e.target;
+      return {
+        inputName: target.name,
+        inputValue: target.value,
+        inputKeyCode: e.keyCode,
+        target,
+        event: e,
+        preventDefault: () => e.preventDefault()
+      };
+    }, []);
+    const IconWrapper = (0, import_react7.useCallback)(
+      ({ className: className2, name: name2, color, closeIconSearch, onPress, srOnly, showPassword }) => {
+        const Markup = showPassword ? "button" : "div";
+        return /* @__PURE__ */ import_react7.default.createElement(
+          Markup,
+          {
+            ...showPassword && { "data-show-pwd": true, type: "button" },
+            onClick: (e) => {
+              onPress && onPress();
+              if (onIconClick) {
+                onIconClick({ inputName: name2 != null ? name2 : "", inputValue: _value, target: e.target });
+              }
+            }
+          },
+          /* @__PURE__ */ import_react7.default.createElement(Icon_default, { className: className2, name: name2, size: "small" /* SMALL */, color }),
+          _value && _value.length > 0 && closeIconSearch && /* @__PURE__ */ import_react7.default.createElement(
+            Icon_default,
+            {
+              onClick: () => setValue(""),
+              className: iconTimesClasses,
+              name: "tri-times" /* TIMES_CIRCLE */,
+              size: "small" /* SMALL */
+            }
+          ),
+          showPassword && srOnly && /* @__PURE__ */ import_react7.default.createElement("span", { className: srOnlyClasses }, srOnly)
+        );
+      },
+      [_value, styled]
+    );
+    const validator = !customValidator && patternValidator ? (value2) => patternValidator.test(value2) ? "success" /* SUCCESS */ : "error" /* ERROR */ : customValidator;
+    (0, import_react7.useEffect)(() => {
+      var _a;
+      setValue((_a = value != null ? value : defaultValue) != null ? _a : "");
+    }, [value, defaultValue]);
+    (0, import_react7.useEffect)(() => {
+      setIsFocused(focused != null ? focused : false);
+    }, [focused]);
+    (0, import_react7.useEffect)(() => {
+      if (isFocused) setIsDirty(true);
+      else if (isDirty) setIsTouched(true);
+    }, [isFocused, isDirty]);
+    (0, import_react7.useEffect)(() => {
+      if (!validator || !isTouched) return;
+      setLocalStatus(validator(_value));
+    }, [isFocused, isTouched]);
+    (0, import_react7.useEffect)(() => {
+      setLocalStatus(status || "default" /* DEFAULT */);
+    }, [status]);
+    (0, import_react7.useEffect)(() => {
+      if (onStatusChange) onStatusChange(localStatus);
+    }, [localStatus]);
+    return /* @__PURE__ */ import_react7.default.createElement("div", { className: wrapperClasses, "data-has-gauge": securityGauge ? true : void 0 }, label && /* @__PURE__ */ import_react7.default.createElement("label", { className: inputLabelClasses, htmlFor: id }, label, " ", required && /* @__PURE__ */ import_react7.default.createElement(Text_default, { markup: "span" /* SPAN */, typo: "has-text-error" /* TEXT_ERROR */ }, "*")), sample && /* @__PURE__ */ import_react7.default.createElement(Text_default, { className: "input-sample", level: 2 /* TWO */, id: idSample }, sample), /* @__PURE__ */ import_react7.default.createElement("div", { className: controlClasses }, /* @__PURE__ */ import_react7.default.createElement(
+      "input",
+      {
+        "aria-describedby": `${idHelp} ${idSample}`,
+        id,
+        required,
+        readOnly,
+        ...others,
+        "aria-label": !label ? accessibilityLabel : void 0,
+        type: inputType,
+        className: classes,
+        value,
+        defaultValue,
+        name,
+        onSubmit,
+        autoCapitalize: type === "password" /* PASSWORD */ ? "off" : autoCapitalize || void 0,
+        ref,
+        disabled,
+        minLength,
+        maxLength,
+        autoComplete: autoCompleteType,
+        onKeyUp: (e) => onKeyUp && onKeyUp(onPressKey(e)),
+        onKeyPress: (e) => onKeyPress && onKeyPress(onPressKey(e)),
+        onMouseEnter: (e) => onMouseEnter == null ? void 0 : onMouseEnter(e),
+        onMouseLeave: (e) => onMouseLeave == null ? void 0 : onMouseLeave(e),
+        placeholder,
+        onClick: (e) => {
+          const target = e.target;
+          if (onClick) {
+            onClick({
+              inputName: target.name,
+              inputValue: target.value,
+              target
+            });
+          }
+        },
+        onChange: (e) => {
+          if (inputType !== "date" /* DATE */ && inputType !== "datetime-local" /* DATETIME_LOCAL */ && inputType !== "number" /* NUMBER */ && inputType !== "email" /* EMAIL */) {
+            const caret = e.target.selectionStart;
+            const element = e.target;
+            window.requestAnimationFrame(() => {
+              element.selectionStart = caret;
+              element.selectionEnd = caret;
+            });
+          }
+          if (!forceControl) setValue(e.target.value);
+          if (onChange) {
+            onChange({
+              inputName: e.target.name,
+              inputValue: e.target.value,
+              inputSelectionStart: e.target.selectionStart,
+              target: e.target,
+              event: e
+            });
+          }
+        },
+        onFocus: (e) => {
+          onFocus == null ? void 0 : onFocus(e);
+          setIsFocused(true);
+        },
+        onBlur: (e) => {
+          onBlur == null ? void 0 : onBlur(e);
+          setIsFocused(false);
+        }
+      }
+    ), hasIcon && !localStatus && !loading && iconNameLeft && /* @__PURE__ */ import_react7.default.createElement(IconWrapper, { name: iconNameLeft }), (iconNameLeft || type === "search" /* SEARCH */) && /* @__PURE__ */ import_react7.default.createElement(IconWrapper, { className: "icon-left", name: iconNameLeft || "tri-search" /* SEARCH */ }), iconNameRight && !loading && type !== "password" /* PASSWORD */ && /* @__PURE__ */ import_react7.default.createElement(IconWrapper, { className: "icon-right", name: iconNameRight }), !loading && type === "password" /* PASSWORD */ && /* @__PURE__ */ import_react7.default.createElement(
+      IconWrapper,
+      {
+        showPassword: true,
+        srOnly: !isShowPwd ? import_locales.inputLocale.showPassword : import_locales.inputLocale.hidePassword,
+        className: "icon-right",
+        name: isShowPwd ? "tri-eye-slash" /* EYE_SLASH */ : "tri-eye" /* EYE */,
+        onPress: () => {
+          if (inputType === "password" /* PASSWORD */) {
+            setInputType("text" /* TEXT */);
+            setIsShowPwd(true);
+          } else {
+            setInputType("password" /* PASSWORD */);
+            setIsShowPwd(false);
+          }
+        }
+      }
+    ), loading && /* @__PURE__ */ import_react7.default.createElement("span", { className: loader })), help && /* @__PURE__ */ import_react7.default.createElement(Text_default, { className: helpClasses, id: idHelp }, help), securityGauge && type === "password" /* PASSWORD */ && /* @__PURE__ */ import_react7.default.createElement(
+      InputGauge_default,
+      {
+        validationRules,
+        securityRules,
+        styled,
+        inputValue: _value
+      }
+    ));
+  }
+);
+Input.displayName = "Input" /* Input */;
+var Input_default = Input;
+
+// components/select/web/SelectDynamic.tsx
+var OPTION_SIZE = 48;
+var SelectDynamic = import_react8.default.forwardRef(
+  ({
+    onChange,
+    disabled,
+    onFocus,
+    onBlur,
+    children,
+    selected,
+    name,
+    id,
+    label,
+    iconName,
+    multiple,
+    className,
+    status,
+    placeholder,
+    required,
+    custom,
+    help,
+    sample,
+    ...others
+  }, ref) => {
+    const { styled } = useTrilogyContext();
+    const { setIsVisibleOptions, isVisibleOptions, selectedOptionValues } = (0, import_react8.useContext)(SelectContext);
+    const containerRef = (0, import_react8.useRef)(null);
+    const [openUpward, setOpenUpward] = (0, import_react8.useState)(false);
+    const optionsListSize = (0, import_react8.useRef)(0);
+    const [dropdownStyles, setDropdownStyles] = (0, import_react8.useState)({});
+    const selectClasses = hashClass(styled, (0, import_clsx5.default)("select", className));
+    const optionsClasses = hashClass(styled, (0, import_clsx5.default)("select-options", openUpward && "select-options-top"));
+    const portalClasses = hashClass(styled, "select-trilogy_modal_open");
+    const onClickInput = () => {
+      if (containerRef.current && optionsListSize.current) {
+        const { top, bottom } = containerRef.current.getBoundingClientRect();
+        const windowHeight = window.innerHeight;
+        const spaceBelow = windowHeight - bottom;
+        const padding = 10;
+        const maxHeightBelow = spaceBelow - padding;
+        const maxHeightAbove = top - padding;
+        const openUpward2 = maxHeightBelow < optionsListSize.current && maxHeightAbove > maxHeightBelow;
+        setOpenUpward(openUpward2);
+        setDropdownStyles({
+          maxHeight: openUpward2 ? `${maxHeightAbove}px` : `${maxHeightBelow}px`,
+          overflowY: "auto"
+        });
+      }
+      setIsVisibleOptions((prev) => !prev);
+    };
+    const onCloseOptions = () => setIsVisibleOptions(false);
+    const onKeyPressInput = (keyCode) => {
+      setIsVisibleOptions((prev) => {
+        if (keyCode === 27) return false;
+        if (keyCode === 13) return !prev;
+        return prev;
+      });
+    };
+    const options = (0, import_react8.useMemo)(() => {
+      var _a;
+      return (_a = import_react8.default.Children.map(children, (child) => {
+        if (!import_react8.default.isValidElement(child)) return false;
+        return {
+          label: child.props.children || child.props.label,
+          value: child.props.value
+        };
+      })) == null ? void 0 : _a.filter((option) => option);
+    }, []);
+    const labelsSelected = (0, import_react8.useMemo)(() => {
+      return selectedOptionValues.map((selectedOption) => {
+        const elm = options == null ? void 0 : options.find((opt) => opt.value === selectedOption);
+        return elm == null ? void 0 : elm.label;
+      });
+    }, [selectedOptionValues, options]);
+    (0, import_react8.useEffect)(() => {
+      const childrenCount = import_react8.default.Children.count(children);
+      if (childrenCount > 0) {
+        optionsListSize.current = childrenCount * OPTION_SIZE;
+      }
+    }, [children]);
+    return /* @__PURE__ */ import_react8.default.createElement("div", { className: selectClasses, ref: containerRef, ...others }, /* @__PURE__ */ import_react8.default.createElement(
+      Input_default,
+      {
+        sample,
+        help,
+        required,
+        status,
+        ref,
+        value: labelsSelected == null ? void 0 : labelsSelected.join(", "),
+        name,
+        disabled,
+        label,
+        placeholder,
+        onFocus,
+        iconNameLeft: iconName,
+        onBlur,
+        onClick: onClickInput,
+        className: isVisibleOptions ? "focus" : void 0,
+        onKeyPress: (e) => {
+          e.preventDefault();
+        },
+        onKeyUp: (e) => {
+          e.preventDefault();
+          onKeyPressInput(e.inputKeyCode);
+        },
+        ...{ readOnly: true, id, role: "combobox" }
+      }
+    ), /* @__PURE__ */ import_react8.default.createElement(
+      "ul",
+      {
+        role: "listbox",
+        className: optionsClasses,
+        style: {
+          display: isVisibleOptions ? "block" : "none",
+          ...dropdownStyles
+        }
+      },
+      children
+    ), isVisibleOptions && import_react_dom.default.createPortal(
+      /* @__PURE__ */ import_react8.default.createElement("div", { role: "presentation", className: portalClasses, onClick: onCloseOptions }),
+      document.body
+    ));
+  }
+);
+SelectDynamic.displayName = "Select" /* Select */;
+var SelectDynamic_default = SelectDynamic;
+
+// components/select/web/SelectNative.tsx
+var import_clsx6 = __toESM(require("clsx"));
+var React10 = __toESM(require("react"));
+var SelectNative = React10.forwardRef(
+  ({
+    onChange,
+    disabled,
+    onFocus,
+    onBlur,
+    children,
+    selected,
+    name,
+    id,
+    testId,
+    label,
+    iconName,
+    className,
+    accessibilityLabel,
+    status,
+    required,
+    sample,
+    help,
+    ...others
+  }, ref) => {
+    const { styled } = useTrilogyContext();
+    const idHelp = React10.useId();
+    const idSample = React10.useId();
+    const [focused, setIsFocused] = React10.useState(false);
+    const [selectedValues, setSelectedValues] = React10.useState(selected);
+    const selectClasses = hashClass(styled, (0, import_clsx6.default)("select", className));
+    const controlClass = hashClass(styled, (0, import_clsx6.default)("control", iconName && "has-icons-left"));
+    const helpClasses = (0, import_clsx6.default)("help", status && is(status));
+    const handleFocus = React10.useCallback((e) => {
+      setIsFocused(true);
+      onFocus && onFocus(e);
+    }, []);
+    const handleBlur = React10.useCallback((e) => {
+      setIsFocused(false);
+      onBlur && onBlur(e);
+    }, []);
+    React10.useEffect(() => {
+      setSelectedValues(selected);
+    }, [selected]);
+    return /* @__PURE__ */ React10.createElement("div", { className: selectClasses }, /* @__PURE__ */ React10.createElement("div", { className: hashClass(styled, (0, import_clsx6.default)("field", focused && "focus")) }, label && /* @__PURE__ */ React10.createElement("label", { className: hashClass(styled, "input-label"), htmlFor: id }, label, " ", required && /* @__PURE__ */ React10.createElement(Text_default, { markup: "span" /* SPAN */, typo: "has-text-error" /* TEXT_ERROR */ }, "*")), sample && /* @__PURE__ */ React10.createElement(Text_default, { className: "input-sample", level: 2 /* TWO */, id: idSample }, sample), /* @__PURE__ */ React10.createElement("div", { className: controlClass }, /* @__PURE__ */ React10.createElement(
+      "select",
+      {
+        ref,
+        className: hashClass(styled, (0, import_clsx6.default)(!label && "no-label", status && is(status))),
+        value: selectedValues,
+        "aria-label": accessibilityLabel,
+        "data-testid": testId,
+        onChange: (e) => {
+          const selectedV = Array.from(e.target.selectedOptions).map((select) => select.value);
+          setSelectedValues(selectedV);
+          if (onChange) {
+            onChange({
+              selectValue: e.target.value,
+              selectName: e.target.name,
+              selectId: e.target.id,
+              name: e.target.name,
+              selectedOptions: selectedV,
+              target: e.target
+            });
+          }
+        },
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        id: id ? String(id) : void 0,
+        name,
+        disabled,
+        role: "listbox",
+        ...others
+      },
+      React10.Children.map(children, (child) => {
+        if (!React10.isValidElement(child)) return null;
+        const props = {
+          ...child.props,
+          native: "true"
+        };
+        return /* @__PURE__ */ React10.createElement(option_default, { ...props });
+      })
+    ), iconName && /* @__PURE__ */ React10.createElement(Icon_default, { name: iconName, size: "small" })), help && /* @__PURE__ */ React10.createElement(Text_default, { className: helpClasses, id: idHelp }, help)));
+  }
+);
+SelectNative.displayName = "Select" /* Select */;
+var SelectNative_default = SelectNative;
+
+// components/select/Select.tsx
+var Select = React11.forwardRef(({ selected, ...props }, ref) => {
+  const [isVisibleOptions, setIsVisibleOptions] = React11.useState(false);
+  const [selectedOptionValues, setSelectedOptionValues] = React11.useState([]);
+  React11.useEffect(() => {
+    const value = typeof selected === "string" || typeof selected === "number" ? [selected] : !selected || selected === null ? [] : selected;
+    setSelectedOptionValues(value);
+  }, [selected]);
+  if (props.custom || props.multiple)
+    return /* @__PURE__ */ React11.createElement(
+      SelectContext.Provider,
+      {
+        value: {
+          custom: props.custom || false,
+          multiple: props.multiple || false,
+          selectedOptionValues,
+          isVisibleOptions,
+          setSelectedOptionValues,
+          setIsVisibleOptions,
+          onChange: props.onChange
+        }
+      },
+      /* @__PURE__ */ React11.createElement(SelectDynamic_default, { ref, selected, ...props })
+    );
+  return /* @__PURE__ */ React11.createElement(SelectNative_default, { ref, selected, ...props });
+});
+Select.displayName = "Select" /* Select */;
+var Select_default = Select;
+
+// components/select/option/SelectOption.tsx
+var import_clsx7 = __toESM(require("clsx"));
+var React12 = __toESM(require("react"));
+var SelectOption = React12.forwardRef(
+  ({ id, className, value = "", disabled, children, onClick, label, iconName, testId, ...others }, ref) => {
+    const { styled } = useTrilogyContext();
+    const { custom, selectedOptionValues, setSelectedOptionValues, multiple, setIsVisibleOptions, onChange } = React12.useContext(SelectContext);
+    const isChecked = selectedOptionValues.includes(value);
+    const selectClasses = hashClass(styled, (0, import_clsx7.default)("option", isChecked && "focus", disabled && is("disabled"), className));
+    const handleClickOption = () => {
+      setSelectedOptionValues((prev) => {
+        const isInclude = prev.includes(value);
+        const newOptionsSelected = !multiple && isInclude ? [] : !multiple && !isInclude ? [value] : isInclude ? prev.filter((opt) => opt !== value) : [...prev, value];
+        if (onChange) {
+          onChange({
+            selectValue: isInclude ? void 0 : value,
+            selectName: isInclude ? void 0 : children || label,
+            selectId: isInclude ? void 0 : id,
+            name: isInclude ? void 0 : children || label,
+            selectedOptions: newOptionsSelected,
+            target: void 0
+          });
+        }
+        return newOptionsSelected;
+      });
+      if (!multiple) setIsVisibleOptions(false);
+    };
+    if (custom || multiple) {
+      return /* @__PURE__ */ React12.createElement(
+        "li",
+        {
+          ref,
+          id,
+          className: selectClasses,
+          "data-selected": isChecked,
+          role: "option",
+          "aria-selected": isChecked,
+          "data-value": value,
+          onClick: !disabled ? handleClickOption : void 0,
+          ...others
+        },
+        iconName && /* @__PURE__ */ React12.createElement(Icon_default, { name: iconName }),
+        label || children
+      );
+    }
+    return /* @__PURE__ */ React12.createElement(
+      "option",
+      {
+        ref,
+        role: "option",
+        id,
+        value,
+        disabled,
+        "aria-label": label,
+        "data-testid": testId,
+        onClick,
+        ...others
+      },
+      children || label
+    );
+  }
+);
+SelectOption.displayName = "SelectOption" /* SelectOption */;
+var SelectOption_default = SelectOption;
+
+// components/select/option/index.ts
+var option_default = SelectOption_default;
+
+// components/calendar/Calendar.tsx
+var days = [...import_locales2.calendarLocale.days];
+var months = [...import_locales2.calendarLocale.months];
+var currentDate = /* @__PURE__ */ new Date();
+function checkIsRange(date) {
+  return !(date instanceof Date);
+}
+var Calendar = import_react9.default.forwardRef(
+  ({
+    value = currentDate,
+    minDate = new Date(currentDate.getFullYear() - 10, 0, 1),
+    maxDate = new Date(currentDate.getFullYear() + 10, 12, 0),
+    disabled,
+    readOnly,
+    disabledDates,
+    onChange,
+    onMonthChange
+  }, ref) => {
+    const { styled } = useTrilogyContext();
+    const [visibleMonth, setVisibleMonth] = import_react9.default.useState(
+      value instanceof Date ? value : value[0] || currentDate
+    );
+    const [activeDate, setActiveDate] = import_react9.default.useState(value);
+    const [dateEndHovered, setDateEndHovered] = import_react9.default.useState();
+    const refsDays = import_react9.default.useRef([]);
+    const refDayFocused = import_react9.default.useRef();
+    const refs = import_react9.default.useRef([]);
+    const weeksId = import_react9.default.useId();
+    const daysId = import_react9.default.useId();
+    const calendarClasses = hashClass(styled, (0, import_clsx8.default)("calendar"));
+    const calendarheaderClasses = hashClass(styled, (0, import_clsx8.default)("calendar-header"));
+    const headerDropdownClasses = hashClass(styled, (0, import_clsx8.default)("calendar-header-dropdown"));
+    const calendarActiveMonthClasses = hashClass(styled, (0, import_clsx8.default)("calendar-active-month"));
+    const calendarDayLabelClasses = hashClass(styled, (0, import_clsx8.default)("calendar-week-day-label"));
+    const calendarWeekDayClasses = hashClass(styled, (0, import_clsx8.default)("calendar-week-day"));
+    const calendarActiveDateClasses = hashClass(styled, (0, import_clsx8.default)("calendar-active-date"));
+    const calendarNextMonthClasses = hashClass(styled, (0, import_clsx8.default)("calendar-next-month"));
+    const calendarPrevMonthClasses = hashClass(styled, (0, import_clsx8.default)("calendar-prev-month"));
+    const calendarWeekDayDisabledClasses = hashClass(styled, (0, import_clsx8.default)("calendar-week-day-disabled"));
+    const isDisabledClass = hashClass(styled, (0, import_clsx8.default)(is("disabled")));
+    const isActiveClasses = hashClass(styled, (0, import_clsx8.default)(is("active")));
+    const calendarWeekClasses = hashClass(styled, (0, import_clsx8.default)("calendar-week"));
+    const dateStartClasses = hashClass(styled, (0, import_clsx8.default)("calendar-date-start"));
+    const dateEndClasses = hashClass(styled, (0, import_clsx8.default)("calendar-date-end"));
+    const rangeClasses = hashClass(styled, (0, import_clsx8.default)("calendar-range"));
+    const dateInRangeClasses = hashClass(styled, (0, import_clsx8.default)("calendar-date-in-range"));
+    const rangeInitClasses = hashClass(styled, (0, import_clsx8.default)("calendar-range-init"));
+    const rondedLeftClasses = hashClass(styled, (0, import_clsx8.default)("calendar-date-rounded-left"));
+    const rondedRightClasses = hashClass(styled, (0, import_clsx8.default)("calendar-date-rounded-right"));
+    const isRange = checkIsRange(activeDate);
+    const isNextDisabled = import_react9.default.useMemo(
+      () => disabled || (maxDate == null ? void 0 : maxDate.getMonth()) === (visibleMonth == null ? void 0 : visibleMonth.getMonth()) && (maxDate == null ? void 0 : maxDate.getFullYear()) === (visibleMonth == null ? void 0 : visibleMonth.getFullYear()),
+      [maxDate, visibleMonth, disabled]
+    );
+    const isPrevDisabled = import_react9.default.useMemo(
+      () => disabled || (minDate == null ? void 0 : minDate.getMonth()) === (visibleMonth == null ? void 0 : visibleMonth.getMonth()) && (minDate == null ? void 0 : minDate.getFullYear()) === (visibleMonth == null ? void 0 : visibleMonth.getFullYear()),
+      [minDate, visibleMonth, disabled]
+    );
+    const getAllDaysInMonth = import_react9.default.useCallback((year, month) => {
+      const date = new Date(year, month, 1);
+      const days2 = [];
+      const firstDayOfMonth = date.getDay();
+      const lastDayOfMonth = new Date(year, month + 1, 0).getDate();
+      const allDays = [];
+      for (let i = 0; i < firstDayOfMonth; i++) days2.push(null);
+      for (let day = 1; day <= lastDayOfMonth; day++) days2.push(new Date(year, month, day));
+      for (let i = 0; i < days2.length; i += 7) allDays.push(days2.slice(i, i + 7));
+      return allDays;
+    }, []);
+    const yearsBetween = import_react9.default.useMemo(() => {
+      const minYear = minDate.getFullYear();
+      const maxYear = maxDate.getFullYear();
+      const currentYear = value instanceof Date && (value == null ? void 0 : value.getFullYear());
+      const isCurrentYearInclude = currentYear && currentYear >= minYear && currentYear <= maxYear;
+      let years = Array.from({ length: maxYear - minYear + 1 }, (_, i) => {
+        const year = minYear + i;
+        return {
+          value: year,
+          disabled: false
+        };
+      });
+      if (currentYear && !isCurrentYearInclude) {
+        years = [{ value: currentYear, disabled: true }, ...years];
+      }
+      return years;
+    }, [minDate, maxDate, value]);
+    const availableMonths = import_react9.default.useMemo(() => {
+      const currentYear = visibleMonth.getFullYear();
+      const minYear = minDate.getFullYear();
+      const maxYear = maxDate.getFullYear();
+      const minMonth = minDate.getMonth();
+      const maxMonth = maxDate.getMonth();
+      return Array.from({ length: 12 }, (_, monthIndex) => {
+        if (currentYear < minYear || currentYear > maxYear) return false;
+        if (currentYear === minYear && monthIndex < minMonth) return false;
+        if (currentYear === maxYear && monthIndex > maxMonth) return false;
+        return true;
+      });
+    }, [minDate, maxDate, visibleMonth]);
+    const availableYear = import_react9.default.useMemo(() => {
+      const minYear = minDate.getFullYear();
+      const maxYear = maxDate.getFullYear();
+      return Array.from({ length: maxYear - minYear + 1 }, (_, i) => minYear + i);
+    }, [minDate, maxDate, visibleMonth]);
+    const allDaysInMonth = import_react9.default.useMemo(() => {
+      refsDays.current = [];
+      const activeYear = visibleMonth.getFullYear();
+      const activeMonth = visibleMonth.getMonth();
+      return getAllDaysInMonth(activeYear, activeMonth);
+    }, [visibleMonth]);
+    const handleClickNextPrevMonth = import_react9.default.useCallback(
+      (month) => {
+        const nextMonth = new Date(visibleMonth.getFullYear(), visibleMonth.getMonth() + month, visibleMonth.getDate());
+        setVisibleMonth(nextMonth);
+        onMonthChange && onMonthChange(nextMonth);
+      },
+      [visibleMonth, onMonthChange]
+    );
+    const handleMonthSelect = import_react9.default.useCallback(
+      (selectedMonth) => {
+        const newDate = new Date(visibleMonth.getFullYear(), selectedMonth, visibleMonth.getDate());
+        setVisibleMonth(newDate);
+        onMonthChange && onMonthChange(newDate);
+      },
+      [visibleMonth, onMonthChange, minDate, maxDate]
+    );
+    const handleYearSelect = import_react9.default.useCallback(
+      (selectedYear) => {
+        const newDate = new Date(selectedYear, visibleMonth.getMonth(), visibleMonth.getDate());
+        if (newDate.getTime() < minDate.getTime() || newDate.getTime() > maxDate.getTime()) {
+          if (newDate.getTime() < minDate.getTime()) {
+            setVisibleMonth(new Date(selectedYear, minDate.getMonth(), visibleMonth.getDate()));
+            onMonthChange && onMonthChange(new Date(selectedYear, minDate.getMonth(), visibleMonth.getDate()));
+          } else {
+            setVisibleMonth(new Date(selectedYear, maxDate.getMonth(), visibleMonth.getDate()));
+            onMonthChange && onMonthChange(new Date(selectedYear, maxDate.getMonth(), visibleMonth.getDate()));
+          }
+          return;
+        }
+        setVisibleMonth(newDate);
+        onMonthChange && onMonthChange(newDate);
+      },
+      [visibleMonth, onMonthChange, minDate, maxDate]
+    );
+    const navigateInDaysWithKeyboard = import_react9.default.useCallback(
+      (currentIndex, nextIndex) => {
+        var _a;
+        const nextRef = refsDays.current[currentIndex + nextIndex];
+        if (nextRef) {
+          refDayFocused.current = nextRef;
+          return nextRef.focus();
+        }
+        const mustNextMonth = [1, 7].includes(nextIndex);
+        const mustPrevMonth = [-1, -7].includes(nextIndex);
+        setVisibleMonth((prev) => {
+          const currentYear = prev.getFullYear();
+          const currentMonth = prev.getMonth();
+          if (mustNextMonth && !isNextDisabled) return new Date(currentYear, currentMonth + 1);
+          if (mustPrevMonth && !isPrevDisabled) return new Date(currentYear, currentMonth - 1);
+          return prev;
+        });
+        if (mustNextMonth && isNextDisabled) return;
+        if (mustPrevMonth && isPrevDisabled) return;
+        const prevDayFocused = new Date(Number((_a = refDayFocused.current) == null ? void 0 : _a.dataset.timestamp));
+        setTimeout(() => {
+          const year = prevDayFocused.getFullYear();
+          const month = prevDayFocused.getMonth();
+          const day = prevDayFocused.getDate() + nextIndex;
+          const nextDayFocused = new Date(year, month, day);
+          refsDays.current[nextDayFocused.getDate() - 1].focus();
+          refDayFocused.current = refsDays.current[nextDayFocused.getDate() - 1];
+        }, 10);
+      },
+      [refsDays.current, refDayFocused.current, isNextDisabled, isPrevDisabled]
+    );
+    const handlePressEnterInDays = import_react9.default.useCallback(
+      (e) => {
+        if (readOnly) return;
+        const elm = e.target;
+        if (!elm) return;
+        refsDays.current.forEach((day) => day.tabIndex = -1);
+        elm.tabIndex = 0;
+        const newDate = new Date(Number(elm.dataset.timestamp));
+        let newActiveDate = [newDate];
+        if (!isRange) newActiveDate = newDate;
+        if (isRange && activeDate.length === 1 && newDate.getTime() > activeDate[0].getTime()) {
+          newActiveDate = [...activeDate, newDate];
+        }
+        setActiveDate(newActiveDate);
+        setDateEndHovered(void 0);
+        onChange && onChange(newActiveDate);
+      },
+      [refsDays.current, onChange, readOnly, activeDate, isRange]
+    );
+    const onKeyDownDay = import_react9.default.useCallback(
+      (e, index, isDisabled) => {
+        switch (e.key) {
+          case "ArrowRight":
+            return navigateInDaysWithKeyboard(index, 1);
+          case "ArrowLeft":
+            return navigateInDaysWithKeyboard(index, -1);
+          case "ArrowUp":
+            return navigateInDaysWithKeyboard(index, -7);
+          case "ArrowDown":
+            return navigateInDaysWithKeyboard(index, 7);
+          case "Enter":
+            return !isDisabled && handlePressEnterInDays(e);
+          default:
+            return;
+        }
+      },
+      [handlePressEnterInDays, navigateInDaysWithKeyboard]
+    );
+    import_react9.default.useEffect(() => {
+      var _a, _b;
+      if (refsDays.current) {
+        const activeDateIndex = refsDays.current.findIndex((day) => day.tabIndex === 0);
+        if (activeDateIndex === -1 && ((_a = refsDays == null ? void 0 : refsDays.current[0]) == null ? void 0 : _a.tabIndex)) {
+          const firstActiveDate = refsDays.current.findIndex((day) => !day.disabled);
+          if (firstActiveDate !== -1) {
+            refsDays.current[firstActiveDate].tabIndex = 0;
+            refDayFocused.current = refsDays.current[firstActiveDate];
+          }
+        }
+        if (activeDateIndex !== -1 && ((_b = refsDays == null ? void 0 : refsDays.current[0]) == null ? void 0 : _b.tabIndex)) {
+          refDayFocused.current = refsDays.current[activeDateIndex];
+        }
+      }
+    }, [refsDays.current, refDayFocused.current]);
+    import_react9.default.useEffect(() => {
+      setActiveDate(value);
+      if (value instanceof Date) return setVisibleMonth(value);
+      if (!(value instanceof Date) && value[0]) return setVisibleMonth(value[0]);
+    }, [value]);
+    return /* @__PURE__ */ import_react9.default.createElement(
+      "table",
+      {
+        "data-calendar-trilogy": "",
+        ref,
+        className: (0, import_clsx8.default)(
+          calendarClasses,
+          isRange && rangeClasses,
+          isRange && activeDate.length === 1 && rangeInitClasses
+        )
+      },
+      /* @__PURE__ */ import_react9.default.createElement("thead", { className: calendarheaderClasses }, /* @__PURE__ */ import_react9.default.createElement("tr", null, /* @__PURE__ */ import_react9.default.createElement("th", { colSpan: 1, className: calendarPrevMonthClasses }, /* @__PURE__ */ import_react9.default.createElement(
+        "button",
+        {
+          "data-focusable": !isPrevDisabled,
+          onClick: () => handleClickNextPrevMonth(-1),
+          "aria-label": "Previous month",
+          type: "button",
+          disabled: isPrevDisabled,
+          ref: (el) => {
+            if (el && refs) refs.current[1] = el;
+          }
+        },
+        /* @__PURE__ */ import_react9.default.createElement(Icon_default, { name: "tri-arrow-left" })
+      )), /* @__PURE__ */ import_react9.default.createElement("th", { colSpan: 5, className: calendarActiveMonthClasses }, /* @__PURE__ */ import_react9.default.createElement("div", { className: headerDropdownClasses }, /* @__PURE__ */ import_react9.default.createElement(
+        Select_default,
+        {
+          "data-focusable": "true",
+          selected: String(visibleMonth.getMonth()),
+          onChange: (value2) => handleMonthSelect(Number(value2.selectValue)),
+          ref: (el) => {
+            if (el && refs) refs.current[2] = el;
+          }
+        },
+        months.map((monthName, monthIndex) => /* @__PURE__ */ import_react9.default.createElement(option_default, { key: monthIndex, value: String(monthIndex), disabled: !availableMonths[monthIndex] }, monthName))
+      ), /* @__PURE__ */ import_react9.default.createElement(
+        Select_default,
+        {
+          "data-focusable": "true",
+          selected: String(visibleMonth.getFullYear()),
+          onChange: (value2) => handleYearSelect(Number(value2.selectValue)),
+          ref: (el) => {
+            if (el && refs) refs.current[3] = el;
+          }
+        },
+        yearsBetween.map((year) => /* @__PURE__ */ import_react9.default.createElement(
+          option_default,
+          {
+            key: year.value,
+            value: String(year.value),
+            disabled: !availableYear.includes(year.value)
+          },
+          String(year.value)
+        ))
+      ))), /* @__PURE__ */ import_react9.default.createElement("th", { colSpan: 1, className: calendarNextMonthClasses }, /* @__PURE__ */ import_react9.default.createElement(
+        "button",
+        {
+          "data-focusable": !isNextDisabled,
+          onClick: () => handleClickNextPrevMonth(1),
+          "aria-label": "Next month",
+          type: "button",
+          disabled: isNextDisabled,
+          ref: (el) => {
+            if (el && refs) refs.current[4] = el;
+          }
+        },
+        /* @__PURE__ */ import_react9.default.createElement(Icon_default, { name: "tri-arrow-right" })
+      ))), /* @__PURE__ */ import_react9.default.createElement("tr", null, days.map((day, index) => {
+        return /* @__PURE__ */ import_react9.default.createElement("td", { className: calendarDayLabelClasses, key: index }, /* @__PURE__ */ import_react9.default.createElement(Text_default, null, day.slice(0, 1)));
+      }))),
+      /* @__PURE__ */ import_react9.default.createElement("tbody", null, allDaysInMonth.map((week, weekIndex) => {
+        return /* @__PURE__ */ import_react9.default.createElement(
+          "tr",
+          {
+            key: `${weeksId}_${weekIndex}`,
+            className: calendarWeekClasses,
+            onMouseLeave: () => setDateEndHovered(void 0)
+          },
+          week.map((day, dayIndex) => {
+            const ind = day !== null && day.getDate() - 1;
+            const isDateStart = isRange && activeDate[0] && (day == null ? void 0 : day.getTime()) === activeDate[0].getTime();
+            const isDateEnd = isRange && activeDate[1] && (day == null ? void 0 : day.getTime()) === activeDate[1].getTime();
+            const today = /* @__PURE__ */ new Date();
+            const isToday = (day == null ? void 0 : day.getFullYear()) === today.getFullYear() && (day == null ? void 0 : day.getMonth()) === today.getMonth() && (day == null ? void 0 : day.getDate()) === today.getDate();
+            const isActive = !isRange ? (day == null ? void 0 : day.getFullYear()) === activeDate.getFullYear() && (day == null ? void 0 : day.getMonth()) === activeDate.getMonth() && (day == null ? void 0 : day.getDate()) === activeDate.getDate() : activeDate == null ? void 0 : activeDate.some(
+              (date) => (date == null ? void 0 : date.getFullYear()) === (day == null ? void 0 : day.getFullYear()) && (date == null ? void 0 : date.getMonth()) === (day == null ? void 0 : day.getMonth()) && (date == null ? void 0 : date.getDate()) === (day == null ? void 0 : day.getDate())
+            );
+            const isDisabled = disabled || day && day.getTime() > (maxDate == null ? void 0 : maxDate.getTime()) || day && day.getTime() < (minDate == null ? void 0 : minDate.getTime()) || day && (disabledDates == null ? void 0 : disabledDates.some(
+              (date) => (date == null ? void 0 : date.getFullYear()) === (day == null ? void 0 : day.getFullYear()) && (date == null ? void 0 : date.getMonth()) === (day == null ? void 0 : day.getMonth()) && (date == null ? void 0 : date.getDate()) === (day == null ? void 0 : day.getDate())
+            )) || false;
+            const isInRange = isRange && activeDate[0] && dateEndHovered && day && day.getTime() >= activeDate[0].getTime() && day.getTime() < dateEndHovered.getTime() || isRange && activeDate[0] && activeDate[1] && day && day.getTime() >= activeDate[0].getTime() && day.getTime() < activeDate[1].getTime();
+            return /* @__PURE__ */ import_react9.default.createElement(
+              "td",
+              {
+                key: `${daysId}_${dayIndex}_${day == null ? void 0 : day.getTime()}`,
+                className: (0, import_clsx8.default)(
+                  calendarWeekDayClasses,
+                  isActive && calendarActiveDateClasses,
+                  isDisabled && calendarWeekDayDisabledClasses,
+                  isDateStart && dateStartClasses,
+                  isDateEnd && dateEndClasses,
+                  isInRange && dateInRangeClasses,
+                  dayIndex === 0 && rondedLeftClasses,
+                  dayIndex === 6 && rondedRightClasses
+                )
+              },
+              day && ind !== false && /* @__PURE__ */ import_react9.default.createElement(
+                "button",
+                {
+                  disabled: isDisabled,
+                  type: "button",
+                  onKeyDown: (e) => onKeyDownDay(e, ind, isDisabled),
+                  tabIndex: isActive ? 0 : -1,
+                  "aria-selected": isActive ? "true" : "false",
+                  "data-timestamp": day == null ? void 0 : day.getTime(),
+                  ref: (el) => {
+                    if (el) refsDays.current[ind] = el;
+                  },
+                  onMouseUp: (e) => !isDisabled && handlePressEnterInDays(e),
+                  className: (0, import_clsx8.default)(isDisabled && isDisabledClass, isActive && isActiveClasses),
+                  onMouseOver: () => {
+                    if (!isRange) return;
+                    if (activeDate[0] !== void 0 && activeDate.length === 1) setDateEndHovered(day);
+                  },
+                  onClick: () => {
+                    refDayFocused.current = refsDays.current[ind];
+                  },
+                  ...isToday && { "data-today": "true" },
+                  ...isActive && { "data-active-date": "true" }
+                },
+                day.getDate()
+              )
+            );
+          })
+        );
+      }))
+    );
+  }
+);
+Calendar.displayName = "Calendar" /* Calendar */;
+var Calendar_default = Calendar;
+
+// helpers/clickOutside/index.ts
+var import_react10 = require("react");
+var useClickOutside = (ref, callback) => {
+  const stableCallback = (0, import_react10.useCallback)(callback, [callback]);
+  (0, import_react10.useEffect)(() => {
+    const handleClickOutside = (event) => {
+      if (ref.current && !ref.current.contains(event.target)) {
+        stableCallback();
+      }
+    };
+    document.addEventListener("mouseup", handleClickOutside);
+    return () => {
+      document.removeEventListener("mouseup", handleClickOutside);
+    };
+  }, [ref, stableCallback]);
+};
+
+// components/datepicker/DatePicker.tsx
+var import_clsx15 = __toESM(require("clsx"));
+var import_react14 = __toESM(require("react"));
+var import_react_dom2 = __toESM(require("react-dom"));
+
+// components/button/Button.tsx
+var import_clsx9 = __toESM(require("clsx"));
+var import_react11 = __toESM(require("react"));
+
+// components/button/ButtonEnum.ts
+var ButtonMarkup = /* @__PURE__ */ ((ButtonMarkup2) => {
+  ButtonMarkup2["BUTTON"] = "button";
+  ButtonMarkup2["INPUT"] = "input";
+  ButtonMarkup2["A"] = "a";
+  return ButtonMarkup2;
+})(ButtonMarkup || {});
+
+// components/button/Button.tsx
+var Button = import_react11.default.forwardRef(
+  ({
+    markup,
+    loading,
+    variant,
+    href,
+    id,
+    fullwidth,
+    children,
+    className,
+    to,
+    accessibilityLabel,
+    onClick,
+    name,
+    routerLink,
+    type,
+    iconName,
+    disabled,
+    ...others
+  }, ref) => {
+    const isDisabled = disabled || false;
+    const { styled } = useTrilogyContext();
+    const isCorrectMarkup2 = (stringMarkup) => {
+      if (stringMarkup in ButtonMarkup || Object.values(ButtonMarkup).includes(stringMarkup))
+        return true;
+    };
+    const getClassNames = (loading2, variant2, fullwidth2, className2) => {
+      return (0, import_clsx9.default)(
+        "button",
+        loading2 && is("loading"),
+        variant2 && is(getButtonVariantClassName(variant2)),
+        fullwidth2 && is("fullwidth"),
+        className2
+      );
+    };
+    const classes = hashClass(styled, getClassNames(loading, variant, fullwidth, className));
+    const Tag = markup && isCorrectMarkup2(markup) ? markup : "button";
+    if (Tag === "button" && !href && !to) {
+      return /* @__PURE__ */ import_react11.default.createElement(
+        "button",
+        {
+          ref,
+          id,
+          "aria-label": accessibilityLabel,
+          className: classes,
+          disabled: isDisabled,
+          name,
+          onClick: (e) => {
+            !isDisabled && (onClick == null ? void 0 : onClick(e));
+            e.stopPropagation();
+          },
+          type: type != null ? type : "button",
+          ...others
+        },
+        iconName && /* @__PURE__ */ import_react11.default.createElement(Icon_default, { className: !children ? "is-marginless" : "", name: iconName }),
+        children
+      );
+    }
+    if (Tag === "input") {
+      return /* @__PURE__ */ import_react11.default.createElement(
+        "input",
+        {
+          ref,
+          id,
+          className: classes,
+          "aria-label": accessibilityLabel,
+          name,
+          onClick: (e) => {
+            !isDisabled && (onClick == null ? void 0 : onClick(e));
+            e.stopPropagation();
+          },
+          disabled: isDisabled,
+          type: type != null ? type : "submit",
+          value: `${children}`,
+          ...others
+        }
+      );
+    }
+    if (routerLink && to && !isDisabled) {
+      const RouterLink = routerLink ? routerLink : "a";
+      return /* @__PURE__ */ import_react11.default.createElement(RouterLink, { ref, "aria-label": accessibilityLabel, to, className: classes, ...others }, iconName && /* @__PURE__ */ import_react11.default.createElement(Icon_default, { className: !children ? "is-marginless" : "", name: iconName }), children);
+    }
+    return /* @__PURE__ */ import_react11.default.createElement(
+      "a",
+      {
+        ref,
+        id,
+        "aria-label": accessibilityLabel,
+        className: classes,
+        href,
+        onClick: (e) => {
+          !isDisabled && (onClick == null ? void 0 : onClick(e));
+          e.stopPropagation();
+        },
+        ...others,
+        ...disabled && { "aria-disabled": true }
+      },
+      iconName && /* @__PURE__ */ import_react11.default.createElement(Icon_default, { className: !children ? "is-marginless" : "", name: iconName }),
+      children
+    );
+  }
+);
+Button.displayName = "Button" /* Button */;
+
+// components/button/list/ButtonList.tsx
+var import_clsx10 = __toESM(require("clsx"));
+var React15 = __toESM(require("react"));
+var ButtonList = React15.forwardRef(
+  ({ className, id, align, direction, ...others }, ref) => {
+    const { styled } = useTrilogyContext();
+    return /* @__PURE__ */ React15.createElement(
+      "div",
+      {
+        ref,
+        id,
+        className: hashClass(
+          styled,
+          (0, import_clsx10.default)(
+            "buttons",
+            className,
+            align && is(getJustifiedClassName(align)),
+            direction === "column" /* COLUMN */ && is("vertical")
+          )
+        ),
+        ...others
+      }
+    );
+  }
+);
+ButtonList.displayName = "ButtonList" /* ButtonList */;
+
+// components/title/Title.tsx
+var import_clsx11 = __toESM(require("clsx"));
+var import_react12 = __toESM(require("react"));
+
+// components/title/TitleEnum.ts
+var TitleMarkup = /* @__PURE__ */ ((TitleMarkup2) => {
+  TitleMarkup2["H1"] = "h1";
+  TitleMarkup2["H2"] = "h2";
+  TitleMarkup2["H3"] = "h3";
+  TitleMarkup2["H4"] = "h4";
+  TitleMarkup2["H5"] = "h5";
+  TitleMarkup2["H6"] = "h6";
+  TitleMarkup2["P"] = "p";
+  TitleMarkup2["SPAN"] = "span";
+  TitleMarkup2["DIV"] = "div";
+  return TitleMarkup2;
+})(TitleMarkup || {});
+
+// components/title/Title.tsx
+var getTitleLevel = (level) => {
+  if (level) {
+    switch (level) {
+      case 1 /* ONE */:
+        return is(`level-1`);
+      case 2 /* TWO */:
+        return is(`level-2`);
+      case 3 /* THREE */:
+        return is(`level-3`);
+      case 4 /* FOUR */:
+        return is(`level-4`);
+      case 5 /* FIVE */:
+        return is(`level-5`);
+      case 6 /* SIX */:
+        return is(`level-6`);
+      default:
+        return is(`level-${level}`);
+    }
+  }
+};
+var isCorrectMarkup = (stringMarkup) => {
+  return stringMarkup in TitleMarkup || Object.values(TitleMarkup).includes(stringMarkup);
+};
+var Title = import_react12.default.forwardRef(({
+  level = 1 /* ONE */,
+  markup,
+  children,
+  className,
+  id,
+  typo,
+  skeleton,
+  inverted,
+  onClick,
+  accessibilityLabel,
+  subtitle,
+  overline,
+  marginless,
+  ...others
+}, ref) => {
+  const { styled } = useTrilogyContext();
+  const classes = hashClass(
+    styled,
+    (0, import_clsx11.default)(
+      "title",
+      level && getTitleLevel(level),
+      typo,
+      skeleton && is("loading"),
+      inverted && is("inverted"),
+      marginless && is("marginless"),
+      className
+    )
+  );
+  const subtitleClasses = hashClass(styled, (0, import_clsx11.default)("subtitle", typo, className));
+  const overlineClasses = hashClass(styled, (0, import_clsx11.default)("overline", typo, className));
+  const Tag = markup && isCorrectMarkup(markup) ? markup : "p";
+  const getClassname = () => {
+    if (subtitle) return subtitleClasses;
+    if (overline) return overlineClasses;
+    return classes;
+  };
+  return /* @__PURE__ */ import_react12.default.createElement(Tag, { ref, id, "aria-label": accessibilityLabel, onClick, className: getClassname(), ...others }, children);
+});
+Title.displayName = "Title" /* Title */;
+var Title_default = Title;
+
+// components/modal/Modal.tsx
+var import_locales3 = require("@trilogy-ds/locales");
+var import_clsx12 = __toESM(require("clsx"));
+var import_react13 = __toESM(require("react"));
+var Modal = import_react13.default.forwardRef(
+  ({
+    children,
+    className,
+    id,
+    accessibilityLabel = "Close",
+    active,
+    onClose,
+    unClosable,
+    panel,
+    size,
+    hideCloseButton = false,
+    trigger,
+    title,
+    ...others
+  }, ref) => {
+    const modalContentRef = (0, import_react13.useRef)(null);
+    const [display, setDisplay] = (0, import_react13.useState)(active || false);
+    const { styled } = useTrilogyContext();
+    const refBtnModal = (0, import_react13.useRef)(null);
+    const refModal = (0, import_react13.useRef)(null);
+    const modalGeneratedId = (0, import_react13.useId)();
+    const focusableElementsRef = (0, import_react13.useRef)(null);
+    const currentFocusIndexRef = (0, import_react13.useRef)(0);
+    const handleClose = import_react13.default.useCallback(
+      (onCloseFunc, e) => {
+        if (!unClosable) {
+          setDisplay(false);
+          refBtnModal.current && refBtnModal.current.focus();
+          if (onCloseFunc) onCloseFunc(e);
+        }
+      },
+      [refBtnModal.current]
+    );
+    const classes = hashClass(
+      styled,
+      (0, import_clsx12.default)("modal", display && is("active"), size && is(size), panel && is("panel"), className)
+    );
+    const onKeyDown = (0, import_react13.useCallback)(
+      (e) => {
+        if (display && e.key === "Tab") {
+          e.preventDefault();
+          if (focusableElementsRef.current) {
+            const currentIndex = currentFocusIndexRef.current;
+            const offset = e.shiftKey ? -1 : 1;
+            const nextIndex = (currentIndex + offset + focusableElementsRef.current.length) % focusableElementsRef.current.length;
+            currentFocusIndexRef.current = nextIndex;
+            focusableElementsRef.current[nextIndex].focus();
+          }
+        }
+        if (!unClosable && display && e.key === "Escape") {
+          e.preventDefault();
+          setDisplay(false);
+          refBtnModal.current && refBtnModal.current.focus();
+          currentFocusIndexRef.current = 0;
+          onClose && onClose();
+        }
+      },
+      [display, focusableElementsRef, currentFocusIndexRef, refBtnModal, onClose]
+    );
+    (0, import_react13.useEffect)(() => {
+      setDisplay((prev) => {
+        if (prev) {
+          refBtnModal.current && refBtnModal.current.focus();
+          currentFocusIndexRef.current = 0;
+        }
+        return active || false;
+      });
+    }, [active, currentFocusIndexRef, refBtnModal]);
+    (0, import_react13.useEffect)(() => {
+      !hideCloseButton && display && focusableElementsRef.current && focusableElementsRef.current[0].focus();
+    }, [hideCloseButton, display, focusableElementsRef]);
+    (0, import_react13.useEffect)(() => {
+      if (modalContentRef.current) {
+        focusableElementsRef.current = modalContentRef.current.querySelectorAll(
+          'button:not(:disabled), input:not(:disabled), a, select:not(:disabled), textarea:not(:disabled), details:not([aria-disabled="true"]) > summary'
+        );
+      }
+    }, [modalContentRef, focusableElementsRef]);
+    return /* @__PURE__ */ import_react13.default.createElement("div", { onKeyDown, ref: refModal }, trigger && import_react13.default.cloneElement(trigger, { ref: refBtnModal, "aria-haspopup": "dialog" }), /* @__PURE__ */ import_react13.default.createElement(
+      "div",
+      {
+        ref,
+        id,
+        className: classes,
+        role: "dialog",
+        "aria-labelledby": modalGeneratedId,
+        "aria-modal": true,
+        onClick: (e) => {
+          var _a;
+          if (!((_a = modalContentRef == null ? void 0 : modalContentRef.current) == null ? void 0 : _a.contains(e.target))) {
+            handleClose(onClose, e);
+          }
+        },
+        ...others
+      },
+      /* @__PURE__ */ import_react13.default.createElement("div", { ref: modalContentRef, className: hashClass(styled, (0, import_clsx12.default)("modal-content")) }, /* @__PURE__ */ import_react13.default.createElement("div", { className: hashClass(styled, (0, import_clsx12.default)("modal-header")) }, !hideCloseButton && !unClosable && /* @__PURE__ */ import_react13.default.createElement(
+        "button",
+        {
+          onClick: (e) => {
+            handleClose(onClose, e);
+          },
+          className: hashClass(styled, (0, import_clsx12.default)("modal-close", is("large"))),
+          type: "button" /* BUTTON */
+        },
+        /* @__PURE__ */ import_react13.default.createElement("span", { className: hashClass(styled, (0, import_clsx12.default)("sr-only")) }, import_locales3.modalLocale.accessibilityLabelButtonClose)
+      ), /* @__PURE__ */ import_react13.default.createElement(Title_default, { id: modalGeneratedId, level: 3 /* THREE */, markup: "h1" /* H1 */ }, title)), children && children)
+    ));
+  }
+);
+Modal.displayName = "Modal" /* Modal */;
+var Modal_default = Modal;
+
+// components/modal/footer/ModalFooter.tsx
+var import_clsx13 = __toESM(require("clsx"));
+var React18 = __toESM(require("react"));
+var ModalFooter = React18.forwardRef(({ children, className, id }, ref) => {
+  const { styled } = useTrilogyContext();
+  return /* @__PURE__ */ React18.createElement("div", { ref, "data-modal-footer": "", id, className: hashClass(styled, (0, import_clsx13.default)("modal-footer", className)) }, children);
+});
+ModalFooter.displayName = "ModalFooter" /* ModalFooter */;
+
+// components/modal/body/ModalBody.tsx
+var import_clsx14 = __toESM(require("clsx"));
+var React19 = __toESM(require("react"));
+var ModalBody = React19.forwardRef(({ children, className, id }, ref) => {
+  const { styled } = useTrilogyContext();
+  return /* @__PURE__ */ React19.createElement("div", { ref, id, className: hashClass(styled, (0, import_clsx14.default)("modal-body", className)) }, children);
+});
+ModalBody.displayName = "ModalBody" /* ModalBody */;
+var ModalBody_default = ModalBody;
+
+// components/datepicker/DatePicker.tsx
+var APPROXIMATIVE_HEIGHT_CALENDAR = 420;
+var checkIsValidDate = (date, year, month, day) => date.getFullYear() === parseInt(year) && date.getMonth() === parseInt(month) - 1 && date.getDate() === parseInt(day) && !isNaN(date.getTime());
+var getFirstDayFocusable = () => {
+  var _a;
+  const calendar = document.querySelector("[data-calendar-trilogy]");
+  const activeDate = calendar.querySelector(`[data-active-date]`);
+  const today = calendar.querySelector(`[data-today]`);
+  const firstOfMonth = calendar.querySelector(`[data-calendar-trilogy] tbody button:not(:disabled)`);
+  return (_a = activeDate != null ? activeDate : today) != null ? _a : firstOfMonth;
+};
+var DatePicker = (0, import_react14.forwardRef)(
+  ({
+    onChange,
+    value,
+    minDate,
+    maxDate,
+    className,
+    label,
+    sample,
+    required,
+    help,
+    status,
+    disabled,
+    disabledDates,
+    id = import_react14.default.useId(),
+    testId,
+    name,
+    ...others
+  }, ref) => {
+    const { styled } = useTrilogyContext();
+    const { "data-cy": dataCy, ...otherProps } = others;
+    const [day, setDay] = (0, import_react14.useState)("jj");
+    const [month, setMonth] = (0, import_react14.useState)("mm");
+    const [year, setYear] = (0, import_react14.useState)("aaaa");
+    const [isOpenCalendar, setIsOpenCalendar] = (0, import_react14.useState)(false);
+    const [canContinueTyping, setCanContinueTyping] = (0, import_react14.useState)(false);
+    const [focused, setIsFocused] = (0, import_react14.useState)(false);
+    const [isMobile, setIsMobile] = (0, import_react14.useState)(false);
+    const [portalPosition, setPortalPosition] = (0, import_react14.useState)({ top: 0, left: 0, width: 0 });
+    const refsSegment = (0, import_react14.useRef)([]);
+    const refsFocusable = (0, import_react14.useRef)([]);
+    const refContainer = (0, import_react14.useRef)(null);
+    const refCalendar = (0, import_react14.useRef)(null);
+    const currentFocusIndexRef = (0, import_react14.useRef)(0);
+    const segmentFocused = (0, import_react14.useRef)(null);
+    const refIcon = (0, import_react14.useRef)(null);
+    const refInput = (0, import_react14.useRef)(null);
+    const calendarContainerClasses = hashClass(styled, (0, import_clsx15.default)("date-picker-calendar"));
+    const datePickerClasses = hashClass(styled, (0, import_clsx15.default)("field date-picker", className));
+    const controlClasses = hashClass(styled, (0, import_clsx15.default)("control", has("icons-right")));
+    const inputClasses = hashClass(styled, (0, import_clsx15.default)("input", status && is(status), focused && is("focused")));
+    const iconRightClasses = hashClass(styled, (0, import_clsx15.default)("icon-right"));
+    const helpClasses = (0, import_clsx15.default)("help", status && is(status));
+    const inputLabelClasses = hashClass(styled, "input-label");
+    const inputHidden = hashClass(styled, "input-hidden");
+    (0, import_react14.useImperativeHandle)(ref, () => refContainer.current);
+    useClickOutside(refCalendar, () => {
+      setTimeout(() => {
+        setIsOpenCalendar(false);
+      }, 0);
+    });
+    useClickOutside(refInput, () => {
+      setTimeout(() => {
+        setIsFocused(false);
+      }, 0);
+    });
+    const segments = (0, import_react14.useMemo)(
+      () => ({
+        day: {
+          sensitiveValue: 3,
+          maxValue: 31,
+          segment: day,
+          segmentPosition: 0,
+          segmentSetter: setDay,
+          label: "jj",
+          initValue: "01"
+        },
+        month: {
+          sensitiveValue: 1,
+          maxValue: 12,
+          segment: month,
+          segmentPosition: 1,
+          segmentSetter: setMonth,
+          label: "mm",
+          initValue: "01"
+        },
+        year: {
+          sensitiveValue: false,
+          maxValue: 9999,
+          segment: year,
+          segmentPosition: 2,
+          segmentSetter: setYear,
+          label: "aaaa",
+          initValue: String((/* @__PURE__ */ new Date()).getFullYear())
+        }
+      }),
+      [day, month, year]
+    );
+    const calendarValue = (0, import_react14.useMemo)(() => {
+      if (parseInt(day) && parseInt(month) && parseInt(year)) {
+        const newDate = /* @__PURE__ */ new Date(`${year}-${month}-${day}`);
+        const isValidDate = checkIsValidDate(newDate, year, month, day);
+        if (isValidDate) return newDate;
+      }
+    }, [day, month, year]);
+    const calculatePortalPosition = (0, import_react14.useCallback)(() => {
+      if (!refInput.current) return;
+      const rect = refInput.current.getBoundingClientRect();
+      const { top, bottom, left, width } = rect;
+      const windowHeight = window.innerHeight;
+      const spaceBelow = windowHeight - bottom;
+      const padding = 10;
+      const maxHeightBelow = spaceBelow - padding;
+      const maxHeightAbove = top - padding;
+      const shouldOpenUpward = maxHeightBelow < APPROXIMATIVE_HEIGHT_CALENDAR && maxHeightAbove > maxHeightBelow;
+      const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+      const scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
+      setPortalPosition({
+        top: shouldOpenUpward ? top + scrollTop - APPROXIMATIVE_HEIGHT_CALENDAR - padding : bottom + scrollTop + padding,
+        left: left + scrollLeft,
+        width
+      });
+    }, []);
+    const handleKeyPress = (0, import_react14.useCallback)(
+      ({ event, type }) => {
+        if (disabled) return;
+        const key = event.data;
+        event.preventDefault();
+        const allowedKeys = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+        if (!allowedKeys.includes(key)) return;
+        const digit = parseInt(key);
+        const { segmentPosition, segment, segmentSetter, sensitiveValue, maxValue } = segments[type];
+        const isDay = type === "day";
+        const isMonth = type === "month";
+        const isYear = type === "year";
+        const newValue = !canContinueTyping ? isYear ? `000${key}` : `0${key}` : isYear ? segment + key : segment[1] + key;
+        if (!canContinueTyping) {
+          segmentSetter(newValue);
+          if (sensitiveValue === false || digit <= sensitiveValue) setCanContinueTyping(true);
+          if (sensitiveValue && digit > sensitiveValue)
+            setTimeout(() => {
+              if (segmentPosition < 2) refsSegment.current[segmentPosition + 1].focus();
+            }, 0);
+        }
+        if (canContinueTyping) {
+          const num = parseInt(newValue);
+          if (isYear && String(num).length === 5) return;
+          if (num >= 1 && num <= maxValue) segmentSetter(isYear ? newValue.slice(-4) : newValue);
+          if (!isYear) {
+            setCanContinueTyping(false);
+            setTimeout(() => {
+              if (segmentPosition < 2) refsSegment.current[segmentPosition + 1].focus();
+            }, 0);
+          }
+        }
+        const newDay = isDay ? newValue : day;
+        const newMonth = isMonth ? newValue : month;
+        const newYear = isYear ? newValue : year;
+        if (parseInt(newDay) && parseInt(newMonth) && parseInt(newYear)) {
+          if (onChange) onChange(`${newYear.slice(-4)}-${newMonth}-${newDay}`);
+        }
+      },
+      [disabled, segments, canContinueTyping, onChange]
+    );
+    const formatDateValue = () => {
+      const isValidDate = parseInt(day) && parseInt(month) && parseInt(year);
+      return !isValidDate ? "" : `${year}-${month}-${day}`;
+    };
+    const handleKeyDownDay = (0, import_react14.useCallback)(
+      (e, type) => {
+        if (disabled) return;
+        const { segmentSetter, label: label2, maxValue, initValue, segmentPosition, segment } = segments[type];
+        switch (e.key) {
+          case "Backspace":
+            e.preventDefault();
+            setCanContinueTyping(false);
+            segmentSetter(label2);
+            break;
+          case " ":
+            e.preventDefault();
+            setIsOpenCalendar(true);
+            segmentFocused.current = refsSegment.current[segmentPosition];
+            break;
+          case "Escape":
+            e.preventDefault();
+            setIsOpenCalendar(false);
+            break;
+          case "ArrowUp":
+            e.preventDefault();
+            const currentValue = parseInt(segment) || 0;
+            const nextValue = currentValue % maxValue + 1;
+            const availableValue = type === "year" && segment === "aaaa" ? initValue : String(nextValue).padStart(2, "0");
+            segmentSetter(availableValue);
+            const updatedDayUp = type === "day" ? availableValue : day;
+            const updatedMonthUp = type === "month" ? availableValue : month;
+            const updatedYearUp = type === "year" ? availableValue : year;
+            if (parseInt(updatedDayUp) && parseInt(updatedMonthUp) && parseInt(updatedYearUp) && onChange) {
+              onChange(`${updatedYearUp}-${updatedMonthUp}-${updatedDayUp}`);
+            }
+            break;
+          case "ArrowDown":
+            e.preventDefault();
+            const value2 = parseInt(segment) || maxValue;
+            const nextVal = value2 <= 1 ? maxValue : value2 - 1;
+            const availableVal = type === "year" && segment === "aaaa" ? initValue : String(nextVal).padStart(2, "0");
+            segmentSetter(availableVal);
+            const updatedDayDown = type === "day" ? availableVal : day;
+            const updatedMonthDown = type === "month" ? availableVal : month;
+            const updatedYearDown = type === "year" ? availableVal : year;
+            if (parseInt(updatedDayDown) && parseInt(updatedMonthDown) && parseInt(updatedYearDown) && onChange) {
+              onChange(`${updatedYearDown}-${updatedMonthDown}-${updatedDayDown}`);
+            }
+            break;
+          default:
+            return;
+        }
+      },
+      [disabled, segments, year, month, day]
+    );
+    const handleFocus = () => {
+      if (disabled) return;
+      setIsFocused(true);
+      setCanContinueTyping(false);
+    };
+    const handlePressCalendar = () => {
+      if (disabled) return;
+      if (refContainer.current) segmentFocused.current = refIcon.current;
+      calculatePortalPosition();
+      setIsOpenCalendar(true);
+    };
+    const handleChangeCalendar = import_react14.default.useCallback(
+      (e) => {
+        const dateCalendar = e;
+        const dateDay = dateCalendar.getDate();
+        const dateMonth = dateCalendar.getMonth() + 1;
+        const dateYear = dateCalendar.getFullYear();
+        const dayFormated = dateDay < 10 ? `0${dateDay}` : String(dateDay);
+        const monthFormated = dateMonth < 10 ? `0${dateMonth}` : String(dateMonth);
+        const yearFormated = String(dateYear);
+        setDay(dayFormated);
+        setMonth(monthFormated);
+        setYear(yearFormated);
+        setIsOpenCalendar(false);
+        if (onChange) onChange(`${yearFormated}-${monthFormated}-${dayFormated}`);
+      },
+      [onChange]
+    );
+    const onKeyDown = (0, import_react14.useCallback)(
+      (e) => {
+        var _a;
+        if (disabled) return;
+        if (isOpenCalendar && e.key === "Tab") {
+          e.preventDefault();
+          if (refsFocusable.current) {
+            const currentIndex = currentFocusIndexRef.current;
+            const offset = e.shiftKey ? -1 : 1;
+            const nextIndex = (currentIndex + offset + (refsFocusable == null ? void 0 : refsFocusable.current.length)) % (refsFocusable == null ? void 0 : refsFocusable.current.length);
+            currentFocusIndexRef.current = nextIndex;
+            refsFocusable.current[nextIndex].focus();
+          }
+        }
+        if (isOpenCalendar && ["Escape", "Enter"].includes(e.key)) {
+          e.preventDefault();
+          setIsOpenCalendar(false);
+          (_a = segmentFocused.current) == null ? void 0 : _a.focus();
+        }
+      },
+      [disabled, isOpenCalendar]
+    );
+    const calendar = (0, import_react14.useMemo)(() => {
+      return /* @__PURE__ */ import_react14.default.createElement(
+        Calendar_default,
+        {
+          disabledDates,
+          maxDate: maxDate ? new Date(maxDate) : void 0,
+          minDate: minDate ? new Date(minDate) : void 0,
+          onChange: handleChangeCalendar,
+          ref: refCalendar,
+          value: calendarValue,
+          onMonthChange: () => {
+            if (isOpenCalendar && refCalendar.current) {
+              const calendar2 = refCalendar.current;
+              setTimeout(() => {
+                refsFocusable.current = [];
+                const elms = calendar2.querySelectorAll(`[data-focusable=true]`);
+                const firstDayFocusable = getFirstDayFocusable();
+                refsFocusable.current[0] = firstDayFocusable;
+                elms.forEach((el, i) => {
+                  const htmlElement = el;
+                  if (htmlElement) refsFocusable.current[i + 1] = htmlElement;
+                });
+              }, 10);
+            }
+          }
+        }
+      );
+    }, [
+      disabledDates,
+      maxDate,
+      minDate,
+      handleChangeCalendar,
+      refCalendar,
+      calendarValue,
+      isOpenCalendar,
+      refsFocusable
+    ]);
+    (0, import_react14.useEffect)(() => {
+      if (!value) {
+        setDay("jj");
+        setMonth("mm");
+        setYear("aaaa");
+      } else {
+        const [year2, month2, day2] = value.split("-");
+        setDay(day2);
+        setMonth(month2);
+        setYear(year2);
+      }
+    }, [value]);
+    (0, import_react14.useEffect)(() => {
+      if (isOpenCalendar && refCalendar.current) {
+        const elms = refCalendar.current.querySelectorAll(`[data-focusable=true]`);
+        const firstDayFocusable = getFirstDayFocusable();
+        refsFocusable.current[0] = firstDayFocusable;
+        firstDayFocusable.focus();
+        elms.forEach((el, i) => {
+          const htmlElement = el;
+          if (htmlElement) refsFocusable.current[i + 1] = htmlElement;
+        });
+      }
+      if (!isOpenCalendar && currentFocusIndexRef.current) currentFocusIndexRef.current = 0;
+    }, [isOpenCalendar, refCalendar, currentFocusIndexRef]);
+    (0, import_react14.useEffect)(() => {
+      const handleResize = () => setIsMobile(window.innerWidth <= 768);
+      handleResize();
+      window.addEventListener("resize", handleResize);
+      return () => window.removeEventListener("resize", handleResize);
+    }, []);
+    (0, import_react14.useEffect)(() => {
+      if (!isOpenCalendar) return;
+      const handleUpdate = () => calculatePortalPosition();
+      window.addEventListener("scroll", handleUpdate, true);
+      window.addEventListener("resize", handleUpdate);
+      return () => {
+        window.removeEventListener("scroll", handleUpdate, true);
+        window.removeEventListener("resize", handleUpdate);
+      };
+    }, [isOpenCalendar, calculatePortalPosition]);
+    return /* @__PURE__ */ import_react14.default.createElement("div", { ref: refContainer, className: datePickerClasses, onKeyDown }, label && /* @__PURE__ */ import_react14.default.createElement("label", { className: inputLabelClasses, htmlFor: id }, label, " ", required && /* @__PURE__ */ import_react14.default.createElement(Text_default, { markup: "span" /* SPAN */, typo: "has-text-error" /* TEXT_ERROR */ }, "*")), sample && /* @__PURE__ */ import_react14.default.createElement(Text_default, { className: "input-sample", level: 2 /* TWO */ }, sample), /* @__PURE__ */ import_react14.default.createElement("div", { className: controlClasses }, /* @__PURE__ */ import_react14.default.createElement(
+      "div",
+      {
+        role: "group",
+        "aria-valuetext": formatDateValue(),
+        "aria-disabled": disabled,
+        ref: refInput,
+        className: inputClasses,
+        onMouseDown: (e) => {
+          if (disabled) return;
+          const clickedSegment = refsSegment.current.find((segment) => segment === document.activeElement);
+          if (clickedSegment) return e.preventDefault();
+          setTimeout(() => {
+            refsSegment.current[0].focus();
+          }, 0);
+        },
+        ...otherProps
+      },
+      /* @__PURE__ */ import_react14.default.createElement(
+        "span",
+        {
+          "aria-valuemin": 1,
+          "aria-valuemax": 31,
+          "aria-readonly": false,
+          "aria-label": "day",
+          role: "spinbutton",
+          suppressContentEditableWarning: true,
+          autoCorrect: "off",
+          autoCapitalize: "none",
+          spellCheck: false,
+          "aria-valuetext": day,
+          contentEditable: !disabled,
+          inputMode: "numeric",
+          onBeforeInput: (e) => handleKeyPress({ event: e, type: "day" }),
+          onFocus: handleFocus,
+          onKeyDown: (e) => handleKeyDownDay(e, "day"),
+          onMouseDown: (e) => e.stopPropagation(),
+          onChange: (e) => e.stopPropagation(),
+          onInput: () => refsSegment.current[0].textContent = day,
+          ref: (el) => {
+            if (el) refsSegment.current[0] = el;
+          }
+        },
+        day
+      ),
+      /* @__PURE__ */ import_react14.default.createElement("span", null, "/"),
+      /* @__PURE__ */ import_react14.default.createElement(
+        "span",
+        {
+          "aria-valuemin": 1,
+          "aria-valuemax": 12,
+          "aria-readonly": false,
+          "aria-label": "month",
+          role: "spinbutton",
+          suppressContentEditableWarning: true,
+          autoCorrect: "off",
+          autoCapitalize: "none",
+          spellCheck: false,
+          "aria-valuetext": month,
+          contentEditable: !disabled,
+          inputMode: "numeric",
+          onBeforeInput: (e) => handleKeyPress({ event: e, type: "month" }),
+          onFocus: handleFocus,
+          onKeyDown: (e) => handleKeyDownDay(e, "month"),
+          onMouseDown: (e) => e.stopPropagation(),
+          onChange: (e) => e.stopPropagation(),
+          onInput: () => refsSegment.current[1].textContent = month,
+          ref: (el) => {
+            if (el) refsSegment.current[1] = el;
+          }
+        },
+        month
+      ),
+      /* @__PURE__ */ import_react14.default.createElement("span", null, "/"),
+      /* @__PURE__ */ import_react14.default.createElement(
+        "span",
+        {
+          "aria-valuemin": 0,
+          "aria-valuemax": 9999,
+          "aria-readonly": false,
+          "aria-label": "year",
+          role: "spinbutton",
+          suppressContentEditableWarning: true,
+          autoCorrect: "off",
+          autoCapitalize: "none",
+          spellCheck: false,
+          "aria-valuetext": year,
+          contentEditable: !disabled,
+          inputMode: "numeric",
+          onBeforeInput: (e) => handleKeyPress({ event: e, type: "year" }),
+          onFocus: handleFocus,
+          onKeyDown: (e) => handleKeyDownDay(e, "year"),
+          onMouseDown: (e) => e.stopPropagation(),
+          onChange: (e) => e.stopPropagation(),
+          onInput: () => refsSegment.current[2].textContent = year,
+          ref: (el) => {
+            if (el) refsSegment.current[2] = el;
+          }
+        },
+        year
+      ),
+      /* @__PURE__ */ import_react14.default.createElement(
+        "input",
+        {
+          disabled,
+          name,
+          type: "text",
+          id,
+          "data-testid": testId,
+          value: `${year}-${month}-${day}`,
+          "data-cy": dataCy,
+          tabIndex: -1,
+          className: inputHidden,
+          onChange: (e) => {
+            const [year2, month2, day2] = e.target.value.split("-");
+            setDay(day2);
+            setMonth(month2);
+            setYear(year2);
+          }
+        }
+      )
+    ), /* @__PURE__ */ import_react14.default.createElement(
+      "button",
+      {
+        type: "button",
+        tabIndex: disabled ? -1 : void 0,
+        onClick: handlePressCalendar,
+        ref: refIcon,
+        "data-show-calendar": "true",
+        onFocus: () => {
+          setIsFocused(false);
+        }
+      },
+      /* @__PURE__ */ import_react14.default.createElement(Icon_default, { name: "tri-calendar", className: iconRightClasses })
+    )), help && /* @__PURE__ */ import_react14.default.createElement(Text_default, { className: helpClasses }, help), isOpenCalendar && !isMobile && import_react_dom2.default.createPortal(
+      /* @__PURE__ */ import_react14.default.createElement(
+        "div",
+        {
+          className: calendarContainerClasses,
+          style: {
+            position: "absolute",
+            top: `${portalPosition.top}px`,
+            left: `${portalPosition.left}px`,
+            minWidth: `${portalPosition.width}px`,
+            zIndex: 9999
+          }
+        },
+        calendar
+      ),
+      document.body
+    ), isOpenCalendar && isMobile && /* @__PURE__ */ import_react14.default.createElement(Modal_default, { active: isOpenCalendar, hideCloseButton: true }, /* @__PURE__ */ import_react14.default.createElement(ModalBody_default, null, calendar)));
+  }
+);
+DatePicker.displayName = "DatePicker" /* DatePicker */;
+var DatePicker_default = DatePicker;