@hhgtech/hhg-components 1.28.67 → 1.28.69

package/build/types-1fedb3d1.js

@@ -0,0 +1,3446 @@
+'use strict';
+
+var tslib_es6 = require('./tslib.es6-65e312a5.js');
+var React = require('react');
+var useTranslations = require('./useTranslations-e1853417.js');
+var debounce = require('lodash/debounce');
+var constants = require('./constants-8b8bc19f.js');
+var index$1 = require('./index-020e6908.js');
+var styled = require('styled-components');
+var index$2 = require('./index-bc4f4c33.js');
+var theme = require('./theme-fa910869.js');
+var shuffle = require('lodash/shuffle');
+var useOutsideClick = require('./useOutsideClick-c6813964.js');
+var utils = require('./utils-64bd0c42.js');
+var Skeleton = require('react-loading-skeleton');
+var paths = require('./paths-a5643d9e.js');
+var core = require('@mantine/core');
+var index = require('./index-5553f9e1.js');
+var cookieHelper = require('./cookieHelper-5c9f4bb8.js');
+var index$3 = require('./index-12c07f71.js');
+var core$1 = require('@hhgtech/icons/core');
+var ChevronDown = require('./ChevronDown-275f1ab5.js');
+var formatString = require('string-format');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+var debounce__default = /*#__PURE__*/_interopDefault(debounce);
+var styled__default = /*#__PURE__*/_interopDefault(styled);
+var shuffle__default = /*#__PURE__*/_interopDefault(shuffle);
+var Skeleton__default = /*#__PURE__*/_interopDefault(Skeleton);
+var formatString__default = /*#__PURE__*/_interopDefault(formatString);
+
+function useGeolocation() {
+    const [permission, setPermission] = React.useState(() => {
+        if (typeof window === 'undefined') {
+            return 'unset';
+        }
+        if (cookieHelper.getCookie(index.USER_GEOLOCATION_COORDINATES_COOKIE)) {
+            return 'granted';
+        }
+        const blocked = !location.protocol.includes('https') && location.hostname !== 'localhost';
+        if (!navigator.geolocation || blocked) {
+            return 'denied';
+        }
+        return 'unset';
+    });
+    const [coordinates, setCoordinates] = React.useState(() => {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+        const cookie = cookieHelper.getCookie(index.USER_GEOLOCATION_COORDINATES_COOKIE);
+        if (cookie) {
+            try {
+                return JSON.parse(cookie);
+            }
+            catch (err) {
+                console.log(err);
+            }
+        }
+        return null;
+    });
+    const request = React.useCallback(function request() {
+        // setPermission()
+        if (navigator.geolocation) {
+            navigator.geolocation.getCurrentPosition((position) => {
+                const gps = {
+                    lat: `${Math.round(position.coords.latitude * 10000000) / 10000000}`,
+                    lng: `${Math.round(position.coords.longitude * 10000000) / 10000000}`,
+                };
+                cookieHelper.setCookie(index.USER_GEOLOCATION_COORDINATES_COOKIE, JSON.stringify(gps), {
+                    minutes: 15,
+                });
+                setCoordinates(gps);
+                setPermission('granted');
+            }, () => {
+                cookieHelper.deleteCookie(index.USER_GEOLOCATION_COORDINATES_COOKIE);
+                setPermission('denied');
+            });
+        }
+    }, []);
+    return React.useMemo(() => ({
+        geoLocationPermission: permission,
+        geoLocationCoordinates: coordinates,
+        requestGeoLocation: request,
+    }), [permission, coordinates]);
+}
+
+const StyledSearchBarWrapper$1 = styled__default["default"].div ``;
+const StyledSearchBarMobileWrapper = styled__default["default"].div `
+  --searchbar-z-index: 305;
+  &[data-is-modal='true'] {
+    position: fixed;
+    left: 0;
+    right: 0;
+    top: 0;
+    height: var(--mobile-care-searchbar-height, 100%);
+    overflow-y: auto;
+    -webkit-overflow-scrolling: touch;
+    background-color: white;
+    z-index: var(--searchbar-z-index);
+  }
+`;
+const StyledSearchBarMobileModalHeader = styled__default["default"].section ``;
+const StyledHiddenInputMobile = styled__default["default"].input `
+  position: fixed;
+  left: -100%;
+  top: -100%;
+`;
+const StyledInput = styled__default["default"](index$1.Input) `
+  #booking-search-bar & {
+    input {
+      font-size: 16px;
+    }
+  }
+`;
+const CareSearchGlobalStyles = styled.createGlobalStyle `
+  .care-popup-open {
+    overflow: hidden;
+    position: fixed;
+    &::before {
+      content: '';
+      inset: 0;
+      position: absolute;
+      background-color: white;
+      min-height: 100vh;
+      min-width: 100vw;
+      z-index: 2;
+    }
+  }
+`;
+
+const ClearIcon = ({ className, color }) => (React__default["default"].createElement("svg", { className: className, width: "24", height: "24", viewBox: "0 0 24 24", fill: "none" },
+    React__default["default"].createElement("rect", { x: "4", y: "4", width: "16", height: "16", rx: "8", fill: "white" }),
+    React__default["default"].createElement("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M12 20C16.4183 20 20 16.4183 20 12C20 7.58172 16.4183 4 12 4C7.58172 4 4 7.58172 4 12C4 16.4183 7.58172 20 12 20ZM8.29289 8.29289C8.68342 7.90237 9.31658 7.90237 9.70711 8.29289L12 10.5858L14.2929 8.29289C14.6834 7.90237 15.3166 7.90237 15.7071 8.29289C16.0976 8.68342 16.0976 9.31658 15.7071 9.70711L13.4142 12L15.7071 14.2929C16.0976 14.6834 16.0976 15.3166 15.7071 15.7071C15.3166 16.0976 14.6834 16.0976 14.2929 15.7071L12 13.4142L9.70711 15.7071C9.31658 16.0976 8.68342 16.0976 8.29289 15.7071C7.90237 15.3166 7.90237 14.6834 8.29289 14.2929L10.5858 12L8.29289 9.70711C7.90237 9.31658 7.90237 8.68342 8.29289 8.29289Z", fill: color || 'currentColor' })));
+const CloseIcon = ({ className, color }) => (React__default["default"].createElement("svg", { className: className, width: "24", height: "24", viewBox: "0 0 24 24", fill: "none" },
+    React__default["default"].createElement("path", { d: "M18 6L6 18", stroke: color || 'currentColor', strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
+    React__default["default"].createElement("path", { d: "M6 6L18 18", stroke: color || 'currentColor', strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })));
+const PinIcon = ({ className, color }) => (React__default["default"].createElement("svg", { width: "14", height: "20", viewBox: "0 0 14 20", className: className },
+    React__default["default"].createElement("path", { d: "M7 0C3.134 0 0 3.134 0 7C0 10.966 4.404 16.82 6.226 19.071C6.626 19.565 7.374 19.565 7.774 19.071C9.596 16.82 14 10.966 14 7C14 3.134 10.866 0 7 0ZM7 9.5C5.619 9.5 4.5 8.381 4.5 7C4.5 5.619 5.619 4.5 7 4.5C8.381 4.5 9.5 5.619 9.5 7C9.5 8.381 8.381 9.5 7 9.5Z", fill: color || 'currentColor' })));
+const MagnifierIcon = ({ className, color }) => (React__default["default"].createElement("svg", { className: className, width: "24", height: "24", viewBox: "0 0 24 24", fill: "none" },
+    React__default["default"].createElement("path", { d: "M11 18C14.866 18 18 14.866 18 11C18 7.13401 14.866 4 11 4C7.13401 4 4 7.13401 4 11C4 14.866 7.13401 18 11 18Z", stroke: color || 'currentColor', strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }),
+    React__default["default"].createElement("path", { d: "M20 20L16 16", stroke: color || 'currentColor', strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" })));
+const DefaultThumbnailAny = ({ width, height, }) => (React__default["default"].createElement("svg", { width: width || 30, height: height || 30, viewBox: "0 0 30 30", fill: "none" },
+    React__default["default"].createElement("circle", { cx: "15", cy: "15", r: "15", fill: "#F7F9FC" })));
+const DefaultThumbnailDoctor = ({ width, height, }) => (React__default["default"].createElement("svg", { width: width || 32, height: height || 32, viewBox: "0 0 32 32", fill: "none" },
+    React__default["default"].createElement("g", { clipPath: "url(#clip0_14712_400114)" },
+        React__default["default"].createElement("rect", { width: "32", height: "32", rx: "16", fill: "#E4E8EC" }),
+        React__default["default"].createElement("path", { d: "M22.065 9.58305C22.1108 9.80952 22.1431 10.0396 22.1614 10.2722C22.3769 13.0522 22.5858 16.1276 22.5727 17.618C22.5306 20.5688 19.708 21.1325 19.4564 21.1769L19.4495 21.5357L19.5228 23.9014C20.8688 23.9341 22.203 24.1759 23.4772 24.6196C24.5264 24.9739 25.4827 25.5591 26.2757 26.332C27.0688 27.105 27.6783 28.0461 28.0594 29.0858L31.9886 39.2068C31.91 39.3048 30.6939 39.6356 29.4888 39.944C30.1695 42.3315 30.4582 44.8142 30.3432 47.2953C30.2991 48.2666 30.1816 49.264 29.7245 50.1211C29.4508 50.6342 29.0319 51.0912 28.5296 51.3753C28.5099 51.4347 28.4864 51.4928 28.4593 51.5495C28.4293 51.6146 28.3908 51.6756 28.3448 51.7307C28.3293 51.7772 28.3232 51.8406 28.3162 51.9135C28.3004 52.0779 28.2799 52.2909 28.1362 52.4685C28.001 52.6373 27.8519 52.7945 27.6905 52.9386C27.6905 52.9386 27.092 52.9667 26.4133 52.9845L26.458 58.4088H5.7492L6.30965 52.9523L5.66093 53.1637C5.07664 53.3528 4.45628 53.4028 3.84925 53.3099C3.24222 53.2169 2.66526 52.9835 2.1643 52.6283C1.61489 52.2388 1.17445 51.715 0.884966 51.1068C0.595484 50.4987 0.46662 49.8266 0.510669 49.1545L0.644528 47.1369L1.41503 38.3366L1.81323 38.4135L-0.914307 37.8437L-0.402886 36.5663C-0.407359 36.5645 -0.411803 36.5627 -0.416214 36.5608C-0.410804 36.56 -0.40538 36.5594 -0.399946 36.5589L2.05995 30.4146C3.00034 28.0825 4.7421 26.1624 6.97187 24.9999C8.56171 24.176 10.3028 23.6861 12.0882 23.5597L11.788 16.5865C11.1882 16.6507 10.0095 16.5266 9.96087 14.954C9.91229 13.3824 11.0457 13.3171 11.6507 13.3961L11.6445 13.2523C11.5785 12.8433 11.5088 12.439 11.4577 12.2132C11.3782 11.8628 11.2611 11.4953 11.1419 11.1207C10.8794 10.2967 10.6061 9.43855 10.697 8.65293C10.697 8.65293 10.6909 8.00438 11.4565 7.24044C11.3707 6.86644 11.3686 6.47786 11.4507 6.10258C11.5366 5.70965 11.7125 5.34199 11.9645 5.02848C12.2165 4.71497 12.5377 4.46414 12.9029 4.29569C13.2682 4.12725 13.6675 4.04577 14.0696 4.05766C14.2277 4.06393 14.3849 4.08493 14.5418 4.10589C14.7932 4.13945 15.0439 4.17294 15.2971 4.14581C15.7708 4.09409 16.177 3.83884 16.5862 3.58167C16.8357 3.42492 17.0863 3.26745 17.354 3.15494C17.9119 2.93744 18.5266 2.91281 19.1002 3.08497C19.6738 3.25713 20.1733 3.61619 20.5192 4.105C20.5943 4.21716 20.6621 4.33678 20.7298 4.45631C20.9035 4.76299 21.077 5.06915 21.373 5.24769C21.5927 5.38236 21.8482 5.42658 22.1057 5.47114C22.2633 5.49842 22.4216 5.52582 22.5728 5.57417C23.0267 5.71015 23.3999 6.0411 23.6319 6.45436C23.6327 6.40753 23.6317 6.36062 23.629 6.31374C23.6502 6.3657 23.6623 6.42092 23.6649 6.47698C23.6661 6.49165 23.667 6.50632 23.6677 6.521C23.8246 6.82609 23.9058 7.17114 23.8885 7.51347C23.8544 7.93447 23.7053 8.33801 23.4574 8.68001C23.2096 9.02201 22.8725 9.28933 22.483 9.45278C22.3469 9.50712 22.2071 9.55061 22.065 9.58305Z", fill: "white" })),
+    React__default["default"].createElement("defs", null,
+        React__default["default"].createElement("clipPath", { id: "clip0_14712_400114" },
+            React__default["default"].createElement("rect", { width: "32", height: "32", rx: "16", fill: "white" })))));
+const DefaultThumbnailService = ({ width, height, }) => (React__default["default"].createElement("svg", { width: width || 30, height: height || 30, viewBox: "0 0 30 30", fill: "none" },
+    React__default["default"].createElement("circle", { cx: "15", cy: "15", r: "15", fill: "#F7F9FC" }),
+    React__default["default"].createElement("path", { d: "M14.9998 6.66663C12.2752 6.66663 9.85335 7.97848 8.33317 9.99996H10.5988C11.8 8.94527 13.3625 8.33329 14.9998 8.33329C16.6372 8.33329 18.1997 8.94527 19.4009 9.99996H21.6665C20.1463 7.97848 17.7244 6.66663 14.9998 6.66663ZM7.7863 10.8333C7.07666 13.0403 6.6665 15.5989 6.6665 18.3333C6.6665 20.0846 6.82601 21.7675 7.13525 23.3333H22.8644C23.1737 21.7675 23.3332 20.0846 23.3332 18.3333C23.3332 15.5989 22.923 13.0403 22.2134 10.8333H7.7863ZM14.9998 13.3333C17.3013 13.3333 19.1665 15.1985 19.1665 17.5C19.1665 19.8014 17.3013 21.6666 14.9998 21.6666C12.6984 21.6666 10.8332 19.8014 10.8332 17.5C10.8332 15.1985 12.6984 13.3333 14.9998 13.3333ZM14.1665 15V16.6666H12.4998V18.3333H14.1665V20H15.8332V18.3333H17.4998V16.6666H15.8332V15H14.1665Z", fill: "#BFC5CC" })));
+
+const StyledLiSkeleton$1 = styled__default["default"].li `
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 8px 16px;
+
+  > :first-child {
+    flex: 1;
+  }
+
+  > :nth-child(2) {
+    flex: 6;
+  }
+
+  & + li::before {
+    content: '';
+    position: absolute;
+    left: 18px;
+    right: 18px;
+    top: 0;
+    height: 1px;
+    background-color: ${theme.theme.colors.neutral100};
+  }
+`;
+const LiSkeleton = ({ count, className }) => {
+    return (React__default["default"].createElement(React__default["default"].Fragment, null, [...Array(count)].map((__v, i) => (React__default["default"].createElement(StyledLiSkeleton$1, { className: className, key: i },
+        React__default["default"].createElement(Skeleton__default["default"], { count: 1, height: 32 }),
+        React__default["default"].createElement(Skeleton__default["default"], { count: 1, height: 24 }))))));
+};
+
+const checkMarkIconUrl = `url("data:image/svg+xml,%3Csvg width='19' height='14' viewBox='0 0 19 14' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M16.9803 0.990669C16.7205 0.99841 16.4739 1.10699 16.2928 1.2934L5.99984 11.5864L2.70687 8.2934C2.61473 8.19743 2.50436 8.12081 2.38223 8.06802C2.2601 8.01524 2.12867 7.98735 1.99563 7.986C1.86259 7.98464 1.73061 8.00985 1.60743 8.06014C1.48426 8.11043 1.37235 8.18479 1.27827 8.27887C1.1842 8.37295 1.10983 8.48485 1.05954 8.60803C1.00926 8.73121 0.98405 8.86318 0.985403 8.99622C0.986757 9.12926 1.01464 9.26069 1.06743 9.38282C1.12021 9.50495 1.19684 9.61532 1.29281 9.70747L5.29281 13.7075C5.48035 13.8949 5.73467 14.0002 5.99984 14.0002C6.26501 14.0002 6.51933 13.8949 6.70687 13.7075L17.7069 2.70747C17.8514 2.567 17.9501 2.38616 17.99 2.18864C18.03 1.99112 18.0093 1.78614 17.9308 1.60055C17.8523 1.41497 17.7195 1.25744 17.5499 1.14861C17.3803 1.03978 17.1817 0.984729 16.9803 0.990669Z' fill='%232685F1'/%3E%3C/svg%3E%0A")`;
+const StyledLocationResultsWrapper = styled__default["default"].div `
+  display: flex;
+  position: absolute;
+  top: 48px;
+  min-width: 100%;
+  box-shadow: 0px 24px 32px rgba(0, 0, 0, 0.04),
+    0px 16px 24px rgba(0, 0, 0, 0.04), 0px 4px 8px rgba(0, 0, 0, 0.04),
+    0px 0px 1px rgba(0, 0, 0, 0.04);
+  border-radius: ${theme.theme.borderRadius};
+  background-color: white;
+  z-index: 30;
+
+  ${utils.MediaQueries.tdDown} {
+    position: relative;
+    top: 0;
+    box-shadow: initial;
+  }
+`;
+const StyledLocationResultsList = styled__default["default"].ul `
+  width: 100%;
+  max-height: 600px;
+  overflow-y: auto;
+`;
+const StyledPinIcon$1 = styled__default["default"](PinIcon) `
+  width: 12px;
+  height: 18px;
+`;
+const StyledLocationItem$1 = styled__default["default"].li `
+  position: relative;
+  cursor: pointer;
+  padding: 12px 18px;
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  overflow: hidden;
+
+  ${({ isSelected }) => isSelected &&
+    `
+        &::after {
+            content: ${checkMarkIconUrl};
+            top: 50%;
+            right: 18px;
+            position: absolute;
+            transform: translateY(-50%);
+        }
+    `}
+
+  & + li::before {
+    content: '';
+    position: absolute;
+    left: 18px;
+    right: 18px;
+    top: 0;
+    height: 1px;
+    background-color: ${theme.theme.colors.neutral100};
+  }
+
+  &:not([data-is-denied='true']):hover {
+    background-color: ${theme.theme.colors.neutral50};
+  }
+
+  &:last-child:hover {
+    border-bottom-right-radius: 6px;
+    border-bottom-left-radius: 6px;
+  }
+
+  &:first-child:hover {
+    border-top-right-radius: 6px;
+    border-top-left-radius: 6px;
+  }
+
+  &[data-is-denied='true'] {
+    cursor: not-allowed;
+  }
+`;
+const StyledLiSkeleton = styled__default["default"](LiSkeleton) `
+  &:first-child {
+    padding-top: 18px;
+  }
+`;
+
+const LocationResults = ({ cities, isLoading, onLocationClick, selectedLocation, }) => {
+    const { t, locale } = useTranslations.useTranslations();
+    const renderContent = () => {
+        if (isLoading) {
+            return React__default["default"].createElement(StyledLiSkeleton, { count: 5 });
+        }
+        if (!cities || cities.length < 1) {
+            return (React__default["default"].createElement(React__default["default"].Fragment, null,
+                React__default["default"].createElement(StyledLocationItem$1, { "data-is-denied": "true" },
+                    React__default["default"].createElement(index$2.Text, { size: "sm", color: "#ccc" }, t('booking.searchBar.noResults')))));
+        }
+        return (React__default["default"].createElement(React__default["default"].Fragment, null,
+            React__default["default"].createElement(StyledLocationItem$1, { key: "all-location", role: "button", tabIndex: 0, onClick: () => {
+                    var _a;
+                    if (onLocationClick) {
+                        onLocationClick({
+                            name: t('booking.searchBar.allLocations'),
+                            id: constants.ID_OPTION_ALL_LOCATION,
+                            slug: (_a = constants.LOCALIZED_SLUGS[locale]) === null || _a === void 0 ? void 0 : _a.ALL,
+                        });
+                    }
+                } },
+                React__default["default"].createElement(StyledPinIcon$1, { color: theme.theme.colors.neutral400 }),
+                React__default["default"].createElement(index$2.Text, { size: "md" }, t('booking.searchBar.allLocations'))),
+            cities.map((city) => (React__default["default"].createElement(StyledLocationItem$1, { key: city.id, onClick: (evt) => {
+                    evt.nativeEvent.stopImmediatePropagation();
+                    if (onLocationClick) {
+                        onLocationClick(city);
+                    }
+                }, role: "button", tabIndex: 0, "aria-label": `Select ${city.name} as location`, isSelected: (selectedLocation === null || selectedLocation === void 0 ? void 0 : selectedLocation.id) === city.id },
+                React__default["default"].createElement(StyledPinIcon$1, { color: theme.theme.colors.neutral400 }),
+                React__default["default"].createElement(index$2.Text, { size: "md" }, city.name))))));
+    };
+    return (React__default["default"].createElement(StyledLocationResultsWrapper, { "data-testid": "location-search-results" },
+        React__default["default"].createElement(StyledLocationResultsList, null, renderContent())));
+};
+
+const EVENT_NAMES = {
+    TYPE_CHARACTER: 'TYPE_CHARACTER',
+    REMOVE_CHARACTER: 'REMOVE_CHARACTER',
+    REMOVE_ALL: 'REMOVE_ALL',
+    REMOVE_LAST_VISIBLE_NODE: 'REMOVE_LAST_VISIBLE_NODE',
+    PAUSE_FOR: 'PAUSE_FOR',
+    CHANGE_DELETE_SPEED: 'CHANGE_DELETE_SPEED',
+    CHANGE_DELAY: 'CHANGE_DELAY',
+    PASTE_STRING: 'PASTE_STRING',
+};
+const getRandomInteger = (min, max) => {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+const VISIBLE_NODE_TYPES = {
+    TEXT_NODE: 'TEXT_NODE',
+};
+class Typewriter {
+    constructor(options) {
+        this.state = {
+            lastFrameTime: null,
+            pauseUntil: null,
+            eventQueue: [],
+            eventLoop: null,
+            eventLoopPaused: false,
+            reverseCalledEvents: [],
+            calledEvents: [],
+            visibleNodes: [],
+            initialOptions: null,
+        };
+        this.options = {
+            strings: null,
+            delay: 'natural',
+            pauseFor: 1500,
+            deleteSpeed: 'natural',
+            loop: false,
+            autoStart: false,
+            stringSplitter: null,
+            onCreateTextNode: null,
+            onRemoveNode: null,
+        };
+        this.start = () => {
+            this.state.eventLoopPaused = false;
+            this.runEventLoop();
+            return this;
+        };
+        this.pause = () => {
+            this.state.eventLoopPaused = true;
+            return this;
+        };
+        this.stop = () => {
+            if (this.state.eventLoop) {
+                window.cancelAnimationFrame(this.state.eventLoop);
+                this.state.eventLoop = null;
+            }
+            return this;
+        };
+        this.pauseFor = (ms) => {
+            this.addEventToQueue(EVENT_NAMES.PAUSE_FOR, { ms });
+            return this;
+        };
+        this.typeOutAllStrings = () => {
+            if (typeof this.options.strings === 'string') {
+                this.typeString(this.options.strings).pauseFor(this.options.pauseFor);
+                return this;
+            }
+            this.options.strings.forEach((string) => {
+                this.typeString(string)
+                    .pauseFor(this.options.pauseFor)
+                    .deleteAll(this.options.deleteSpeed);
+            });
+            return this;
+        };
+        this.typeString = (string, node = null) => {
+            if (string) {
+                const { stringSplitter } = this.options || {};
+                const characters = typeof stringSplitter === 'function'
+                    ? stringSplitter(string)
+                    : string.split('');
+                this.typeCharacters(characters, node);
+            }
+            return this;
+        };
+        this.pasteString = (string, node = null) => {
+            if (string) {
+                this.addEventToQueue(EVENT_NAMES.PASTE_STRING, {
+                    character: string,
+                    node,
+                });
+            }
+            return this;
+        };
+        this.deleteAll = (speed = 'natural') => {
+            this.addEventToQueue(EVENT_NAMES.REMOVE_ALL, { speed });
+            return this;
+        };
+        this.changeDeleteSpeed = (speed) => {
+            if (!speed) {
+                throw new Error('Must provide new delete speed');
+            }
+            this.addEventToQueue(EVENT_NAMES.CHANGE_DELETE_SPEED, { speed });
+            return this;
+        };
+        this.changeDelay = (delay) => {
+            if (!delay) {
+                throw new Error('Must provide new delay');
+            }
+            this.addEventToQueue(EVENT_NAMES.CHANGE_DELAY, { delay });
+            return this;
+        };
+        this.deleteChars = (amount) => {
+            if (!amount) {
+                throw new Error('Must provide amount of characters to delete');
+            }
+            for (let i = 0; i < amount; i++) {
+                this.addEventToQueue(EVENT_NAMES.REMOVE_CHARACTER);
+            }
+            return this;
+        };
+        this.typeCharacters = (characters, node = null) => {
+            if (!characters || !Array.isArray(characters)) {
+                throw new Error('Characters must be an array');
+            }
+            characters.forEach((character) => {
+                this.addEventToQueue(EVENT_NAMES.TYPE_CHARACTER, { character, node });
+            });
+            return this;
+        };
+        this.removeCharacters = (characters) => {
+            if (!characters || !Array.isArray(characters)) {
+                throw new Error('Characters must be an array');
+            }
+            characters.forEach(() => {
+                this.addEventToQueue(EVENT_NAMES.REMOVE_CHARACTER);
+            });
+            return this;
+        };
+        this.addEventToQueue = (eventName, eventArgs, prepend = false) => {
+            return this.addEventToStateProperty(eventName, eventArgs, prepend, 'eventQueue');
+        };
+        this.addReverseCalledEvent = (eventName, eventArgs, prepend = false) => {
+            const { loop } = this.options;
+            if (!loop) {
+                return this;
+            }
+            return this.addEventToStateProperty(eventName, eventArgs, prepend, 'reverseCalledEvents');
+        };
+        this.addEventToStateProperty = (eventName, eventArgs, prepend = false, property) => {
+            const eventItem = {
+                eventName,
+                eventArgs: eventArgs || {},
+            };
+            if (prepend) {
+                this.state[property] = [eventItem, ...this.state[property]];
+            }
+            else {
+                this.state[property] = [...this.state[property], eventItem];
+            }
+            return this;
+        };
+        this.runEventLoop = () => {
+            if (!this.state.lastFrameTime) {
+                this.state.lastFrameTime = Date.now();
+            }
+            // Setup variables to calculate if this frame should run
+            const nowTime = Date.now();
+            const delta = nowTime - this.state.lastFrameTime;
+            if (!this.state.eventQueue.length) {
+                if (!this.options.loop) {
+                    return;
+                }
+                // Reset event queue if we are looping
+                this.state.eventQueue = [...this.state.calledEvents];
+                this.state.calledEvents = [];
+                this.options = Object.assign({}, this.state.initialOptions);
+            }
+            // Request next frame
+            this.state.eventLoop = window.requestAnimationFrame(this.runEventLoop);
+            // Check if event loop is paused
+            if (this.state.eventLoopPaused) {
+                return;
+            }
+            // Check if state has pause until time
+            if (this.state.pauseUntil) {
+                // Check if event loop should be paused
+                if (nowTime < this.state.pauseUntil) {
+                    return;
+                }
+                // Reset pause time
+                this.state.pauseUntil = null;
+            }
+            // Make a clone of event queue
+            const eventQueue = [...this.state.eventQueue];
+            // Get first event from queue
+            const currentEvent = eventQueue.shift();
+            // Setup delay variable
+            let delay = 0;
+            // Check if frame should run or be
+            // skipped based on fps interval
+            if (currentEvent.eventName === EVENT_NAMES.REMOVE_LAST_VISIBLE_NODE ||
+                currentEvent.eventName === EVENT_NAMES.REMOVE_CHARACTER) {
+                delay =
+                    this.options.deleteSpeed === 'natural'
+                        ? getRandomInteger(40, 80)
+                        : this.options.deleteSpeed;
+            }
+            else {
+                delay =
+                    this.options.delay === 'natural'
+                        ? getRandomInteger(120, 160)
+                        : this.options.delay;
+            }
+            if (delta <= delay) {
+                return;
+            }
+            // Get current event args
+            const { eventName, eventArgs } = currentEvent;
+            // Run item from event loop
+            switch (eventName) {
+                case EVENT_NAMES.PASTE_STRING:
+                case EVENT_NAMES.TYPE_CHARACTER: {
+                    const { character } = eventArgs;
+                    const textNode = document.createTextNode(character);
+                    let textNodeToUse = textNode;
+                    if (this.options.onCreateTextNode &&
+                        typeof this.options.onCreateTextNode === 'function') {
+                        textNodeToUse = this.options.onCreateTextNode(character, textNode);
+                    }
+                    this.state.visibleNodes = [
+                        ...this.state.visibleNodes,
+                        {
+                            type: VISIBLE_NODE_TYPES.TEXT_NODE,
+                            character,
+                            node: textNodeToUse,
+                        },
+                    ];
+                    break;
+                }
+                case EVENT_NAMES.REMOVE_CHARACTER: {
+                    eventQueue.unshift({
+                        eventName: EVENT_NAMES.REMOVE_LAST_VISIBLE_NODE,
+                        eventArgs: { removingCharacterNode: true },
+                    });
+                    break;
+                }
+                case EVENT_NAMES.PAUSE_FOR: {
+                    const { ms } = currentEvent.eventArgs;
+                    this.state.pauseUntil = Date.now() + parseInt(ms);
+                    break;
+                }
+                case EVENT_NAMES.REMOVE_ALL: {
+                    const { visibleNodes } = this.state;
+                    const { speed } = eventArgs;
+                    const removeAllEventItems = [];
+                    if (speed) {
+                        removeAllEventItems.push({
+                            eventName: EVENT_NAMES.CHANGE_DELETE_SPEED,
+                            eventArgs: { speed, temp: true },
+                        });
+                    }
+                    for (let i = 0, length = visibleNodes.length; i < length; i++) {
+                        removeAllEventItems.push({
+                            eventName: EVENT_NAMES.REMOVE_LAST_VISIBLE_NODE,
+                            eventArgs: { removingCharacterNode: false },
+                        });
+                    }
+                    if (speed) {
+                        removeAllEventItems.push({
+                            eventName: EVENT_NAMES.CHANGE_DELETE_SPEED,
+                            eventArgs: { speed: this.options.deleteSpeed, temp: true },
+                        });
+                    }
+                    eventQueue.unshift(...removeAllEventItems);
+                    break;
+                }
+                case EVENT_NAMES.REMOVE_LAST_VISIBLE_NODE: {
+                    if (this.state.visibleNodes.length) {
+                        const { node, character } = this.state.visibleNodes.pop();
+                        if (this.options.onRemoveNode &&
+                            typeof this.options.onRemoveNode === 'function') {
+                            this.options.onRemoveNode({
+                                node,
+                                character,
+                            });
+                        }
+                        if (node) {
+                            node.parentNode.removeChild(node);
+                        }
+                    }
+                    break;
+                }
+                case EVENT_NAMES.CHANGE_DELETE_SPEED: {
+                    this.options.deleteSpeed = currentEvent.eventArgs.speed;
+                    break;
+                }
+                case EVENT_NAMES.CHANGE_DELAY: {
+                    this.options.delay = currentEvent.eventArgs.delay;
+                    break;
+                }
+            }
+            // Add que item to called queue if we are looping
+            if (this.options.loop) {
+                if (currentEvent.eventName !== EVENT_NAMES.REMOVE_LAST_VISIBLE_NODE &&
+                    !(currentEvent.eventArgs && currentEvent.eventArgs.temp)) {
+                    this.state.calledEvents = [...this.state.calledEvents, currentEvent];
+                }
+            }
+            // Replace state event queue with cloned queue
+            this.state.eventQueue = eventQueue;
+            // Set last frame time so it can be used to calculate next frame
+            this.state.lastFrameTime = nowTime;
+        };
+        if (options) {
+            this.options = Object.assign(Object.assign({}, this.options), options);
+        }
+        this.state.initialOptions = Object.assign({}, this.options);
+        this.init();
+    }
+    init() {
+        this.addEventToQueue(EVENT_NAMES.REMOVE_ALL, null, true);
+        if (this.options.autoStart === true && this.options.strings) {
+            this.typeOutAllStrings().start();
+        }
+    }
+}
+
+function useAnimatedPlaceholder({ inputRef, wrapperRef, disabled, }) {
+    const { t, locale } = useTranslations.useTranslations();
+    const values = React.useMemo(() => {
+        if (disabled) {
+            return [];
+        }
+        const shuffleKeys = [
+            'booking.searchBar.placeholder.hospital',
+            'booking.searchBar.placeholder.doctor',
+        ];
+        if (locale !== 'zh-TW') {
+            shuffleKeys.push('booking.searchBar.placeholder.specialty', 'booking.searchBar.placeholder.service');
+        }
+        return shuffle__default["default"](shuffleKeys).map((s) => t(s));
+    }, [t, locale]);
+    React.useEffect(() => {
+        if (disabled) {
+            return;
+        }
+        const input = getInput();
+        if (input) {
+            input.placeholder = '';
+            new Typewriter({
+                strings: values,
+                autoStart: true,
+                loop: true,
+                delay: 32,
+                deleteSpeed: 32,
+                pauseFor: 1500,
+                onCreateTextNode: customNodeCreator,
+                onRemoveNode: onRemoveNode,
+            });
+        }
+    }, [inputRef, wrapperRef]);
+    function customNodeCreator(character) {
+        const input = getInput();
+        if (input) {
+            input.placeholder = input.placeholder + character;
+        }
+        return null;
+    }
+    function onRemoveNode() {
+        const input = getInput();
+        if (input) {
+            input.placeholder = input.placeholder.slice(0, -1);
+        }
+    }
+    function getInput() {
+        if (inputRef && inputRef.current) {
+            return inputRef.current;
+        }
+        else if (wrapperRef && wrapperRef.current) {
+            return wrapperRef.current.querySelector('input') || null;
+        }
+        return null;
+    }
+    return;
+}
+
+const StyledFakeInputSearchMobile = styled__default["default"].div `
+  user-select: none;
+  input {
+    pointer-events: none;
+    background-color: white;
+  }
+`;
+function MobileFakeInput({ focused, value = '', onClick, trackingAttributes, inputSearchPlaceholder, }) {
+    const { t } = useTranslations.useTranslations();
+    const wrapperRef = React.useRef(null);
+    useAnimatedPlaceholder({ wrapperRef, disabled: !!inputSearchPlaceholder });
+    const gaAttributes = React.useMemo(() => {
+        if (trackingAttributes) {
+            return {
+                'data-event-category': trackingAttributes.dataEventCategory,
+                'data-event-action': trackingAttributes.dataEventAction,
+                'data-event-label': trackingAttributes.dataEventLabel,
+            };
+        }
+        else {
+            return {};
+        }
+    }, [trackingAttributes]);
+    return (React__default["default"].createElement(StyledFakeInputSearchMobile, Object.assign({ onClick: () => onClick && onClick(), ref: wrapperRef }, gaAttributes),
+        React__default["default"].createElement(StyledInput, { inputClassName: focused === 'location' ? 'focused' : undefined, name: "booking-search-placeholder", displayIcon: React__default["default"].createElement(MagnifierIcon, { color: theme.theme.colors.gray400 }), placeholder: t('booking.searchBar.searchInput.placeholder'), value: value, size: "md" })));
+}
+
+const StyledTopBar = styled__default["default"].header `
+  display: flex;
+  height: 64px;
+  align-items: center;
+  justify-content: space-between;
+  margin: 0 auto;
+  position: sticky;
+  z-index: 99;
+  background-color: white;
+  top: 0;
+  left: 0;
+`;
+const StyledTopBarHeaderRight = styled__default["default"].div `
+  display: inline-flex;
+  flex: 1;
+  justify-content: flex-end;
+  cursor: pointer;
+  text-decoration: underline;
+`;
+const StyledTopBarIcon = styled__default["default"].div `
+  display: flex;
+  align-items: center;
+  margin-left: 16px;
+  cursor: pointer;
+`;
+const StyledTopbarHeading = styled__default["default"].div `
+  width: 100%;
+  margin-left: 24px;
+`;
+const StyledTopbarHeadingText = styled__default["default"](index$2.Text) `
+  color: ${theme.theme.colors.secondaryDark};
+  text-align: start;
+`;
+
+const MobileTopBar = ({ className, onLeftClick, headingText, onRightClick, iconLeft, textRight, }) => {
+    return (React__default["default"].createElement(StyledTopBar, { className: className },
+        React__default["default"].createElement(StyledTopBarIcon, { onClick: onLeftClick }, iconLeft || React__default["default"].createElement(CloseIcon, { color: theme.theme.colors.gray800 })),
+        React__default["default"].createElement(StyledTopbarHeading, null,
+            React__default["default"].createElement(StyledTopbarHeadingText, { size: "md", weight: "bold" }, headingText)),
+        React__default["default"].createElement(StyledTopBarHeaderRight, { onClick: onRightClick }, textRight && React__default["default"].createElement("p", null, textRight))));
+};
+
+const SEARCH_KEYWORD_MIN_LENGTH$1 = {
+    'en-PH': 3,
+    'tl-PH': 2,
+    'id-ID': 3,
+    'vi-VN': 2,
+    'zh-TW': 0,
+    'ms-MY': 2,
+};
+
+const initialState$1 = {
+    isMobile: false,
+    isDebug: false,
+    navigateTo: null,
+    geoLocationPermission: 'unset',
+    geoLocationCoordinates: null,
+    focused: 'none',
+    searchLocationKeywords: '',
+    searchKeywords: '',
+    selectedLocation: null,
+    defaultCity: null,
+    initialCities: [],
+    cities: [],
+    searchResults: [],
+    initialSearchResults: [],
+    isLoadingCities: false,
+    isLoadingSearchResults: false,
+    isMobileModalOpened: false,
+    initialSelectedCity: null,
+    autoCompleteDisabled: false,
+    inputSearchPlaceholder: '',
+    locale: 'vi-VN',
+};
+var ActionTypes$1;
+(function (ActionTypes) {
+    ActionTypes["NavigateTo"] = "navigate to url";
+    ActionTypes["ClickOutsideInputLocation"] = "click outside input location";
+    ActionTypes["ClickOutsideInputSearch"] = "click outside input search";
+    ActionTypes["SelectCurrentLocation"] = "select current location";
+    ActionTypes["FocusInputLocation"] = "focus input location";
+    ActionTypes["FocusInputSearch"] = "focus input search";
+    ActionTypes["ChangeInputLocation"] = "change input location";
+    ActionTypes["ChangeInputSearch"] = "change input search";
+    ActionTypes["ClearInputLocation"] = "clear input location";
+    ActionTypes["ClearInputSearch"] = "clear input search";
+    ActionTypes["SelectLocation"] = "select location";
+    ActionTypes["FetchCitiesStart"] = "fetch cities start";
+    ActionTypes["FetchCitiesFinish"] = "fetch cities finish";
+    ActionTypes["FetchSearchResultsStart"] = "fetch search results start";
+    ActionTypes["FetchSearchResultsComplete"] = "fetch search results complete";
+    ActionTypes["FetchSearchResultsFinish"] = "fetch search results finish";
+    ActionTypes["FetchCitiesByGeoIpComplete"] = "fetch cities by geo IP finish";
+    ActionTypes["FetchCitiesByKeywordComplete"] = "fetch cities by keyword finish";
+    ActionTypes["DisplayInitialCities"] = "display initial cities";
+    ActionTypes["DisplayInitialSearchResults"] = "display initial search results";
+    ActionTypes["GrantGeoLocationPermission"] = "grant geolocation permission";
+    ActionTypes["DenyGeoLocationPermission"] = "deny geolocation permission";
+    ActionTypes["OpenMobileModal"] = "open mobile modal";
+    ActionTypes["CloseMobileModal"] = "close mobile modal";
+    ActionTypes["UpdateInitialSearchValue"] = "update initial search value";
+    ActionTypes["SelectSearchResult"] = "select search result";
+    ActionTypes["SetInputSearchPlaceholder"] = "set input search placeholder";
+})(ActionTypes$1 || (ActionTypes$1 = {}));
+function resetSearchLocationKeywords$1(state) {
+    const { selectedLocation, searchLocationKeywords } = state;
+    if (selectedLocation && searchLocationKeywords !== selectedLocation.name) {
+        return Object.assign(Object.assign({}, state), { searchLocationKeywords: selectedLocation.name });
+    }
+    return state;
+}
+function reducer$1(state, action) {
+    var _a;
+    if (state.isDebug) {
+        console.log('bookingSearchBar', { action, state });
+    }
+    switch (action.type) {
+        case ActionTypes$1.NavigateTo:
+            return Object.assign(Object.assign({}, state), { navigateTo: action.payload, focused: 'none', isMobileModalOpened: false });
+        case ActionTypes$1.ClickOutsideInputLocation: {
+            if (state.isMobile || state.focused !== 'location') {
+                return state;
+            }
+            return resetSearchLocationKeywords$1(Object.assign(Object.assign({}, state), { focused: 'none' }));
+        }
+        case ActionTypes$1.ClickOutsideInputSearch: {
+            if (state.isMobile || state.focused !== 'search') {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { focused: 'none' });
+        }
+        case ActionTypes$1.FocusInputLocation: {
+            const nextState = Object.assign(Object.assign({}, state), { focused: 'location' });
+            if (((_a = state.selectedLocation) === null || _a === void 0 ? void 0 : _a.id) === constants.ID_OPTION_CURRENT_LOCATION) {
+                nextState.searchLocationKeywords = '';
+            }
+            return nextState;
+        }
+        case ActionTypes$1.FocusInputSearch:
+            const nextState = Object.assign(Object.assign({}, state), { focused: 'search' });
+            if (state.isMobile) {
+                return resetSearchLocationKeywords$1(nextState);
+            }
+            return nextState;
+        case ActionTypes$1.ChangeInputLocation:
+            return Object.assign(Object.assign({}, state), { searchLocationKeywords: action.payload });
+        case ActionTypes$1.ChangeInputSearch: {
+            const keyword = action.payload;
+            return Object.assign(Object.assign({}, state), { searchKeywords: keyword, isLoadingSearchResults: keyword.trim().length > SEARCH_KEYWORD_MIN_LENGTH$1[state.locale] });
+        }
+        case ActionTypes$1.SelectCurrentLocation:
+            return Object.assign(Object.assign({}, state), { focused: 'none', selectedLocation: action.payload, searchLocationKeywords: action.payload.name });
+        case ActionTypes$1.ClearInputLocation:
+            return Object.assign(Object.assign({}, state), { focused: 'location', cities: state.initialCities, searchLocationKeywords: '' });
+        case ActionTypes$1.ClearInputSearch:
+            return Object.assign(Object.assign({}, state), { focused: 'search', searchKeywords: '' });
+        case ActionTypes$1.SelectLocation:
+            return Object.assign(Object.assign({}, state), { focused: 'none', selectedLocation: action.payload, searchLocationKeywords: action.payload.name });
+        case ActionTypes$1.SelectSearchResult:
+            return Object.assign(Object.assign({}, state), { searchKeywords: action.payload.name, isMobileModalOpened: false, focused: 'none', navigateTo: action.payload.url });
+        case ActionTypes$1.FetchCitiesStart:
+            return Object.assign(Object.assign({}, state), { isLoadingCities: true });
+        case ActionTypes$1.FetchCitiesFinish:
+            return Object.assign(Object.assign({}, state), { isLoadingCities: false });
+        case ActionTypes$1.FetchSearchResultsStart:
+            return Object.assign(Object.assign({}, state), { isLoadingSearchResults: true });
+        case ActionTypes$1.FetchSearchResultsFinish:
+            return Object.assign(Object.assign({}, state), { isLoadingSearchResults: false });
+        case ActionTypes$1.FetchSearchResultsComplete: {
+            const nextState = Object.assign(Object.assign({}, state), { searchResults: action.payload });
+            if (state.initialSearchResults.length === 0) {
+                nextState.initialSearchResults = action.payload;
+            }
+            return nextState;
+        }
+        case ActionTypes$1.FetchCitiesByGeoIpComplete: {
+            let { cities } = action.payload;
+            const { default: defaultCity } = action.payload;
+            cities = cities.filter((c) => c.id !== defaultCity.id);
+            cities.unshift(defaultCity);
+            if (state.initialSelectedCity &&
+                !cities.find((c) => c.id === state.initialSelectedCity.id)) {
+                cities.unshift(state.initialSelectedCity);
+            }
+            const nextState = Object.assign(Object.assign({}, state), { defaultCity, initialCities: cities, cities });
+            if (state.geoLocationPermission === 'denied' &&
+                !state.initialSelectedCity) {
+                nextState.selectedLocation = defaultCity;
+                nextState.searchLocationKeywords = defaultCity.name;
+            }
+            return nextState;
+        }
+        case ActionTypes$1.FetchCitiesByKeywordComplete:
+            return Object.assign(Object.assign({}, state), { cities: action.payload });
+        case ActionTypes$1.DisplayInitialCities:
+            return Object.assign(Object.assign({}, state), { cities: state.initialCities });
+        case ActionTypes$1.DisplayInitialSearchResults:
+            return Object.assign(Object.assign({}, state), { searchResults: state.initialSearchResults, isLoadingSearchResults: false });
+        case ActionTypes$1.GrantGeoLocationPermission:
+            return Object.assign(Object.assign({}, state), { geoLocationPermission: 'granted', geoLocationCoordinates: action.payload });
+        case ActionTypes$1.DenyGeoLocationPermission:
+            return Object.assign(Object.assign({}, state), { geoLocationPermission: 'denied', geoLocationCoordinates: null });
+        case ActionTypes$1.OpenMobileModal:
+            return Object.assign(Object.assign({}, state), { isMobileModalOpened: true });
+        case ActionTypes$1.CloseMobileModal:
+            return Object.assign(Object.assign({}, state), { isMobileModalOpened: false });
+        case ActionTypes$1.UpdateInitialSearchValue:
+            return Object.assign(Object.assign({}, state), { searchKeywords: action.payload });
+        case ActionTypes$1.SetInputSearchPlaceholder:
+            return Object.assign(Object.assign({}, state), { inputSearchPlaceholder: action.payload });
+        default:
+            return state;
+    }
+}
+
+const StyledSearchBarInputsWrapper = styled__default["default"].div `
+  display: flex;
+  gap: 16px;
+  ${utils.MediaQueries.mbDown} {
+    flex-direction: column;
+    padding: 14px;
+    background-color: ${theme.theme.colors.primary50};
+
+    input {
+      filter: drop-shadow(0px 4px 8px rgba(0, 0, 0, 0.04))
+        drop-shadow(0px 0px 2px rgba(0, 0, 0, 0.06))
+        drop-shadow(0px 0px 1px rgba(0, 0, 0, 0.04));
+    }
+  }
+
+  input {
+    background-color: white;
+  }
+`;
+const StyledInputWrapper = styled__default["default"].div `
+  position: relative;
+`;
+const StyledInputLocationWrapper = styled__default["default"](StyledInputWrapper) `
+  flex: 1;
+`;
+const StyledInputSearchWrapper = styled__default["default"](StyledInputWrapper) `
+  flex: 2;
+`;
+const StyledClearIcon = styled__default["default"](ClearIcon) `
+  display: none;
+  &.shown {
+    display: block;
+  }
+`;
+
+const SearchIcon = () => (React__default["default"].createElement("svg", { width: "18", height: "18", viewBox: "0 0 18 18" },
+    React__default["default"].createElement("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M2.97887 8.15493C2.97887 5.29627 5.29627 2.97887 8.15493 2.97887C11.0136 2.97887 13.331 5.29627 13.331 8.15493C13.331 11.0136 11.0136 13.331 8.15493 13.331C5.29627 13.331 2.97887 11.0136 2.97887 8.15493ZM8.15493 1.5C4.47951 1.5 1.5 4.47951 1.5 8.15493C1.5 11.8303 4.47951 14.8099 8.15493 14.8099C9.72624 14.8099 11.1704 14.2653 12.3089 13.3546L15.2377 16.2834C15.5265 16.5722 15.9947 16.5722 16.2834 16.2834C16.5722 15.9947 16.5722 15.5265 16.2834 15.2377L13.3546 12.3089C14.2653 11.1704 14.8099 9.72624 14.8099 8.15493C14.8099 4.47951 11.8303 1.5 8.15493 1.5Z", fill: "white" })));
+const StyledSearchIcon = styled__default["default"].button `
+  min-height: 100%;
+  border-radius: 6px;
+  background-color: ${theme.theme.colors.primaryBase};
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  gap: 11px;
+  cursor: pointer;
+  flex: 0.3;
+
+  ${utils.MediaQueries.mbDown} {
+    --margin: 16px;
+    min-height: 44px;
+    margin: var(--margin);
+    width: calc(100% - var(--margin) * 2);
+    position: absolute;
+    bottom: 0;
+  }
+
+  &:hover {
+    background-color: ${theme.theme.colors.primaryHover};
+  }
+
+  &:active {
+    background-color: ${theme.theme.colors.primaryActive};
+  }
+
+  &:focus-visible {
+    outline: 1px solid black;
+  }
+`;
+const StyledText$1 = styled__default["default"](index$2.Text) `
+  font-weight: ${theme.theme.sizes.fwSemiBold};
+`;
+const SearchButton = ({ onClick }) => {
+    const { t } = useTranslations.useTranslations();
+    const title = t('booking.searchBar.searchButton');
+    return (React__default["default"].createElement(StyledSearchIcon, { onClick: onClick, title: title },
+        React__default["default"].createElement(SearchIcon, null),
+        React__default["default"].createElement(StyledText$1, { size: "s3", color: "white" }, title)));
+};
+
+function SearchInputs$1({ isMobile, state, dispatch, debouncedFetchCitiesByKeyword, debouncedFetchSearchResults, focusLocationInput, focusSearchInput, renderLocationResults, renderSearchResults, locationTrackingAttributes, trackingAttributes, onSearch, initalSearchValue, }) {
+    const inputLocationWrapperRef = React.useRef(null);
+    const inputSearchWrapperRef = React.useRef(null);
+    const { focused, searchLocationKeywords, geoLocationPermission, selectedLocation, searchKeywords, inputSearchPlaceholder, } = state;
+    const { t } = useTranslations.useTranslations();
+    useAnimatedPlaceholder({
+        wrapperRef: inputSearchWrapperRef,
+        disabled: !!inputSearchPlaceholder,
+    });
+    useOutsideClick.useOutsideClick(inputLocationWrapperRef, () => {
+        if (!isMobile) {
+            dispatch({ type: ActionTypes$1.ClickOutsideInputLocation });
+        }
+    });
+    useOutsideClick.useOutsideClick(inputSearchWrapperRef, () => {
+        if (!isMobile) {
+            dispatch({ type: ActionTypes$1.ClickOutsideInputSearch });
+        }
+    });
+    function handleLocationInputClear() {
+        dispatch({ type: ActionTypes$1.ClearInputLocation });
+        debouncedFetchCitiesByKeyword.cancel();
+        focusLocationInput();
+    }
+    function handleSearchInputClear() {
+        dispatch({ type: ActionTypes$1.ClearInputSearch });
+        debouncedFetchSearchResults.cancel();
+        debouncedFetchSearchResults('', state);
+        focusSearchInput();
+    }
+    const searchInputPinIconColor = React.useMemo(() => {
+        if (geoLocationPermission === 'granted' &&
+            (selectedLocation === null || selectedLocation === void 0 ? void 0 : selectedLocation.id) === constants.ID_OPTION_CURRENT_LOCATION) {
+            return theme.theme.colors.primaryBase;
+        }
+        else {
+            return theme.theme.colors.gray400;
+        }
+    }, [geoLocationPermission, selectedLocation]);
+    const handleSearchInputChange = React.useCallback(function handleSearchInputChange(value) {
+        dispatch({ type: ActionTypes$1.ChangeInputSearch, payload: value });
+        if (typeof onSearch === 'function') {
+            return;
+        }
+        if (value.trim().length > SEARCH_KEYWORD_MIN_LENGTH$1[state.locale] ||
+            initalSearchValue) {
+            debouncedFetchSearchResults(value.trim(), state);
+        }
+        else {
+            debouncedFetchSearchResults.cancel();
+            dispatch({ type: ActionTypes$1.DisplayInitialSearchResults });
+        }
+    }, [dispatch, state]);
+    const handleSearchLocationInputChange = React.useCallback(function handleSearchLocationInputChange(value) {
+        dispatch({ type: ActionTypes$1.ChangeInputLocation, payload: value });
+        if (value.trim().length > SEARCH_KEYWORD_MIN_LENGTH$1[state.locale]) {
+            debouncedFetchCitiesByKeyword(value.trim());
+        }
+        else {
+            debouncedFetchCitiesByKeyword.cancel();
+            dispatch({ type: ActionTypes$1.DisplayInitialCities });
+        }
+    }, [debouncedFetchCitiesByKeyword, dispatch]);
+    const handleKeyPress = (e) => {
+        if (state.autoCompleteDisabled && e.key === 'Enter' && onSearch) {
+            onSearch({
+                cityId: state.selectedLocation.id,
+                keyword: searchKeywords,
+            });
+        }
+    };
+    return (React__default["default"].createElement(StyledSearchBarInputsWrapper, null,
+        React__default["default"].createElement(StyledInputLocationWrapper, { ref: inputLocationWrapperRef },
+            React__default["default"].createElement(StyledInput, { inputClassName: focused === 'location' ? 'focused' : undefined, placeholder: t('booking.searchBar.locationPlaceholder'), autoComplete: "off", name: "search-location", displayIcon: React__default["default"].createElement(PinIcon, { className: "location-pin-icon", color: searchInputPinIconColor }), actionIcon: React__default["default"].createElement(StyledClearIcon, { color: theme.theme.colors.gray300, className: searchLocationKeywords !== '' ? 'shown' : '' }), onActionClick: handleLocationInputClear, value: searchLocationKeywords, onChange: handleSearchLocationInputChange, onFocus: () => dispatch({ type: ActionTypes$1.FocusInputLocation }), size: "md", trackingAttributes: locationTrackingAttributes }),
+            !isMobile && renderLocationResults()),
+        React__default["default"].createElement(StyledInputSearchWrapper, { ref: inputSearchWrapperRef },
+            React__default["default"].createElement(StyledInput, { placeholder: inputSearchPlaceholder ||
+                    t('booking.searchBar.searchInput.placeholder'), autoComplete: "off", name: "search-results", actionIcon: React__default["default"].createElement(StyledClearIcon, { color: theme.theme.colors.gray300, className: searchKeywords !== '' ? 'shown' : '' }), onActionClick: handleSearchInputClear, value: searchKeywords, onChange: handleSearchInputChange, onFocus: () => dispatch({ type: ActionTypes$1.FocusInputSearch }), inputClassName: focused === 'search' ? 'focused' : undefined, size: "md", trackingAttributes: trackingAttributes, onKeyPress: handleKeyPress, enterKeyHint: state.autoCompleteDisabled ? 'search' : undefined }),
+            !isMobile && renderSearchResults()),
+        state.autoCompleteDisabled && !state.isMobile && (React__default["default"].createElement(SearchButton, { onClick: () => {
+                onSearch({
+                    cityId: state.selectedLocation.id,
+                    keyword: searchKeywords,
+                });
+            } }))));
+}
+
+const DoctorIcon$1 = () => (React__default["default"].createElement("svg", { width: "14", height: "18", viewBox: "0 0 14 18" },
+    React__default["default"].createElement("path", { d: "M7.00004 0.666992C5.29757 0.666992 3.64067 0.813476 2.52087 1.03158C1.73311 1.18457 1.16671 1.86816 1.16671 2.6722V4.83366C1.16671 5.29264 1.54106 5.66699 2.00004 5.66699H12C12.459 5.66699 12.8334 5.29264 12.8334 4.83366V2.69824C12.8334 1.89421 12.267 1.21061 11.4792 1.05762C10.3562 0.839518 8.69275 0.666992 7.00004 0.666992ZM6.16671 1.50033H7.83337V2.33366H8.66671V4.00033H7.83337V4.83366H6.16671V4.00033H5.33337V2.33366H6.16671V1.50033ZM1.42712 6.50033C1.3197 6.89421 1.24158 7.32389 1.19275 7.77637C1.14718 8.18001 1.05603 9.25423 1.06254 9.36491C0.603556 9.72624 0.333374 10.2861 0.333374 10.9014C0.333374 11.8356 0.977906 12.6364 1.84379 12.8285C2.74548 15.0192 4.55212 17.3337 7.00004 17.3337C9.44796 17.3337 11.2546 14.9964 12.1563 12.8024C13.0222 12.6136 13.6667 11.8356 13.6667 10.9014C13.6667 10.2861 13.3965 9.72624 12.9375 9.36491C12.9441 9.25423 12.8562 8.16048 12.8073 7.75033C12.7552 7.30436 12.6804 6.89095 12.573 6.50033H5.35942C6.52804 8.20606 9.27543 7.18717 11.0365 7.62012C11.5736 8.79199 11.1667 10.4326 11.1667 10.4326L11.8177 10.641C11.9121 10.6702 12 10.7549 12 10.9014C12 11.0576 11.8861 11.1943 11.6875 11.1878L11.0105 11.0837L10.7761 11.7347C9.96554 14.0492 8.4128 15.667 7.00004 15.667C5.58728 15.667 4.03455 14.0492 3.224 11.7347L2.96358 11.0837L2.26046 11.1878C2.11723 11.1878 2.00004 11.0576 2.00004 10.9014C2.00004 10.7549 2.08793 10.6702 2.18233 10.641L2.83337 10.4326C2.73246 10.5531 2.4102 8.7041 2.83337 8.03678C3.59184 7.5127 4.2266 7.87728 5.12504 6.50033H1.42712ZM5.17712 9.05241C4.57166 9.05241 4.08337 9.55371 4.08337 10.1722C4.08337 10.7907 4.57166 11.292 5.17712 11.292C5.78259 11.292 6.27087 10.7907 6.27087 10.1722C6.27087 9.55371 5.78259 9.05241 5.17712 9.05241ZM8.82296 9.05241C8.21749 9.05241 7.72921 9.55371 7.72921 10.1722C7.72921 10.7907 8.21749 11.292 8.82296 11.292C9.42843 11.292 9.91671 10.7907 9.91671 10.1722C9.91671 9.55371 9.42843 9.05241 8.82296 9.05241Z", fill: "#9AA2AC" })));
+const ServiceIcon$1 = () => (React__default["default"].createElement("svg", { width: "18", height: "18", viewBox: "0 0 18 18" },
+    React__default["default"].createElement("path", { d: "M8.99996 0.666992C6.27535 0.666992 3.85348 1.97884 2.33329 4.00033H4.59892C5.80009 2.94564 7.36259 2.33366 8.99996 2.33366C10.6373 2.33366 12.1998 2.94564 13.401 4.00033H15.6666C14.1464 1.97884 11.7246 0.666992 8.99996 0.666992ZM1.78642 4.83366C1.07678 7.04069 0.666626 9.59928 0.666626 12.3337C0.666626 14.085 0.826131 15.7679 1.13538 17.3337H16.8645C17.1738 15.7679 17.3333 14.085 17.3333 12.3337C17.3333 9.59928 16.9231 7.04069 16.2135 4.83366H1.78642ZM8.99996 7.33366C11.3014 7.33366 13.1666 9.19889 13.1666 11.5003C13.1666 13.8018 11.3014 15.667 8.99996 15.667C6.69853 15.667 4.83329 13.8018 4.83329 11.5003C4.83329 9.19889 6.69853 7.33366 8.99996 7.33366ZM8.16663 9.00033V10.667H6.49996V12.3337H8.16663V14.0003H9.83329V12.3337H11.5V10.667H9.83329V9.00033H8.16663Z", fill: "#9AA2AC" })));
+const HospitalIcon$1 = () => (React__default["default"].createElement("svg", { width: "16", height: "17", viewBox: "0 0 16 17" },
+    React__default["default"].createElement("path", { d: "M8 0.666992L0.5 5.63533V14.8337C0.5 15.7545 1.24583 16.5003 2.16667 16.5003H13.8333C14.7542 16.5003 15.5 15.7545 15.5 14.8337V5.63533L8 0.666992ZM11.3333 10.667H8.83333V13.167H7.16667V10.667H4.66667V9.00033H7.16667V6.50033H8.83333V9.00033H11.3333V10.667Z", fill: "#9AA2AC" })));
+const SpecialtyIcon$1 = () => (React__default["default"].createElement("svg", { width: "16", height: "16", viewBox: "0 0 16 16" },
+    React__default["default"].createElement("path", { d: "M3.83333 0.5C2.94928 0.5 2.10143 0.851189 1.47631 1.47631C0.851189 2.10143 0.5 2.94928 0.5 3.83333C0.5 4.71739 0.851189 5.56523 1.47631 6.19036C2.10143 6.81548 2.94928 7.16667 3.83333 7.16667C4.71739 7.16667 5.56523 6.81548 6.19036 6.19036C6.81548 5.56523 7.16667 4.71739 7.16667 3.83333C7.16667 2.94928 6.81548 2.10143 6.19036 1.47631C5.56523 0.851189 4.71739 0.5 3.83333 0.5V0.5ZM10.5 0.5C9.57917 0.5 8.83333 1.24583 8.83333 2.16667V5.5C8.83333 6.42083 9.57917 7.16667 10.5 7.16667H13.8333C14.7542 7.16667 15.5 6.42083 15.5 5.5V2.16667C15.5 1.24583 14.7542 0.5 13.8333 0.5H10.5ZM3.83333 8.83333C2.94928 8.83333 2.10143 9.18452 1.47631 9.80964C0.851189 10.4348 0.5 11.2826 0.5 12.1667C0.5 13.0507 0.851189 13.8986 1.47631 14.5237C2.10143 15.1488 2.94928 15.5 3.83333 15.5C4.71739 15.5 5.56523 15.1488 6.19036 14.5237C6.81548 13.8986 7.16667 13.0507 7.16667 12.1667C7.16667 11.2826 6.81548 10.4348 6.19036 9.80964C5.56523 9.18452 4.71739 8.83333 3.83333 8.83333V8.83333ZM12.1667 8.83333C11.2826 8.83333 10.4348 9.18452 9.80964 9.80964C9.18452 10.4348 8.83333 11.2826 8.83333 12.1667C8.83333 13.0507 9.18452 13.8986 9.80964 14.5237C10.4348 15.1488 11.2826 15.5 12.1667 15.5C13.0507 15.5 13.8986 15.1488 14.5237 14.5237C15.1488 13.8986 15.5 13.0507 15.5 12.1667C15.5 11.2826 15.1488 10.4348 14.5237 9.80964C13.8986 9.18452 13.0507 8.83333 12.1667 8.83333V8.83333Z", fill: "#9AA2AC" })));
+
+const StyledTypeHeader = styled__default["default"].header `
+  display: flex;
+  justify-content: space-between;
+  padding: 12px 24px;
+  background-color: ${theme.theme.colors.neutral50};
+  box-shadow: inset 0px 1px 0px #e4e8ec;
+`;
+const StyledInfoWrapper = styled__default["default"].div `
+  display: grid;
+  flex: 2;
+  align-items: center;
+  gap: 16px;
+  grid-template-columns: 16px 1fr;
+`;
+const StyledTypeName = styled__default["default"].p `
+  color: ${theme.theme.colors.neutral800};
+  font-size: 14px;
+  font-weight: ${theme.theme.sizes.fwSemiBold};
+  letter-spacing: -0.2px;
+  line-height: 22px;
+`;
+const StyledSeeMoreButton = styled__default["default"].button `
+  flex: 1;
+  cursor: pointer;
+  text-align: end;
+`;
+const StyledResultsContainer = styled__default["default"].section `
+  padding: 12px 16px;
+  --rowGap: 16px;
+  --graphicSize: 32px;
+
+  ${utils.MediaQueries.tdUp} {
+    --rowGap: 8px;
+  }
+`;
+const StyledItemsWrapper = styled__default["default"].ul `
+  --gap: 16px;
+  ${utils.MediaQueries.tdUp} {
+    --gap: 8px;
+  }
+
+  display: grid;
+  overflow: hidden;
+  gap: var(--gap);
+  transition: max-height 0.8s ease-out;
+
+  ${({ isMore }) => isMore &&
+    `
+     height: auto;
+     max-height: 0;
+     margin-top: var(--gap);
+   `}
+
+  ${({ isShown }) => isShown &&
+    `
+     max-height: 600px;
+    `}
+
+@media (prefers-reduced-motion) {
+    transition: none;
+  }
+
+  ${utils.MediaQueries.tdUp} {
+    grid-template-columns: 1fr 1fr;
+  }
+`;
+const StyledSeeMore = styled__default["default"](index$2.Text) `
+  margin-top: 12px;
+  margin-bottom: 8px;
+  cursor: pointer;
+  text-align: start;
+  text-transform: capitalize;
+`;
+
+const StyledResult = styled__default["default"].li `
+  display: flex;
+  align-items: center;
+  gap: var(--rowGap);
+  cursor: pointer;
+  &.not-nav {
+    cursor: default;
+  }
+`;
+const StyledRoundedIconWrapper = styled__default["default"].div `
+  --wrapper-size: var(--graphicSize);
+  border-radius: calc(var(--wrapper-size) / 2);
+  background-color: var(--neutral50);
+  width: var(--wrapper-size);
+  height: var(--wrapper-size);
+  aspect-ratio: 1/1;
+  overflow: hidden;
+
+  ${({ type }) => type &&
+    type === 'doctors' &&
+    `
+    border-radius: calc(var(--graphicSize) / 2);
+    `}
+
+  img {
+    width: var(--graphicSize);
+    height: var(--graphicSize);
+    ${({ type }) => type && type === 'doctors'
+    ? `
+
+        object-fit: cover;  
+      `
+    : `
+        object-fit: contain;
+      `}
+  }
+
+  &:focus-visible {
+    outline: 1px solid ${theme.theme.colors.gray600};
+  }
+`;
+const StyledText = styled__default["default"](index$2.Text) `
+  line-height: 22px;
+  letter-spacing: -0.2px;
+
+  ${utils.MediaQueries.tdUp} {
+    &[data-size='p3'] {
+      font-size: 14px;
+    }
+  }
+`;
+const StyledPictureWrapper = styled__default["default"].figure `
+  max-width: var(--graphicSize);
+  min-width: var(--graphicSize);
+`;
+const StyledLocationPin = styled__default["default"].svg `
+  margin: 0 auto;
+  display: block;
+`;
+const StyledImageSkeletonWrapper = styled__default["default"].div `
+  display: grid;
+  place-items: center;
+`;
+
+const defaultThumbnailByType = {
+    doctors: DefaultThumbnailDoctor,
+    services: DefaultThumbnailService,
+};
+const ResultSectionItem = ({ type, item, imageUrl, className, onClickItem, }) => {
+    const onKeyDown = (e) => {
+        if (e.key === 'Enter' || e.key === 'Space') {
+            if (onClickItem) {
+                onClickItem(item);
+            }
+        }
+    };
+    const defaultThumbnail = React.useMemo(() => {
+        const Cmp = defaultThumbnailByType[type] || DefaultThumbnailAny;
+        return React__default["default"].createElement(Cmp, { width: 32, height: type === 'services' ? 32 : 24 });
+    }, [type]);
+    return (React__default["default"].createElement(StyledResult, { onClick: () => onClickItem && onClickItem(item), onKeyDown: onKeyDown, tabIndex: 0, role: "button", className: className },
+        React__default["default"].createElement(StyledPictureWrapper, null, type === 'hospitals' ? (React__default["default"].createElement(StyledLocationPin, { width: "12", height: "16", viewBox: "0 0 12 16" },
+            React__default["default"].createElement("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M0.75 5.94873C0.75 3.04623 3.0975 0.69873 6 0.69873C8.9025 0.69873 11.25 3.04623 11.25 5.94873C11.25 9.07623 7.935 13.3887 6.5775 15.0312C6.2775 15.3912 5.73 15.3912 5.43 15.0312C4.065 13.3887 0.75 9.07623 0.75 5.94873ZM4.125 5.94873C4.125 6.98373 4.965 7.82373 6 7.82373C7.035 7.82373 7.875 6.98373 7.875 5.94873C7.875 4.91373 7.035 4.07373 6 4.07373C4.965 4.07373 4.125 4.91373 4.125 5.94873Z", fill: "#9AA2AC" }))) : (React__default["default"].createElement(StyledRoundedIconWrapper, { type: type }, imageUrl ? (React__default["default"].createElement("img", { src: imageUrl, width: 32, height: type === 'services' ? 32 : 24, loading: "lazy" })) : (defaultThumbnail)))),
+        React__default["default"].createElement(StyledText, { color: theme.theme.colors.gray800, size: "p3" }, item.name)));
+};
+
+const ResultSection = ({ type, data, state, dispatch, itemsToShow, itemsToShowDesktop, isMobile, isLoading, keyword, isNavResultItem, }) => {
+    const [seeMoreOpen, setSeeMoreOpen] = React.useState(false);
+    const { t, locale } = useTranslations.useTranslations();
+    const { selectedLocation, searchKeywords } = state;
+    const slugs = React.useMemo(() => constants.LOCALIZED_SLUGS[locale], [locale]);
+    const isMalay = locale === 'ms-MY';
+    const typeInformation = React.useMemo(() => {
+        return {
+            doctors: {
+                name: t('booking.searchPopup.doctors'),
+                icon: React__default["default"].createElement(DoctorIcon$1, null),
+                slug: slugs.DOCTOR,
+            },
+            services: {
+                name: t('booking.searchPopup.services'),
+                icon: React__default["default"].createElement(ServiceIcon$1, null),
+                slug: slugs.SERVICE,
+            },
+            hospitals: {
+                name: t('booking.searchPopup.hospitals'),
+                icon: React__default["default"].createElement(HospitalIcon$1, null),
+                slug: slugs.HOSPITAL,
+            },
+            specialties: {
+                name: t('booking.searchPopup.specialties'),
+                icon: React__default["default"].createElement(SpecialtyIcon$1, null),
+                slug: slugs.SPECIALTIES,
+            },
+        };
+    }, [type, slugs]);
+    const typeSlug = React.useMemo(() => typeInformation[type].slug, [typeInformation]);
+    const showItemCount = isMobile ? itemsToShow : itemsToShowDesktop;
+    function onClickItem(item) {
+        let url = '';
+        switch (type) {
+            case 'specialties':
+                url = `/${selectedLocation.slug}/${typeInformation.doctors.slug}/${item.slug}`;
+                break;
+            case 'services':
+                url = `/${selectedLocation.slug}/${typeSlug}/${item.slug}`;
+                break;
+            case 'doctors':
+            case 'hospitals':
+                url = `/${typeSlug}/${item.slug}-${item.id}`;
+                break;
+        }
+        if (url) {
+            dispatch({
+                type: ActionTypes$1.SelectSearchResult,
+                payload: { name: item.name, url },
+            });
+        }
+    }
+    function renderItem(item) {
+        return (React__default["default"].createElement(ResultSectionItem, { key: item.id, item: item, type: type, imageUrl: item.logo || item.avatar || item.thumbnail, className: !isNavResultItem ? 'not-nav' : '', onClickItem: isNavResultItem && onClickItem }));
+    }
+    function onSeeAllClick() {
+        let url = '';
+        switch (type) {
+            case 'specialties':
+                url = `/${typeSlug}`;
+                break;
+            case 'services':
+            case 'doctors':
+            case 'hospitals':
+                url = `/${selectedLocation.slug}/${typeSlug}`;
+                break;
+        }
+        if (url) {
+            dispatch({ type: ActionTypes$1.NavigateTo, payload: url });
+        }
+    }
+    function onClickSearchByKeyword() {
+        const { slug: typeSlug } = typeInformation[type];
+        const url = `/${selectedLocation.slug}/${typeSlug}?q=${searchKeywords}`;
+        dispatch({ type: ActionTypes$1.NavigateTo, payload: url });
+    }
+    return (React__default["default"].createElement("section", null,
+        React__default["default"].createElement(StyledTypeHeader, null,
+            React__default["default"].createElement(StyledInfoWrapper, null,
+                typeInformation[type].icon,
+                React__default["default"].createElement(StyledTypeName, null, typeInformation[type].name)),
+            (keyword.trim().length <= SEARCH_KEYWORD_MIN_LENGTH$1[locale] ||
+                isMalay) && (React__default["default"].createElement(StyledSeeMoreButton, { onClick: onSeeAllClick },
+                React__default["default"].createElement(index$2.Text, { size: "p3", color: theme.theme.colors.primaryBase }, t('booking.searchPopup.seeAll'))))),
+        (isLoading || (data && data.length > 0)) && (React__default["default"].createElement(StyledResultsContainer, null,
+            React__default["default"].createElement(StyledItemsWrapper, null,
+                isLoading &&
+                    Array(2)
+                        .fill(undefined)
+                        .map((_, i) => (React__default["default"].createElement(StyledResult, { key: type + 'loading' + i },
+                        React__default["default"].createElement(StyledPictureWrapper, null,
+                            React__default["default"].createElement(StyledImageSkeletonWrapper, null,
+                                React__default["default"].createElement(Skeleton__default["default"], { height: 14, width: type === 'hospitals' ? 12 : 32, style: {
+                                        maxWidth: 'var(--graphicSize)',
+                                        minHeight: 'var(--graphicSize)',
+                                    } }))),
+                        React__default["default"].createElement(Skeleton__default["default"], { width: 120, height: 24 })))),
+                !isLoading &&
+                    data &&
+                    data.length > 0 &&
+                    data.slice(0, showItemCount).map(renderItem)),
+            React__default["default"].createElement(StyledItemsWrapper, { isShown: seeMoreOpen, isMore: true }, data.slice(showItemCount, -1).map(renderItem)),
+            type === 'specialties' &&
+                showItemCount < data.length &&
+                !isLoading && (React__default["default"].createElement("button", { onClick: () => setSeeMoreOpen(!seeMoreOpen) },
+                React__default["default"].createElement(StyledSeeMore, { size: "p3", color: theme.theme.colors.primaryBase }, seeMoreOpen
+                    ? t('booking.searchPopup.seeLessSpecialties')
+                    : t('booking.searchPopup.seeMoreSpecialties')))),
+            type !== 'specialties' &&
+                (showItemCount < data.length || isMalay) &&
+                !isLoading &&
+                keyword.trim().length > SEARCH_KEYWORD_MIN_LENGTH$1[locale] && (React__default["default"].createElement("button", { onClick: onClickSearchByKeyword },
+                React__default["default"].createElement(StyledSeeMore, { size: "p3", color: theme.theme.colors.primaryBase }, t(`booking.searchPopup.searchIn.${type}`, {
+                    name: keyword,
+                })))))),
+        !isLoading && (data === null || data === void 0 ? void 0 : data.length) === 0 && (React__default["default"].createElement(StyledResultsContainer, null,
+            React__default["default"].createElement(index$2.Text, { size: "sm", color: theme.theme.colors.gray400 }, t('booking.searchBar.noResults'))))));
+};
+
+const StyledSection = styled__default["default"].section `
+  background-color: white;
+  border-radius: 4px;
+  position: absolute;
+  width: 100%;
+  z-index: 30;
+
+  ${utils.MediaQueries.tdUp} {
+    box-shadow: 0px 24px 32px rgba(0, 0, 0, 0.04),
+      0px 16px 24px rgba(0, 0, 0, 0.04), 0px 4px 8px rgba(0, 0, 0, 0.04),
+      0px 0px 1px rgba(0, 0, 0, 0.04);
+  }
+`;
+const SearchResults = ({ data, state, dispatch, isMobile, isLoading, keyword, hideResults, isNavResultItem, }) => {
+    return (React__default["default"].createElement(StyledSection, null, data &&
+        data.map((data) => {
+            if (hideResults && hideResults.includes(data.type)) {
+                return React__default["default"].createElement(React__default["default"].Fragment, null);
+            }
+            return (React__default["default"].createElement(ResultSection, { type: data.type, state: state, dispatch: dispatch, itemsToShow: 2, itemsToShowDesktop: 4, key: data.type, data: data.results, isMobile: isMobile, isLoading: isLoading, keyword: keyword, isNavResultItem: isNavResultItem }));
+        })));
+};
+
+const getApiPath = (path, params, locale) => {
+    return formatString__default["default"](path, Object.assign(Object.assign({}, params), { domain: index.domainLocales[locale || 'en-PH'] }));
+};
+
+function useSearchBarApi$1({ dispatch, careApiDomain, locale = 'vi-VN', }) {
+    const fetchCitiesApi = React.useCallback(function fetchCitiesApi(path, params = {}) {
+        const url = `${careApiDomain}${path}`;
+        dispatch({ type: ActionTypes$1.FetchCitiesStart });
+        return fetch(getApiPath(url, params, locale), { method: 'GET' })
+            .then((res) => res.json())
+            .then((data) => {
+            if (data._status !== 1 || !data._data) {
+                console.log('error loading cities', data);
+                return Promise.reject(data);
+            }
+            return data === null || data === void 0 ? void 0 : data._data;
+        })
+            .finally(() => dispatch({ type: ActionTypes$1.FetchCitiesFinish }));
+    }, [locale]);
+    const fetchCitiesByLocation = React.useCallback(function fetchCitiesByLocation({ coordinates }) {
+        let params = {};
+        const moreParams = {};
+        if (coordinates) {
+            params = {
+                lat: coordinates.lat,
+                lng: coordinates.lng,
+            };
+        }
+        if (locale === 'ms-MY') {
+            moreParams.noPaging = 1;
+        }
+        const requests = [
+            fetchCitiesApi(paths.PATHS.GET_CITY_BY_IP, Object.assign(Object.assign({}, params), moreParams)),
+        ];
+        if (locale === 'zh-TW') {
+            requests.push(fetchCitiesApi(paths.PATHS.GET_CITIES_LIST, { noPaging: 1 }));
+        }
+        return Promise.all(requests)
+            .then(([data1, data2]) => {
+            const data = Object.assign({}, data1);
+            if (data2) {
+                const citiesIds = data.cities.map((c) => c.id);
+                data.cities = data.cities.concat(data2.cities.filter((c) => !citiesIds.includes(c.id)));
+            }
+            dispatch({
+                type: ActionTypes$1.FetchCitiesByGeoIpComplete,
+                payload: data,
+            });
+        })
+            .catch((err) => console.error('error loading cities by location', err));
+    }, [locale, careApiDomain, dispatch]);
+    const fetchCitiesByKeyword = React.useCallback(function fetchCitiesByKeyword(keyword) {
+        return fetchCitiesApi(paths.PATHS.GET_CITIES_LIST, { keyword })
+            .then((data) => {
+            dispatch({
+                type: ActionTypes$1.FetchCitiesByKeywordComplete,
+                payload: data.cities,
+            });
+        })
+            .catch((err) => console.error('error loading cities by keyword', err));
+    }, [locale, careApiDomain, dispatch]);
+    const fetchSearchResults = React.useCallback(function fetchSearchResults(searchKeywords, state) {
+        const url = `${careApiDomain}${paths.PATHS.GET_SEARCH_V2}`;
+        dispatch({ type: ActionTypes$1.FetchSearchResultsStart });
+        const { defaultCity, selectedLocation, geoLocationCoordinates } = state;
+        let cityId = '';
+        if (!selectedLocation || !defaultCity) {
+            dispatch({ type: ActionTypes$1.FetchSearchResultsFinish });
+            return;
+        }
+        const isCurrentLocationSelected = selectedLocation.id === constants.ID_OPTION_CURRENT_LOCATION;
+        if (isCurrentLocationSelected) {
+            if (!geoLocationCoordinates) {
+                cityId = defaultCity.id;
+            }
+        }
+        else if (selectedLocation.id === constants.ID_OPTION_ALL_LOCATION) {
+            cityId = '';
+        }
+        else {
+            cityId = selectedLocation.id;
+        }
+        const lat = (geoLocationCoordinates === null || geoLocationCoordinates === void 0 ? void 0 : geoLocationCoordinates.lat) || '';
+        const lng = (geoLocationCoordinates === null || geoLocationCoordinates === void 0 ? void 0 : geoLocationCoordinates.lng) || '';
+        return fetch(getApiPath(url, {
+            domain: careApiDomain,
+            searchType: 'global',
+            keyword: searchKeywords.trim().length > SEARCH_KEYWORD_MIN_LENGTH$1[locale]
+                ? searchKeywords.trim()
+                : '',
+            city: cityId === constants.ID_OPTION_CURRENT_LOCATION ? '' : cityId,
+            lat,
+            lng,
+        }, locale), {
+            method: 'GET',
+            headers: {
+                accept: 'version=2.0.0.0',
+            },
+        })
+            .then((res) => res.json())
+            .then((data) => {
+            if (data._status !== 1 || !data._data) {
+                return Promise.reject(data);
+            }
+            return data === null || data === void 0 ? void 0 : data._data;
+        })
+            .then((results) => dispatch({
+            type: ActionTypes$1.FetchSearchResultsComplete,
+            payload: results,
+        }))
+            .catch((error) => {
+            console.log('error loading search results', { url, error });
+        })
+            .finally(() => dispatch({ type: ActionTypes$1.FetchSearchResultsFinish }));
+    }, [locale, careApiDomain, dispatch]);
+    return {
+        fetchCitiesByLocation,
+        fetchCitiesByKeyword,
+        fetchSearchResults,
+    };
+}
+
+const BookingSearchBar = ({ isMobile, careApiDomain, geoLocationPermission: geoLocationPermissionFromProps, geoLocationCoordinates: geoLocationCoordinatesFromProps, initialSelectedCity: initialSelectedCityFromProps, initialSearchValue = '', careFrontDomain = '/care', isDebug = false, askForGeolocationPermission = false, gaTrackingSearchBar, gaTrackingLocationSearch, autoCompleteDisabled = false, inputSearchPlaceholder = '', isOptionAllLocation = false, hideResults = [], isNavResultItem = true, routerPush, onGeoLocationPermissionChange, onSearch, onChangeLocation, }) => {
+    const { t, locale } = useTranslations.useTranslations();
+    const wrapperRef = React.useRef(null);
+    const hiddenInputRef = React.useRef(null);
+    const [viewportHeight, setViewportHeight] = React.useState(undefined);
+    const [isNavResultPage, setIsNavResultPage] = React.useState(false);
+    const { geoLocationPermission: geoLocationPermissionFromHook, geoLocationCoordinates: geoLocationCoordinatesFromHook, requestGeoLocation, } = useGeolocation();
+    const [state, dispatch] = React.useReducer(reducer$1, initialState$1, (s) => (Object.assign(Object.assign({}, s), { isDebug,
+        isMobile, geoLocationPermission: geoLocationPermissionFromProps ||
+            geoLocationPermissionFromHook ||
+            'unset', geoLocationCoordinates: geoLocationCoordinatesFromProps ||
+            geoLocationCoordinatesFromHook ||
+            null, searchKeywords: initialSearchValue, initialSelectedCity: initialSelectedCityFromProps || null, selectedLocation: initialSelectedCityFromProps || s.selectedLocation || null, searchLocationKeywords: (initialSelectedCityFromProps === null || initialSelectedCityFromProps === void 0 ? void 0 : initialSelectedCityFromProps.name) || s.searchLocationKeywords, autoCompleteDisabled,
+        inputSearchPlaceholder,
+        locale })));
+    const { navigateTo, focused, isLoadingCities, cities, searchKeywords, geoLocationPermission, selectedLocation, initialSelectedCity, defaultCity, searchResults, isLoadingSearchResults, isMobileModalOpened, inputSearchPlaceholder: inputSearchPlaceholderState, } = state;
+    const { fetchCitiesByLocation, fetchCitiesByKeyword, fetchSearchResults } = useSearchBarApi$1({
+        dispatch,
+        locale,
+        careApiDomain,
+    });
+    const currentLocationCityItem = React.useMemo(() => {
+        var _a;
+        return ({
+            id: constants.ID_OPTION_CURRENT_LOCATION,
+            name: t('booking.searchBar.currentLocation'),
+            slug: (_a = constants.LOCALIZED_SLUGS[locale]) === null || _a === void 0 ? void 0 : _a.CURRENT,
+        });
+    }, [t, locale]);
+    const debouncedFetchCitiesByKeyword = React.useMemo(() => debounce__default["default"](fetchCitiesByKeyword, 400), [fetchCitiesByKeyword]);
+    const debouncedFetchSearchResults = React.useMemo(() => debounce__default["default"](fetchSearchResults, 400), [fetchSearchResults]);
+    React.useEffect(() => {
+        if (initialSearchValue !== '' &&
+            initialSearchValue !== state.searchKeywords) {
+            dispatch({
+                type: ActionTypes$1.UpdateInitialSearchValue,
+                payload: initialSearchValue,
+            });
+        }
+    }, [initialSearchValue]);
+    React.useEffect(() => {
+        if (askForGeolocationPermission &&
+            (selectedLocation === null || selectedLocation === void 0 ? void 0 : selectedLocation.id) === constants.ID_OPTION_CURRENT_LOCATION &&
+            geoLocationPermission === 'unset') {
+            requestGeoLocation();
+        }
+    }, [askForGeolocationPermission, selectedLocation, geoLocationPermission]);
+    React.useEffect(() => {
+        if (!geoLocationPermissionFromProps &&
+            geoLocationPermission !== geoLocationPermissionFromHook) {
+            if (geoLocationPermissionFromHook === 'granted' &&
+                geoLocationCoordinatesFromHook) {
+                dispatch({
+                    type: ActionTypes$1.GrantGeoLocationPermission,
+                    payload: geoLocationCoordinatesFromHook,
+                });
+            }
+            else if (geoLocationPermissionFromHook === 'denied') {
+                dispatch({ type: ActionTypes$1.DenyGeoLocationPermission });
+            }
+        }
+    }, [
+        geoLocationPermission,
+        geoLocationPermissionFromHook,
+        geoLocationCoordinatesFromHook,
+        geoLocationPermissionFromProps,
+    ]);
+    React.useEffect(() => {
+        if (navigateTo) {
+            if (routerPush) {
+                routerPush(navigateTo);
+            }
+            else {
+                window.location.href = `${careFrontDomain}${navigateTo}`;
+            }
+        }
+    }, [navigateTo]);
+    const selectCurrentLocation = React.useCallback(function selectCurrentLocation() {
+        dispatch({
+            type: ActionTypes$1.SelectCurrentLocation,
+            payload: currentLocationCityItem,
+        });
+    }, [t, dispatch]);
+    React.useEffect(() => {
+        var _a;
+        if (geoLocationPermission !== 'denied' && !initialSelectedCity) {
+            dispatch({
+                type: ActionTypes$1.SelectLocation,
+                payload: {
+                    name: t('booking.searchBar.allLocations'),
+                    id: constants.ID_OPTION_ALL_LOCATION,
+                    slug: (_a = constants.LOCALIZED_SLUGS[locale]) === null || _a === void 0 ? void 0 : _a.ALL,
+                },
+            });
+        }
+        if (onGeoLocationPermissionChange) {
+            onGeoLocationPermissionChange(geoLocationPermission, state.geoLocationCoordinates);
+        }
+        if (isMobile && geoLocationPermission === 'granted' && selectedLocation) {
+            dispatch({ type: ActionTypes$1.FocusInputSearch });
+        }
+        fetchCitiesByLocation({ coordinates: state.geoLocationCoordinates });
+    }, [geoLocationPermission]);
+    React.useEffect(() => {
+        if (selectedLocation && defaultCity) {
+            fetchSearchResults(state.searchKeywords, state);
+        }
+    }, [selectedLocation, defaultCity]);
+    React.useEffect(() => {
+        if (inputSearchPlaceholder !== inputSearchPlaceholderState) {
+            dispatch({
+                type: ActionTypes$1.SetInputSearchPlaceholder,
+                payload: inputSearchPlaceholder,
+            });
+        }
+    }, [inputSearchPlaceholder, inputSearchPlaceholderState]);
+    React.useEffect(() => {
+        if (isMobileModalOpened) {
+            document.body.classList.add('care-popup-open');
+        }
+        else {
+            document.body.classList.remove('care-popup-open');
+        }
+    }, [isMobileModalOpened]);
+    const handleLocationClick = React.useCallback(function handleLocationClick(city) {
+        if (locale === 'ms-MY') {
+            setIsNavResultPage(true);
+        }
+        dispatch({ type: ActionTypes$1.SelectLocation, payload: city });
+        if (locale !== 'ms-MY') {
+            focusSearchInput();
+        }
+        if (onChangeLocation) {
+            onChangeLocation(city);
+        }
+    }, [t, dispatch]);
+    function handleCurrentLocationClick() {
+        if (locale === 'ms-MY') {
+            setIsNavResultPage(true);
+        }
+        if (isMobile && state.geoLocationPermission !== 'granted') {
+            requestGeoLocation();
+        }
+        else {
+            selectCurrentLocation();
+            if (locale !== 'ms-MY') {
+                focusSearchInput();
+            }
+        }
+    }
+    function handleMobileFakeInputClick() {
+        var _a;
+        return tslib_es6.__awaiter(this, void 0, void 0, function* () {
+            if (hiddenInputRef.current) {
+                hiddenInputRef.current.focus();
+            }
+            dispatch({ type: ActionTypes$1.OpenMobileModal });
+            yield Promise.resolve();
+            if (wrapperRef.current) {
+                (_a = wrapperRef.current
+                    .querySelector('input[name="search-location"]')) === null || _a === void 0 ? void 0 : _a.focus();
+            }
+        });
+    }
+    function focusLocationInput() {
+        var _a;
+        if (wrapperRef.current) {
+            (_a = wrapperRef.current
+                .querySelector('input[name="search-location"]')) === null || _a === void 0 ? void 0 : _a.focus();
+        }
+    }
+    function focusSearchInput() {
+        var _a;
+        if (wrapperRef.current) {
+            (_a = wrapperRef.current
+                .querySelector('input[name="search-results"]')) === null || _a === void 0 ? void 0 : _a.focus();
+        }
+    }
+    function handleMobileTopBarClose() {
+        dispatch({ type: ActionTypes$1.CloseMobileModal });
+    }
+    function renderLocationResults() {
+        if (focused !== 'location') {
+            return null;
+        }
+        return (React__default["default"].createElement(LocationResults, { isLoading: isLoadingCities, cities: cities, onLocationClick: handleLocationClick, onCurrentLocationClick: handleCurrentLocationClick, isLocationLoading: isLoadingCities, geoLocationPermission: geoLocationPermission, selectedLocation: selectedLocation, isOptionAllLocation: isOptionAllLocation }));
+    }
+    function renderSearchResults() {
+        if (focused !== 'search') {
+            return null;
+        }
+        if (state.autoCompleteDisabled) {
+            if (!isMobile) {
+                return null;
+            }
+            return (React__default["default"].createElement(SearchButton, { onClick: () => {
+                    onSearch({
+                        cityId: state.selectedLocation.id,
+                        keyword: searchKeywords,
+                    });
+                    handleMobileTopBarClose();
+                } }));
+        }
+        return (React__default["default"].createElement(SearchResults, { data: searchResults, state: state, dispatch: dispatch, isMobile: false, keyword: searchKeywords, isLoading: isLoadingSearchResults, hideResults: hideResults, isNavResultItem: isNavResultItem }));
+    }
+    function renderSearchInputs() {
+        return (React__default["default"].createElement(SearchInputs$1, { isMobile: isMobile, state: state, dispatch: dispatch, debouncedFetchCitiesByKeyword: debouncedFetchCitiesByKeyword, debouncedFetchSearchResults: debouncedFetchSearchResults, focusLocationInput: focusLocationInput, focusSearchInput: focusSearchInput, renderLocationResults: renderLocationResults, renderSearchResults: renderSearchResults, trackingAttributes: gaTrackingSearchBar, locationTrackingAttributes: gaTrackingLocationSearch, onSearch: onSearch, initalSearchValue: initialSearchValue }));
+    }
+    React.useEffect(() => {
+        if (window.visualViewport) {
+            const resizeHandler = (evt) => {
+                const viewport = evt.target;
+                setViewportHeight(viewport === null || viewport === void 0 ? void 0 : viewport.height);
+            };
+            window.visualViewport.addEventListener('resize', resizeHandler, {
+                passive: true,
+            });
+            return () => {
+                window.visualViewport.removeEventListener('resize', resizeHandler);
+            };
+        }
+    }, [setViewportHeight]);
+    React.useEffect(() => {
+        // Apply for ms-MY. Navigation to result page after selected location
+        if (selectedLocation && isNavResultPage && locale === 'ms-MY') {
+            const url = `/${selectedLocation.slug}/hospital`;
+            dispatch({ type: ActionTypes$1.NavigateTo, payload: url });
+            setIsNavResultPage(false);
+        }
+    }, [isNavResultPage, locale, selectedLocation]);
+    if (isMobile) {
+        return (React__default["default"].createElement(React__default["default"].Fragment, null,
+            React__default["default"].createElement(CareSearchGlobalStyles, null),
+            React__default["default"].createElement(StyledHiddenInputMobile, { ref: hiddenInputRef }),
+            React__default["default"].createElement(StyledSearchBarMobileWrapper, { id: "booking-search-bar", ref: wrapperRef, "data-is-modal": isMobile && isMobileModalOpened, style: {
+                    '--mobile-care-searchbar-height': isMobileModalOpened && viewportHeight
+                        ? `${viewportHeight}px`
+                        : '100%',
+                } }, !isMobileModalOpened ? (React__default["default"].createElement(MobileFakeInput, { onClick: handleMobileFakeInputClick, focused: focused, value: searchKeywords, trackingAttributes: gaTrackingSearchBar, inputSearchPlaceholder: inputSearchPlaceholder })) : (React__default["default"].createElement(React__default["default"].Fragment, null,
+                React__default["default"].createElement(StyledSearchBarMobileModalHeader, null,
+                    React__default["default"].createElement(MobileTopBar, { headingText: t('booking.searchBar.searchButton'), onLeftClick: handleMobileTopBarClose }),
+                    renderSearchInputs()),
+                renderLocationResults(),
+                renderSearchResults())))));
+    }
+    return (React__default["default"].createElement(StyledSearchBarWrapper$1, { id: "booking-search-bar", ref: wrapperRef }, renderSearchInputs()));
+};
+
+const StyledSearchBarWrapper = styled__default["default"].div ``;
+const StyleWrapperContainer = styled__default["default"].div `
+  background-color: ${theme.theme.colors.neutral50};
+  padding-bottom: 1px;
+  ${utils.MediaQueries.mbDown} {
+    padding: 0 16px 10px;
+  }
+`;
+const StyleSearchInputContainer = styled__default["default"](index$3.Container) `
+  padding: 0 16px;
+
+  ${utils.MediaQueries.mbDown} {
+    padding: 0;
+  }
+`;
+const StyleSearchContent = styled__default["default"].div `
+  padding: 24px 56px;
+  border-radius: 0px 0px 16px 16px;
+  background-color: ${theme.theme.colors.white};
+  box-shadow: 0px 0px 1px 0px rgba(0, 0, 0, 0.04),
+    0px 0px 2px 0px rgba(0, 0, 0, 0.06), 0px 4px 8px 0px rgba(0, 0, 0, 0.04);
+
+  ${utils.MediaQueries.mbDown} {
+    padding: 16px 16px;
+    border-radius: 0px 0px 12px 12px;
+  }
+
+  .flex-search-input {
+    flex-direction: row;
+    ${utils.MediaQueries.mbDown} {
+      flex-direction: column;
+    }
+  }
+`;
+
+const SEARCH_KEYWORD_MIN_LENGTH = {
+    'en-PH': 3,
+    'tl-PH': 2,
+    'id-ID': 3,
+    'vi-VN': 2,
+    'zh-TW': 0,
+    'ms-MY': 2,
+};
+
+const initialState = {
+    isMobile: false,
+    isDebug: false,
+    navigateTo: null,
+    geoLocationPermission: 'unset',
+    geoLocationCoordinates: null,
+    focused: 'none',
+    focusedSpecialty: 'none',
+    searchLocationKeywords: '',
+    searchSpecialtyKeywords: '',
+    searchKeywords: '',
+    selectedLocation: null,
+    selectedSpecialty: null,
+    defaultCity: null,
+    initialCities: [],
+    cities: [],
+    searchResults: {},
+    initialSearchResults: {},
+    isLoadingCities: false,
+    isLoadingSearchResults: false,
+    isMobileModalOpened: false,
+    initialSelectedCity: null,
+    autoCompleteDisabled: false,
+    inputSearchPlaceholder: '',
+    locale: 'vi-VN',
+    allSpecialties: [],
+    popularKeys: [],
+};
+var ActionTypes;
+(function (ActionTypes) {
+    ActionTypes["NavigateTo"] = "navigate to url";
+    ActionTypes["ClickOutsideInputLocation"] = "click outside input location";
+    ActionTypes["ClickOutsideInputSearch"] = "click outside input search";
+    ActionTypes["ClickOutsideInputSearchSpecialty"] = "click outside input search specialty";
+    ActionTypes["ClickOutsideInputSpecialty"] = "click outside input specialty";
+    ActionTypes["SelectCurrentLocation"] = "select current location";
+    ActionTypes["FocusInputLocation"] = "focus input location";
+    ActionTypes["FocusInputSearch"] = "focus input search";
+    ActionTypes["FocusInputSearchSpecialty"] = "focus input search specialty";
+    ActionTypes["ChangeInputLocation"] = "change input location";
+    ActionTypes["ChangeInputSearch"] = "change input search";
+    ActionTypes["ClearInputLocation"] = "clear input location";
+    ActionTypes["ClearInputSearch"] = "clear input search";
+    ActionTypes["SelectLocation"] = "select location";
+    ActionTypes["SelectSpecialty"] = "select specialty";
+    ActionTypes["FetchCitiesStart"] = "fetch cities start";
+    ActionTypes["FetchCitiesFinish"] = "fetch cities finish";
+    ActionTypes["FetchSearchResultsStart"] = "fetch search results start";
+    ActionTypes["FetchSearchResultsComplete"] = "fetch search results complete";
+    ActionTypes["FetchSearchResultsFinish"] = "fetch search results finish";
+    ActionTypes["FetchCitiesByGeoIpComplete"] = "fetch cities by geo IP finish";
+    ActionTypes["FetchCitiesByKeywordComplete"] = "fetch cities by keyword finish";
+    ActionTypes["DisplayInitialCities"] = "display initial cities";
+    ActionTypes["DisplayInitialSearchResults"] = "display initial search results";
+    ActionTypes["UpdateInitialSearchResults"] = "update initial search results";
+    ActionTypes["GrantGeoLocationPermission"] = "grant geolocation permission";
+    ActionTypes["DenyGeoLocationPermission"] = "deny geolocation permission";
+    ActionTypes["OpenMobileModal"] = "open mobile modal";
+    ActionTypes["CloseMobileModal"] = "close mobile modal";
+    ActionTypes["UpdateInitialSearchValue"] = "update initial search value";
+    ActionTypes["SelectSearchResult"] = "select search result";
+    ActionTypes["SetInputSearchPlaceholder"] = "set input search placeholder";
+    ActionTypes["FocusInputSpecialty"] = "focus input specialty";
+    ActionTypes["FetchAllSpecialties"] = "fetch all specialty";
+    ActionTypes["FetchPopularKeys"] = "fetch popular key by type";
+})(ActionTypes || (ActionTypes = {}));
+function resetSearchLocationKeywords(state) {
+    const { selectedLocation, searchLocationKeywords } = state;
+    if (selectedLocation && searchLocationKeywords !== selectedLocation.name) {
+        return Object.assign(Object.assign({}, state), { searchLocationKeywords: selectedLocation.name });
+    }
+    return state;
+}
+function reducer(state, action) {
+    var _a, _b;
+    if (state.isDebug) {
+        console.log('bookingSearchBar', { action, state });
+    }
+    switch (action.type) {
+        case ActionTypes.NavigateTo:
+            return Object.assign(Object.assign({}, state), { navigateTo: action.payload, focused: 'none', isMobileModalOpened: false });
+        case ActionTypes.ClickOutsideInputLocation: {
+            if (state.focused !== 'location') {
+                return state;
+            }
+            return resetSearchLocationKeywords(Object.assign(Object.assign({}, state), { focused: 'none' }));
+        }
+        case ActionTypes.ClickOutsideInputSpecialty: {
+            if (state.focused !== 'specialty') {
+                return state;
+            }
+            return resetSearchLocationKeywords(Object.assign(Object.assign({}, state), { focused: 'none' }));
+        }
+        case ActionTypes.ClickOutsideInputSearch: {
+            if (state.focused !== 'search') {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { focused: 'none' });
+        }
+        case ActionTypes.ClickOutsideInputSearchSpecialty: {
+            if (state.focusedSpecialty !== 'search') {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { focusedSpecialty: 'none' });
+        }
+        case ActionTypes.FocusInputLocation: {
+            const nextState = Object.assign(Object.assign({}, state), { focused: 'location' });
+            if (((_a = state.selectedLocation) === null || _a === void 0 ? void 0 : _a.id) === constants.ID_OPTION_CURRENT_LOCATION) {
+                nextState.searchLocationKeywords = '';
+            }
+            return nextState;
+        }
+        case ActionTypes.FocusInputSpecialty: {
+            const nextState = Object.assign(Object.assign({}, state), { focused: 'specialty' });
+            if (((_b = state.selectedLocation) === null || _b === void 0 ? void 0 : _b.id) === constants.ID_OPTION_CURRENT_LOCATION) {
+                nextState.searchLocationKeywords = '';
+            }
+            return nextState;
+        }
+        case ActionTypes.FocusInputSearch:
+            const nextState = Object.assign(Object.assign({}, state), { focused: 'search' });
+            if (state.isMobile) {
+                return resetSearchLocationKeywords(nextState);
+            }
+            return nextState;
+        case ActionTypes.FocusInputSearchSpecialty: {
+            const nextState = Object.assign(Object.assign({}, state), { focusedSpecialty: 'search' });
+            return nextState;
+        }
+        case ActionTypes.ChangeInputLocation:
+            return Object.assign(Object.assign({}, state), { searchLocationKeywords: action.payload });
+        case ActionTypes.ChangeInputSearch: {
+            const keyword = action.payload;
+            return Object.assign(Object.assign({}, state), { searchKeywords: keyword, isLoadingSearchResults: keyword.trim().length > SEARCH_KEYWORD_MIN_LENGTH[state.locale] });
+        }
+        case ActionTypes.SelectCurrentLocation:
+            return Object.assign(Object.assign({}, state), { focused: 'none', selectedLocation: action.payload, searchLocationKeywords: action.payload.name });
+        case ActionTypes.ClearInputLocation:
+            return Object.assign(Object.assign({}, state), { focused: 'location', cities: state.initialCities, searchLocationKeywords: '' });
+        case ActionTypes.ClearInputSearch:
+            return Object.assign(Object.assign({}, state), { focused: 'search', searchKeywords: '' });
+        case ActionTypes.SelectLocation:
+            return Object.assign(Object.assign({}, state), { focused: 'none', selectedLocation: action.payload, searchLocationKeywords: action.payload.name });
+        case ActionTypes.SelectSpecialty:
+            return Object.assign(Object.assign({}, state), { focused: 'none', selectedSpecialty: action.payload });
+        case ActionTypes.SelectSearchResult:
+            return Object.assign(Object.assign({}, state), { searchKeywords: action.payload.name, isMobileModalOpened: false, focused: 'none', navigateTo: action.payload.url });
+        case ActionTypes.FetchCitiesStart:
+            return Object.assign(Object.assign({}, state), { isLoadingCities: true });
+        case ActionTypes.FetchCitiesFinish:
+            return Object.assign(Object.assign({}, state), { isLoadingCities: false });
+        case ActionTypes.FetchSearchResultsStart:
+            return Object.assign(Object.assign({}, state), { isLoadingSearchResults: true });
+        case ActionTypes.FetchSearchResultsFinish:
+            return Object.assign(Object.assign({}, state), { isLoadingSearchResults: false });
+        case ActionTypes.FetchSearchResultsComplete: {
+            const nextState = Object.assign(Object.assign({}, state), { searchResults: Object.assign(Object.assign({}, state.searchResults), { [action.payload.key]: action.payload.searches }) });
+            return nextState;
+        }
+        case ActionTypes.FetchCitiesByGeoIpComplete: {
+            let { cities } = action.payload;
+            const { default: defaultCity } = action.payload;
+            cities = cities.filter((c) => c.id !== defaultCity.id);
+            if (defaultCity) {
+                cities.unshift(defaultCity);
+            }
+            if (state.initialSelectedCity &&
+                !cities.find((c) => c.id === state.initialSelectedCity.id)) {
+                cities.unshift(state.initialSelectedCity);
+            }
+            const nextState = Object.assign(Object.assign({}, state), { defaultCity, initialCities: cities, cities });
+            if (state.geoLocationPermission === 'denied' &&
+                !state.initialSelectedCity) {
+                nextState.selectedLocation = defaultCity;
+                nextState.searchLocationKeywords = defaultCity.name;
+            }
+            return nextState;
+        }
+        case ActionTypes.FetchCitiesByKeywordComplete:
+            return Object.assign(Object.assign({}, state), { cities: action.payload });
+        case ActionTypes.DisplayInitialCities:
+            return Object.assign(Object.assign({}, state), { cities: state.initialCities });
+        case ActionTypes.DisplayInitialSearchResults:
+            return Object.assign(Object.assign({}, state), { searchResults: state.initialSearchResults, isLoadingSearchResults: false });
+        case ActionTypes.UpdateInitialSearchResults:
+            return Object.assign(Object.assign({}, state), { initialSearchResults: Object.assign(Object.assign({}, state.initialSearchResults), { [action.payload.key]: action.payload.searches }) });
+        case ActionTypes.GrantGeoLocationPermission:
+            return Object.assign(Object.assign({}, state), { geoLocationPermission: 'granted', geoLocationCoordinates: action.payload });
+        case ActionTypes.DenyGeoLocationPermission:
+            return Object.assign(Object.assign({}, state), { geoLocationPermission: 'denied', geoLocationCoordinates: null });
+        case ActionTypes.OpenMobileModal:
+            return Object.assign(Object.assign({}, state), { isMobileModalOpened: true });
+        case ActionTypes.CloseMobileModal:
+            return Object.assign(Object.assign({}, state), { isMobileModalOpened: false });
+        case ActionTypes.UpdateInitialSearchValue:
+            return Object.assign(Object.assign({}, state), { searchKeywords: action.payload });
+        case ActionTypes.SetInputSearchPlaceholder:
+            return Object.assign(Object.assign({}, state), { inputSearchPlaceholder: action.payload });
+        case ActionTypes.FetchAllSpecialties:
+            return Object.assign(Object.assign({}, state), { allSpecialties: action.payload });
+        case ActionTypes.FetchPopularKeys:
+            return Object.assign(Object.assign({}, state), { popularKeys: action.payload });
+        default:
+            return state;
+    }
+}
+
+const StyleSearchInputsWrapper = styled__default["default"].div `
+  flex: 1;
+  position: relative;
+
+  ${utils.MediaQueries.mbDown} {
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+  }
+`;
+const StyleResultWrapper$2 = styled__default["default"].div `
+  position: absolute;
+  top: calc(100% + 2px);
+  width: 100%;
+  border-radius: 4px;
+  background: ${theme.theme.colors.white};
+  box-shadow: 0px 8px 40px 0px rgba(0, 0, 0, 0.1);
+  z-index: 10;
+
+  ${utils.MediaQueries.mbDown} {
+    width: calc(100% + 64px);
+    left: -32px;
+  }
+`;
+
+const StyledSearchResultWrapper = styled__default["default"].div ``;
+const StyleResultHeader = styled__default["default"].div `
+  display: flex;
+  justify-content: space-between;
+  align-item: center;
+  padding: 9px 14px 9px 22px;
+  background: #f7f9fc;
+
+  .title {
+    color: ${theme.theme.colors.gray800};
+    font-size: 14px;
+    font-weight: 600;
+    line-height: 22px;
+  }
+
+  .btn-see-all {
+    color: ${theme.theme.colors.blue600};
+    font-size: 14px;
+    line-height: 22px;
+    cursor: pointer;
+  }
+`;
+const StyleResultBody = styled__default["default"].div `
+  padding: 10px 16px;
+  max-height: 400px;
+  overflow: auto;
+`;
+const StyleResultItem = styled__default["default"].div `
+  display: flex;
+  gap: 12px;
+  align-items: center;
+  cursor: pointer;
+
+  &:hover {
+    background-color: ${theme.theme.colors.blue50};
+  }
+  .image-item {
+    flex: 0 0 48px;
+    width: 48px;
+    height: 48px;
+    border-radius: 50%;
+
+    img {
+      object-fit: contain;
+      width: 100%;
+      height: 100%;
+      border-radius: 50%;
+    }
+  }
+  .infor {
+    overflow: hidden;
+    padding: 12px 0;
+    flex: 1;
+    border-bottom: 1px solid ${theme.theme.colors.neutral100};
+    .title {
+      color: ${theme.theme.colors.gray800};
+      font-size: 16px;
+      font-weight: 600;
+      line-height: 24px;
+    }
+    .description {
+      overflow: hidden;
+      color: ${theme.theme.colors.gray600};
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      font-size: 12px;
+      line-height: 18px;
+      display: flex;
+      gap: 8px;
+      align-items: center;
+      margin-top: 5px;
+
+      svg {
+        flex: 0 0 16px;
+      }
+
+      .sub-description {
+        overflow: hidden;
+        white-space: nowrap;
+        text-overflow: ellipsis;
+        flex: 1;
+      }
+    }
+  }
+
+  &.last-item {
+    .infor {
+      border-bottom: none;
+    }
+  }
+`;
+styled__default["default"].div `
+  padding: 0 16px 16px;
+
+  .search-detail-btn {
+    color: ${theme.theme.colors.blue600};
+    font-size: 14px;
+    line-height: 22px;
+    cursor: pointer;
+  }
+`;
+
+const SearchResult = ({ state, type, results, location, isLoading, typeInformation, clientSlug = '', dispatch, }) => {
+    const { locale, t } = useTranslations.useTranslations();
+    const { selectedLocation } = state;
+    const typeSlug = React.useMemo(() => typeInformation[type].slug, [typeInformation, type]);
+    const handleOnClick = (item) => {
+        let url = '';
+        switch (type) {
+            case 'service':
+                url = `/${selectedLocation.slug}/${typeSlug}/${item.slug}`;
+                break;
+            case 'doctor':
+            case 'hospital':
+                url = `/${typeSlug}/${item.slug}-${item.id}`;
+                break;
+        }
+        if (url) {
+            dispatch({
+                type: ActionTypes.NavigateTo,
+                payload: url,
+            });
+        }
+    };
+    const handleSeeAll = () => {
+        let url = `/${selectedLocation.slug}/${typeSlug}`;
+        const slugClientUrl = constants.MAPPING_CLIENT_WITH_SLUG[locale][clientSlug];
+        if (slugClientUrl) {
+            url += `/${slugClientUrl}`;
+        }
+        if ((type === 'doctor' || type === 'hospital') &&
+            state.selectedSpecialty.id > 0) {
+            url += `?specialtyId=${state.selectedSpecialty.id}`;
+        }
+        if (url) {
+            dispatch({ type: ActionTypes.NavigateTo, payload: url });
+        }
+    };
+    return (React__default["default"].createElement(StyledSearchResultWrapper, null,
+        React__default["default"].createElement(StyleResultHeader, null,
+            React__default["default"].createElement("div", { className: "title" }, t('booking.searchResult.description', {
+                search_type: typeInformation[type].name,
+                search_location: location,
+            })),
+            results.length > 0 && (React__default["default"].createElement("div", { className: "btn-see-all", onClick: handleSeeAll }, t('home.seeAll')))),
+        React__default["default"].createElement(StyleResultBody, null,
+            isLoading &&
+                Array(3)
+                    .fill(undefined)
+                    .map((_, i) => (React__default["default"].createElement(StyleResultItem, { key: type + 'loading' + i, className: i === 2 ? 'last-item' : '' },
+                    React__default["default"].createElement("div", { className: "image-item" },
+                        React__default["default"].createElement(core.Skeleton, { height: 48, circle: true, mb: "xl", animate: true })),
+                    React__default["default"].createElement("div", { className: "infor" },
+                        React__default["default"].createElement("div", { className: "title" },
+                            React__default["default"].createElement(core.Skeleton, { height: 8, mt: 10, radius: "xl", animate: true })),
+                        React__default["default"].createElement("div", { className: "description" },
+                            React__default["default"].createElement("div", { className: "sub-description" },
+                                React__default["default"].createElement(core.Skeleton, { height: 8, mt: 10, radius: "xl", width: "80%", animate: true }))))))),
+            !isLoading && results && results.length > 0 && (React__default["default"].createElement(React__default["default"].Fragment, null, results.map((item, index) => {
+                var _a, _b;
+                const isLastItem = (results.length > 4 && index === 3) ||
+                    (results.length <= 4 && index === results.length - 1);
+                let subDescription = '';
+                if (type === 'hospital') {
+                    subDescription = (item === null || item === void 0 ? void 0 : item.address) || '';
+                }
+                if (type === 'doctor') {
+                    subDescription = ((_a = item === null || item === void 0 ? void 0 : item.specialties) === null || _a === void 0 ? void 0 : _a.join(', ')) || '';
+                }
+                if (type === 'service') {
+                    subDescription = ((_b = item === null || item === void 0 ? void 0 : item.hospital_branch) === null || _b === void 0 ? void 0 : _b.name) || '';
+                }
+                if (index >= 4) {
+                    return React__default["default"].createElement(React__default["default"].Fragment, null);
+                }
+                return (React__default["default"].createElement(StyleResultItem, { key: item.id, className: isLastItem ? 'last-item' : '', onClick: () => handleOnClick(item) },
+                    React__default["default"].createElement("div", { className: "image-item" },
+                        React__default["default"].createElement("img", { src: item.logo || item.avatar, alt: item.name })),
+                    React__default["default"].createElement("div", { className: "infor" },
+                        React__default["default"].createElement("div", { className: "title" }, item.name),
+                        React__default["default"].createElement("div", { className: "description" },
+                            typeInformation[type].icon,
+                            React__default["default"].createElement("div", { className: "sub-description" }, subDescription)))));
+            }))),
+            !isLoading && (results === null || results === void 0 ? void 0 : results.length) === 0 && (React__default["default"].createElement(index$2.Text, { size: "sm", color: theme.theme.colors.gray400 }, t('booking.searchBar.noResults'))))));
+};
+
+const StyleSearchSpecialtyWrapper = styled__default["default"].div `
+  position: relative;
+
+  ${utils.MediaQueries.mbDown} {
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+  }
+`;
+const StyleResultWrapper$1 = styled__default["default"].div `
+  position: absolute;
+  top: calc(100% + 2px);
+  width: calc(100% + 100px);
+  border-radius: 4px;
+  background: ${theme.theme.colors.white};
+  box-shadow: 0px 8px 40px 0px rgba(0, 0, 0, 0.1);
+  z-index: 10;
+  max-height: 300px;
+  overflow: auto;
+
+  ${utils.MediaQueries.mbDown} {
+    width: calc(100% + 64px);
+    left: -32px;
+  }
+`;
+const StyledSpecialtyItem = styled__default["default"].li `
+  position: relative;
+  cursor: pointer;
+  padding: 12px 18px;
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  overflow: hidden;
+
+  .image-item {
+    display: flex;
+    align-items: center;
+    width: 40px;
+    height: 40px;
+
+    img {
+      width: 100%;
+      object-fit: cover;
+    }
+
+    svg {
+      width: 40px;
+    }
+  }
+
+  ${({ isSelected }) => isSelected &&
+    `
+        &::after {
+            content: ${checkMarkIconUrl};
+            top: 50%;
+            right: 18px;
+            position: absolute;
+            transform: translateY(-50%);
+        }
+    `}
+
+  & + li::before {
+    content: '';
+    position: absolute;
+    left: 18px;
+    right: 18px;
+    top: 0;
+    height: 1px;
+    background-color: ${theme.theme.colors.neutral100};
+  }
+
+  &:not([data-is-denied='true']):hover {
+    background-color: ${theme.theme.colors.neutral50};
+  }
+
+  &:last-child:hover {
+    border-bottom-right-radius: 6px;
+    border-bottom-left-radius: 6px;
+  }
+
+  &:first-child:hover {
+    border-top-right-radius: 6px;
+    border-top-left-radius: 6px;
+  }
+
+  &[data-is-denied='true'] {
+    cursor: not-allowed;
+  }
+`;
+
+const DoctorIcon = () => (React__default["default"].createElement("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none" },
+    React__default["default"].createElement("path", { d: "M8.98307 14.3333C7.87196 14.3333 6.92752 13.9445 6.14974 13.1667C5.37196 12.3889 4.98307 11.4445 4.98307 10.3333V9.96668C4.08307 9.85557 3.33041 9.45557 2.72507 8.76668C2.1193 8.07779 1.81641 7.26668 1.81641 6.33334V3.10001C1.81641 2.93334 1.87463 2.79157 1.99107 2.67468C2.10796 2.55823 2.24974 2.50001 2.41641 2.50001H3.81641V2.33334C3.81641 2.1889 3.86374 2.06934 3.95841 1.97468C4.05263 1.88045 4.17196 1.83334 4.31641 1.83334C4.46085 1.83334 4.58041 1.88045 4.67507 1.97468C4.7693 2.06934 4.81641 2.1889 4.81641 2.33334V3.66668C4.81641 3.81112 4.7693 3.93045 4.67507 4.02468C4.58041 4.11934 4.46085 4.16668 4.31641 4.16668C4.17196 4.16668 4.05263 4.11934 3.95841 4.02468C3.86374 3.93045 3.81641 3.81112 3.81641 3.66668V3.50001H2.81641V6.33334C2.81641 7.06668 3.07752 7.69445 3.59974 8.21668C4.12196 8.7389 4.74974 9.00001 5.48307 9.00001C6.21641 9.00001 6.84418 8.7389 7.36641 8.21668C7.88863 7.69445 8.14974 7.06668 8.14974 6.33334V3.50001H7.14974V3.66668C7.14974 3.81112 7.10263 3.93045 7.00841 4.02468C6.91374 4.11934 6.79418 4.16668 6.64974 4.16668C6.5053 4.16668 6.38596 4.11934 6.29174 4.02468C6.19707 3.93045 6.14974 3.81112 6.14974 3.66668V2.33334C6.14974 2.1889 6.19707 2.06934 6.29174 1.97468C6.38596 1.88045 6.5053 1.83334 6.64974 1.83334C6.79418 1.83334 6.91374 1.88045 7.00841 1.97468C7.10263 2.06934 7.14974 2.1889 7.14974 2.33334V2.50001H8.54974C8.71641 2.50001 8.85818 2.55823 8.97507 2.67468C9.09152 2.79157 9.14974 2.93334 9.14974 3.10001V6.33334C9.14974 7.26668 8.84707 8.07779 8.24174 8.76668C7.63596 9.45557 6.88307 9.85557 5.98307 9.96668V10.3333C5.98307 11.1667 6.27485 11.8751 6.85841 12.4587C7.44152 13.0418 8.14974 13.3333 8.98307 13.3333C9.81641 13.3333 10.5249 13.0418 11.1084 12.4587C11.6915 11.8751 11.9831 11.1667 11.9831 10.3333V9.25001C11.6386 9.1389 11.3526 8.93601 11.1251 8.64134C10.8971 8.34712 10.7831 8.01112 10.7831 7.63334C10.7831 7.15557 10.9497 6.75001 11.2831 6.41668C11.6164 6.08334 12.0164 5.91668 12.4831 5.91668C12.9609 5.91668 13.3664 6.08334 13.6997 6.41668C14.0331 6.75001 14.1997 7.15557 14.1997 7.63334C14.1997 8.01112 14.086 8.34712 13.8584 8.64134C13.6304 8.93601 13.3386 9.1389 12.9831 9.25001V10.3333C12.9831 11.4445 12.5942 12.3889 11.8164 13.1667C11.0386 13.9445 10.0942 14.3333 8.98307 14.3333ZM12.4831 8.33334C12.6831 8.33334 12.8526 8.26401 12.9917 8.12534C13.1304 7.98623 13.1997 7.82223 13.1997 7.63334C13.1997 7.43334 13.1304 7.26401 12.9917 7.12534C12.8526 6.98623 12.6831 6.91668 12.4831 6.91668C12.2831 6.91668 12.1164 6.98623 11.9831 7.12534C11.8497 7.26401 11.7831 7.43334 11.7831 7.63334C11.7831 7.82223 11.8497 7.98623 11.9831 8.12534C12.1164 8.26401 12.2831 8.33334 12.4831 8.33334Z", fill: "#595959" })));
+const ServiceIcon = () => (React__default["default"].createElement("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none" },
+    React__default["default"].createElement("path", { d: "M6.86836 9.26489V10.2386C6.86836 10.509 6.96294 10.7389 7.15209 10.9283C7.34124 11.1176 7.57093 11.2122 7.84114 11.2122C8.11135 11.2122 8.34133 11.1176 8.53106 10.9283C8.7208 10.7389 8.81567 10.509 8.81567 10.2386V9.26489H9.78936C10.0598 9.26489 10.2897 9.17031 10.479 8.98116C10.6684 8.79201 10.763 8.56233 10.763 8.29211C10.763 8.0219 10.6684 7.79192 10.479 7.60219C10.2897 7.41245 10.0598 7.31758 9.78936 7.31758H8.81567V6.34389C8.81567 6.07343 8.72109 5.84354 8.53194 5.65422C8.34279 5.4649 8.11311 5.37024 7.84289 5.37024C7.57268 5.37024 7.3427 5.4649 7.15297 5.65422C6.96323 5.84354 6.86836 6.07343 6.86836 6.34389V7.31758H5.89467C5.62421 7.31758 5.39432 7.41216 5.205 7.60131C5.01568 7.79046 4.92102 8.02014 4.92102 8.29036C4.92102 8.56057 5.01568 8.79055 5.205 8.98028C5.39432 9.17002 5.62421 9.26489 5.89467 9.26489H6.86836ZM3.40809 14.1333C3.02086 14.1333 2.68938 13.9954 2.41364 13.7196C2.13788 13.4439 2 13.1124 2 12.7252V6.07426C2 5.85132 2.04987 5.64011 2.14961 5.44063C2.24936 5.24116 2.38723 5.07689 2.56323 4.94782L6.99718 1.61486C7.24323 1.42712 7.52444 1.33325 7.84081 1.33325C8.15718 1.33325 8.43919 1.42712 8.68685 1.61486L13.1208 4.94782C13.2968 5.07689 13.4347 5.24116 13.5344 5.44063C13.6342 5.64011 13.684 5.85132 13.684 6.07426V12.7252C13.684 13.1124 13.5462 13.4439 13.2704 13.7196C12.9947 13.9954 12.6632 14.1333 12.2759 14.1333H3.40809ZM3.40809 12.9649H12.2759C12.3459 12.9649 12.4033 12.9424 12.4482 12.8974C12.4932 12.8525 12.5156 12.7951 12.5156 12.7252V6.07426C12.5156 6.03431 12.5069 5.99811 12.4894 5.96566C12.4719 5.9332 12.4482 5.90449 12.4183 5.87953L7.98433 2.55406C7.94438 2.51911 7.89694 2.50164 7.84202 2.50164C7.78709 2.50164 7.73965 2.51911 7.69971 2.55406L3.26576 5.87953C3.2358 5.90449 3.21209 5.9332 3.1946 5.96566C3.17712 5.99811 3.16839 6.03431 3.16839 6.07426V12.7252C3.16839 12.7951 3.19086 12.8525 3.2358 12.8974C3.28075 12.9424 3.33818 12.9649 3.40809 12.9649Z", fill: "#595959" })));
+const HospitalIcon = () => (React__default["default"].createElement("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none" },
+    React__default["default"].createElement("path", { d: "M7.99984 8.00004C8.3665 8.00004 8.68039 7.86949 8.9415 7.60837C9.20261 7.34726 9.33317 7.03337 9.33317 6.66671C9.33317 6.30004 9.20261 5.98615 8.9415 5.72504C8.68039 5.46393 8.3665 5.33337 7.99984 5.33337C7.63317 5.33337 7.31928 5.46393 7.05817 5.72504C6.79706 5.98615 6.6665 6.30004 6.6665 6.66671C6.6665 7.03337 6.79706 7.34726 7.05817 7.60837C7.31928 7.86949 7.63317 8.00004 7.99984 8.00004ZM7.99984 12.9C9.35539 11.6556 10.3609 10.525 11.0165 9.50837C11.6721 8.49171 11.9998 7.58893 11.9998 6.80004C11.9998 5.58893 11.6137 4.59726 10.8415 3.82504C10.0693 3.05282 9.12206 2.66671 7.99984 2.66671C6.87761 2.66671 5.93039 3.05282 5.15817 3.82504C4.38595 4.59726 3.99984 5.58893 3.99984 6.80004C3.99984 7.58893 4.32761 8.49171 4.98317 9.50837C5.63873 10.525 6.64428 11.6556 7.99984 12.9ZM7.99984 14.4167C7.91095 14.4167 7.82206 14.4 7.73317 14.3667C7.64428 14.3334 7.5665 14.2889 7.49984 14.2334C5.87761 12.8 4.6665 11.4695 3.8665 10.2417C3.0665 9.01393 2.6665 7.86671 2.6665 6.80004C2.6665 5.13337 3.20261 3.8056 4.27484 2.81671C5.34706 1.82782 6.58873 1.33337 7.99984 1.33337C9.41095 1.33337 10.6526 1.82782 11.7248 2.81671C12.7971 3.8056 13.3332 5.13337 13.3332 6.80004C13.3332 7.86671 12.9332 9.01393 12.1332 10.2417C11.3332 11.4695 10.1221 12.8 8.49984 14.2334C8.43317 14.2889 8.35539 14.3334 8.2665 14.3667C8.17761 14.4 8.08873 14.4167 7.99984 14.4167Z", fill: "#8C8C8C" })));
+const SpecialtyIcon = () => (React__default["default"].createElement("svg", { width: "16", height: "16", viewBox: "0 0 16 16" },
+    React__default["default"].createElement("path", { d: "M3.83333 0.5C2.94928 0.5 2.10143 0.851189 1.47631 1.47631C0.851189 2.10143 0.5 2.94928 0.5 3.83333C0.5 4.71739 0.851189 5.56523 1.47631 6.19036C2.10143 6.81548 2.94928 7.16667 3.83333 7.16667C4.71739 7.16667 5.56523 6.81548 6.19036 6.19036C6.81548 5.56523 7.16667 4.71739 7.16667 3.83333C7.16667 2.94928 6.81548 2.10143 6.19036 1.47631C5.56523 0.851189 4.71739 0.5 3.83333 0.5V0.5ZM10.5 0.5C9.57917 0.5 8.83333 1.24583 8.83333 2.16667V5.5C8.83333 6.42083 9.57917 7.16667 10.5 7.16667H13.8333C14.7542 7.16667 15.5 6.42083 15.5 5.5V2.16667C15.5 1.24583 14.7542 0.5 13.8333 0.5H10.5ZM3.83333 8.83333C2.94928 8.83333 2.10143 9.18452 1.47631 9.80964C0.851189 10.4348 0.5 11.2826 0.5 12.1667C0.5 13.0507 0.851189 13.8986 1.47631 14.5237C2.10143 15.1488 2.94928 15.5 3.83333 15.5C4.71739 15.5 5.56523 15.1488 6.19036 14.5237C6.81548 13.8986 7.16667 13.0507 7.16667 12.1667C7.16667 11.2826 6.81548 10.4348 6.19036 9.80964C5.56523 9.18452 4.71739 8.83333 3.83333 8.83333V8.83333ZM12.1667 8.83333C11.2826 8.83333 10.4348 9.18452 9.80964 9.80964C9.18452 10.4348 8.83333 11.2826 8.83333 12.1667C8.83333 13.0507 9.18452 13.8986 9.80964 14.5237C10.4348 15.1488 11.2826 15.5 12.1667 15.5C13.0507 15.5 13.8986 15.1488 14.5237 14.5237C15.1488 13.8986 15.5 13.0507 15.5 12.1667C15.5 11.2826 15.1488 10.4348 14.5237 9.80964C13.8986 9.18452 13.0507 8.83333 12.1667 8.83333V8.83333Z", fill: "#9AA2AC" })));
+
+const SearchSpecialty = ({ state, isMobile, debouncedFetchSearchResults, selectedLocation, onSpecialtyClick, dispatch, }) => {
+    var _a;
+    const { t, locale } = useTranslations.useTranslations();
+    const inputSpecialtyWrapperRef = React.useRef(null);
+    const slugs = React.useMemo(() => constants.LOCALIZED_SLUGS[locale], [locale]);
+    const styleSpecialties = React.useMemo(() => {
+        return {
+            wrapper: {
+                '&:after': {
+                    content: '""',
+                    width: '1px',
+                    height: '20px',
+                    backgroundColor: '#E4E8EC',
+                    position: 'absolute',
+                    right: 0,
+                    top: '13px',
+                },
+            },
+            input: {
+                border: isMobile ? 'border: 1px solid #d9d9d9' : 'none',
+                height: isMobile ? '40px' : '46px !important',
+                paddingRight: '30px',
+                '&:focus': {
+                    boxShadow: isMobile ? 'box-shadow: 0px 0px 0px 2px #91caff' : 'none',
+                },
+            },
+            rightSection: {
+                width: '30px',
+                svg: {
+                    fontSize: '20px',
+                },
+            },
+        };
+    }, [isMobile]);
+    const handleSearchSpecialtyInputChange = React.useCallback(function handleSearchSpecialtyInputChange(value) {
+        // dispatch({ type: ActionTypes.ChangeInputLocation, payload: value })
+        // if (value.trim().length > SEARCH_KEYWORD_MIN_LENGTH[state.locale]) {
+        //   debouncedFetchSearchResults(value.trim())
+        // } else {
+        //   debouncedFetchSearchResults.cancel()
+        //   dispatch({ type: ActionTypes.DisplayInitialCities })
+        // }
+        console.log(value);
+    }, [debouncedFetchSearchResults, dispatch]);
+    useOutsideClick.useOutsideClick(inputSpecialtyWrapperRef, () => {
+        dispatch({ type: ActionTypes.ClickOutsideInputSpecialty });
+    });
+    return (React__default["default"].createElement(StyleSearchSpecialtyWrapper, { ref: inputSpecialtyWrapperRef },
+        React__default["default"].createElement(core.Input.Wrapper, null,
+            React__default["default"].createElement(core.Input, { size: isMobile ? 'md' : 'lg', placeholder: t('booking.searchPopup.specialties'), value: ((_a = state === null || state === void 0 ? void 0 : state.selectedSpecialty) === null || _a === void 0 ? void 0 : _a.name) || '', rightSection: React__default["default"].createElement(ChevronDown.ChevronDown, null), styles: styleSpecialties, onFocus: () => dispatch({ type: ActionTypes.FocusInputSpecialty }), onChange: (event) => {
+                    handleSearchSpecialtyInputChange(event.target.value);
+                } })),
+        state.focused === 'specialty' && (React__default["default"].createElement(StyleResultWrapper$1, null,
+            React__default["default"].createElement(StyledSpecialtyItem, { key: "all-location", role: "button", tabIndex: 0, onClick: () => {
+                    if (onSpecialtyClick) {
+                        onSpecialtyClick({
+                            name: t('booking.searchBar.allSpecialties'),
+                            id: -1,
+                            thumbnail: '',
+                            total_doctor: 0,
+                            slug: slugs.SPECIALTIES,
+                        });
+                    }
+                } },
+                React__default["default"].createElement("div", { className: "image-item" },
+                    React__default["default"].createElement(SpecialtyIcon, null)),
+                React__default["default"].createElement(index$2.Text, { size: "md" }, t('booking.searchBar.allSpecialties'))),
+            state.allSpecialties.map((specialty) => (React__default["default"].createElement(StyledSpecialtyItem, { key: specialty.id, onClick: (evt) => {
+                    evt.nativeEvent.stopImmediatePropagation();
+                    if (onSpecialtyClick) {
+                        onSpecialtyClick(Object.assign(Object.assign({}, specialty), { total_doctor: 0 }));
+                    }
+                }, role: "button", tabIndex: 0, "aria-label": `Select ${specialty.name} as location`, isSelected: (selectedLocation === null || selectedLocation === void 0 ? void 0 : selectedLocation.id) === specialty.id },
+                React__default["default"].createElement("div", { className: "image-item" },
+                    React__default["default"].createElement("img", { src: specialty.thumbnail, alt: specialty.name })),
+                React__default["default"].createElement(index$2.Text, { size: "md" }, specialty.name))))))));
+};
+
+const SearchInputs = ({ state, type, isMobile, isLoading, initalSearchValue, typeInformation, debouncedFetchSearchResults, trackingAttributes, hideSpecialtySelection = false, clientSlug = '', focusSearchInput, onSearch, onEnterSearch, dispatch, }) => {
+    var _a;
+    const { t } = useTranslations.useTranslations();
+    const inputSearchWrapperRef = React.useRef(null);
+    const gaAttributes = React.useMemo(() => {
+        if (trackingAttributes) {
+            return {
+                'data-event-category': trackingAttributes.dataEventCategory,
+                'data-event-action': trackingAttributes.dataEventAction,
+                'data-event-label': trackingAttributes.dataEventLabel,
+            };
+        }
+        else {
+            return {};
+        }
+    }, [trackingAttributes]);
+    const placeholderSearch = React.useMemo(() => {
+        if (type === 'doctor') {
+            return t('booking.searchBar.placeholder.doctor');
+        }
+        if (type === 'service') {
+            return t('booking.searchBar.placeholder.service');
+        }
+        if (type === 'hospital') {
+            return t('booking.searchBar.placeholder.hospital');
+        }
+        if (type === 'specialty') {
+            return t('booking.searchBar.placeholder.specialty');
+        }
+        return '';
+    }, [type]);
+    const styleInputWrapper = React.useMemo(() => {
+        return {
+            root: {
+                flex: 1,
+                '&.hide-specialty-selection': {
+                    '.mantine-Input-rightSection': {
+                        display: 'none',
+                    },
+                    input: {
+                        paddingLeft: '48px',
+                    },
+                    '.mantine-Input-icon': {
+                        left: '0',
+                    },
+                },
+            },
+        };
+    }, []);
+    const styleInput = React.useMemo(() => {
+        return {
+            icon: {
+                left: '165px',
+            },
+            input: {
+                color: '#262626',
+                '&[data-with-icon="true"]': {
+                    paddingLeft: '205px',
+                    paddingRight: '16px',
+                },
+            },
+            rightSection: {
+                left: 0,
+                width: '165px',
+                padding: '1px',
+            },
+        };
+    }, []);
+    const styleInputSpecialties = React.useMemo(() => {
+        return {
+            input: {
+                color: '#262626',
+            },
+        };
+    }, []);
+    useOutsideClick.useOutsideClick(inputSearchWrapperRef, () => {
+        dispatch({ type: ActionTypes.ClickOutsideInputSearch });
+    });
+    const handleSearchInputChange = React.useCallback(function handleSearchInputChange(value) {
+        dispatch({ type: ActionTypes.ChangeInputSearch, payload: value });
+        if (typeof onSearch === 'function') {
+            return;
+        }
+        if (value.trim().length > SEARCH_KEYWORD_MIN_LENGTH[state.locale] ||
+            initalSearchValue ||
+            value.trim().length === 0) {
+            debouncedFetchSearchResults(value.trim(), state, type, clientSlug);
+        }
+        else {
+            debouncedFetchSearchResults.cancel();
+            dispatch({ type: ActionTypes.DisplayInitialSearchResults });
+        }
+    }, [dispatch, state, type]);
+    const handleSpecialtyClick = React.useCallback(function handleSpecialtyClick(specialty) {
+        dispatch({ type: ActionTypes.SelectSpecialty, payload: specialty });
+        focusSearchInput();
+    }, [dispatch]);
+    const inputOnKeyDown = React.useCallback((e) => {
+        if (e.keyCode === 13) {
+            e.stopPropagation();
+            e.preventDefault();
+            onEnterSearch && onEnterSearch();
+        }
+    }, [onEnterSearch]);
+    return (React__default["default"].createElement(StyleSearchInputsWrapper, { ref: inputSearchWrapperRef }, type === 'specialty' ? (React__default["default"].createElement(core.Input.Wrapper, { styles: styleInputWrapper },
+        React__default["default"].createElement(core.Input, { icon: React__default["default"].createElement(core$1.Search, null), size: isMobile ? 'md' : 'lg', placeholder: placeholderSearch, styles: styleInputSpecialties, value: state.searchKeywords, onFocus: () => dispatch({ type: ActionTypes.FocusInputSearchSpecialty }), onChange: (event) => {
+                handleSearchInputChange(event.target.value);
+            }, onKeyDown: inputOnKeyDown }))) : (React__default["default"].createElement(React__default["default"].Fragment, null,
+        type === 'service' ? (React__default["default"].createElement(core.Input.Wrapper, { styles: styleInputWrapper },
+            React__default["default"].createElement(core.Input, { icon: React__default["default"].createElement(core$1.Search, null), size: isMobile ? 'md' : 'lg', name: "search-results", placeholder: placeholderSearch, onFocus: () => dispatch({ type: ActionTypes.FocusInputSearch }), value: state.searchKeywords, onChange: (event) => {
+                    handleSearchInputChange(event.target.value);
+                }, onKeyDown: inputOnKeyDown }))) : (React__default["default"].createElement(React__default["default"].Fragment, null, isMobile && !hideSpecialtySelection ? (React__default["default"].createElement(React__default["default"].Fragment, null,
+            React__default["default"].createElement(SearchSpecialty, { state: state, isMobile: isMobile, dispatch: dispatch, debouncedFetchSearchResults: debouncedFetchSearchResults, onSpecialtyClick: handleSpecialtyClick }),
+            React__default["default"].createElement(core.Input.Wrapper, { styles: styleInputWrapper },
+                React__default["default"].createElement(core.Input, { icon: React__default["default"].createElement(core$1.Search, null), size: "md", placeholder: placeholderSearch, value: state.searchKeywords, name: "search-results", onFocus: () => dispatch({ type: ActionTypes.FocusInputSearch }), onChange: (event) => {
+                        handleSearchInputChange(event.target.value);
+                    }, onKeyDown: inputOnKeyDown })))) : (React__default["default"].createElement(core.Input.Wrapper, { styles: styleInputWrapper, className: hideSpecialtySelection ? 'hide-specialty-selection' : '' },
+            React__default["default"].createElement(core.Input, Object.assign({ icon: React__default["default"].createElement(core$1.Search, null), size: "lg", placeholder: placeholderSearch, styles: styleInput, name: "search-results", autoComplete: "off", value: state.searchKeywords, onChange: (event) => {
+                    handleSearchInputChange(event.target.value);
+                }, onFocus: () => dispatch({ type: ActionTypes.FocusInputSearch }), onKeyDown: inputOnKeyDown }, gaAttributes, { rightSection: hideSpecialtySelection ? (React__default["default"].createElement(React__default["default"].Fragment, null)) : (React__default["default"].createElement(SearchSpecialty, { state: state, isMobile: isMobile, dispatch: dispatch, debouncedFetchSearchResults: debouncedFetchSearchResults, onSpecialtyClick: handleSpecialtyClick })) })))))),
+        state.focused === 'search' && (React__default["default"].createElement(StyleResultWrapper$2, null,
+            React__default["default"].createElement(SearchResult, { type: type, state: state, results: ((_a = state.searchResults) === null || _a === void 0 ? void 0 : _a[type]) || [], location: state.selectedLocation.name, dispatch: dispatch, isLoading: isLoading, typeInformation: typeInformation, clientSlug: clientSlug })))))));
+};
+
+const StyleSearchLocationWrapper = styled__default["default"].div `
+  position: relative;
+
+  ${utils.MediaQueries.mbDown} {
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+  }
+`;
+const StyleResultWrapper = styled__default["default"].div `
+  position: absolute;
+  top: calc(100% + 2px);
+  width: 100%;
+  border-radius: 4px;
+  background: ${theme.theme.colors.white};
+  box-shadow: 0px 8px 40px 0px rgba(0, 0, 0, 0.1);
+  z-index: 10;
+
+  ${utils.MediaQueries.mbDown} {
+    width: calc(100% + 64px);
+    left: -32px;
+  }
+`;
+const StyledLocationItem = styled__default["default"].li `
+  position: relative;
+  cursor: pointer;
+  padding: 12px 18px;
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  overflow: hidden;
+
+  ${({ isSelected }) => isSelected &&
+    `
+        &::after {
+            content: ${checkMarkIconUrl};
+            top: 50%;
+            right: 18px;
+            position: absolute;
+            transform: translateY(-50%);
+        }
+    `}
+
+  & + li::before {
+    content: '';
+    position: absolute;
+    left: 18px;
+    right: 18px;
+    top: 0;
+    height: 1px;
+    background-color: ${theme.theme.colors.neutral100};
+  }
+
+  &:not([data-is-denied='true']):hover {
+    background-color: ${theme.theme.colors.neutral50};
+  }
+
+  &:last-child:hover {
+    border-bottom-right-radius: 6px;
+    border-bottom-left-radius: 6px;
+  }
+
+  &:first-child:hover {
+    border-top-right-radius: 6px;
+    border-top-left-radius: 6px;
+  }
+
+  &[data-is-denied='true'] {
+    cursor: not-allowed;
+  }
+`;
+const StyledPinIcon = styled__default["default"](PinIcon) `
+  width: 12px;
+  height: 18px;
+  flex: 0 0 12px;
+`;
+
+const SearchLocation = ({ state, isMobile, debouncedFetchCitiesByKeyword, selectedLocation, trackingAttributes, onLocationClick, dispatch, }) => {
+    const { t, locale } = useTranslations.useTranslations();
+    const inputLocationWrapperRef = React.useRef(null);
+    const gaAttributes = React.useMemo(() => {
+        if (trackingAttributes) {
+            return {
+                'data-event-category': trackingAttributes.dataEventCategory,
+                'data-event-action': trackingAttributes.dataEventAction,
+                'data-event-label': trackingAttributes.dataEventLabel,
+            };
+        }
+        else {
+            return {};
+        }
+    }, [trackingAttributes]);
+    const handleSearchLocationInputChange = React.useCallback(function handleSearchLocationInputChange(value) {
+        dispatch({ type: ActionTypes.ChangeInputLocation, payload: value });
+        if (value.trim().length > SEARCH_KEYWORD_MIN_LENGTH[state.locale]) {
+            debouncedFetchCitiesByKeyword(value.trim());
+        }
+        else {
+            debouncedFetchCitiesByKeyword.cancel();
+            dispatch({ type: ActionTypes.DisplayInitialCities });
+        }
+    }, [debouncedFetchCitiesByKeyword, dispatch]);
+    useOutsideClick.useOutsideClick(inputLocationWrapperRef, () => {
+        dispatch({ type: ActionTypes.ClickOutsideInputLocation });
+    });
+    return (React__default["default"].createElement(StyleSearchLocationWrapper, { ref: inputLocationWrapperRef },
+        React__default["default"].createElement(core.Input.Wrapper, null,
+            React__default["default"].createElement(core.Input, Object.assign({ size: isMobile ? 'md' : 'lg', placeholder: "Search location", value: state.searchLocationKeywords, onFocus: () => dispatch({ type: ActionTypes.FocusInputLocation }), onChange: (event) => {
+                    handleSearchLocationInputChange(event.target.value);
+                } }, gaAttributes))),
+        state.focused === 'location' && (React__default["default"].createElement(StyleResultWrapper, null,
+            React__default["default"].createElement(StyledLocationItem, { key: "all-location", role: "button", tabIndex: 0, onClick: () => {
+                    var _a;
+                    if (onLocationClick) {
+                        onLocationClick({
+                            name: t('booking.searchBar.allLocations'),
+                            id: constants.ID_OPTION_ALL_LOCATION,
+                            slug: (_a = constants.LOCALIZED_SLUGS[locale]) === null || _a === void 0 ? void 0 : _a.ALL,
+                        });
+                    }
+                } },
+                React__default["default"].createElement(StyledPinIcon, { color: theme.theme.colors.neutral400 }),
+                React__default["default"].createElement(index$2.Text, { size: "md" }, t('booking.searchBar.allLocations'))),
+            state.cities.map((city) => (React__default["default"].createElement(StyledLocationItem, { key: city.id, onClick: (evt) => {
+                    evt.nativeEvent.stopImmediatePropagation();
+                    if (onLocationClick) {
+                        onLocationClick(city);
+                    }
+                }, role: "button", tabIndex: 0, "aria-label": `Select ${city.name} as location`, isSelected: (selectedLocation === null || selectedLocation === void 0 ? void 0 : selectedLocation.id) === city.id },
+                React__default["default"].createElement(StyledPinIcon, { color: theme.theme.colors.neutral400 }),
+                React__default["default"].createElement(index$2.Text, { size: "md" }, city.name))))))));
+};
+
+const StyleSpecialtiesWrapper = styled__default["default"].div `
+  display: flex;
+  flex-wrap: wrap;
+  row-gap: 8px;
+  column-gap: 20px;
+  ${utils.MediaQueries.mbDown} {
+    margin-top: 12px;
+  }
+`;
+const StyleSpecialtyItem = styled__default["default"].div `
+  display: flex;
+  align-items: center;
+  border-radius: 8px;
+  border: 1px solid ${theme.theme.colors.neutral100};
+  background: ${theme.theme.colors.white};
+  padding: 8px 12px 8px 8px;
+  flex: 0 0 calc(33.3% - 13px);
+  gap: 12px;
+  cursor: pointer;
+
+  &:hover {
+    background: ${theme.theme.colors.blue50};
+  }
+
+  ${utils.MediaQueries.tdDown} {
+    flex: 0 0 calc(50% - 10px);
+  }
+
+  ${utils.MediaQueries.mbDown} {
+    flex: 0 0 100%;
+    border: none;
+  }
+
+  .image-item {
+    display: flex;
+    align-items: center;
+    width: 40px;
+    height: 40px;
+
+    img {
+      width: 100%;
+      object-fit: cover;
+    }
+  }
+
+  .infor {
+    flex: 1;
+    .title {
+      color: ${theme.theme.colors.gray800};
+      font-size: 14px;
+      font-style: normal;
+      font-weight: 400;
+      line-height: 22px;
+    }
+
+    .description {
+      color: ${theme.theme.colors.gray600};
+      font-size: 12px;
+      font-weight: 400;
+      line-height: 18px;
+    }
+  }
+`;
+const StyleDivider = styled__default["default"](core.Divider) `
+  margin: 24px 0 !important;
+`;
+const StyleShowMore = styled__default["default"].div `
+  display: flex;
+  justify-content: center;
+  margin-top: 24px;
+  .show-more {
+    border-radius: 4px;
+    border: 1px solid ${theme.theme.colors.neutral200};
+    padding: 12px 16px;
+    cursor: pointer;
+    display: inline-block;
+    color: ${theme.theme.colors.gray800};
+    font-size: 16px;
+    font-weight: 600;
+    line-height: 24px;
+
+    ${utils.MediaQueries.mbDown} {
+      width: 100%;
+      text-align: center;
+    }
+  }
+`;
+
+const SearchResultSpecialties = ({ state, isMobile, specialties, isLoading, dispatch, }) => {
+    const { t, locale } = useTranslations.useTranslations();
+    const { selectedLocation } = state;
+    const slugs = React.useMemo(() => constants.LOCALIZED_SLUGS[locale], [locale]);
+    const handleOnClick = (specialtySlug) => {
+        let url = '';
+        if (specialtySlug === constants.SLUG_VACIN_ID) {
+            url = `/${selectedLocation.slug}/${slugs.HOSPITAL}/${constants.CLIENT_KEY.GSK}/`;
+            dispatch({ type: ActionTypes.ClickOutsideInputSearchSpecialty });
+        }
+        else {
+            url = `/${selectedLocation.slug}/${slugs.DOCTOR}/${specialtySlug}`;
+        }
+        dispatch({ type: ActionTypes.NavigateTo, payload: url });
+    };
+    const handleShowMore = () => {
+        const url = `/${slugs.SPECIALTIES}`;
+        dispatch({ type: ActionTypes.NavigateTo, payload: url });
+    };
+    const showSeeMore = React.useMemo(() => {
+        return (specialties.length >= 9 ||
+            state.searchKeywords.trim().length <=
+                SEARCH_KEYWORD_MIN_LENGTH[state.locale]);
+    }, [state.searchKeywords, specialties]);
+    return (React__default["default"].createElement(React__default["default"].Fragment, null,
+        !isMobile && React__default["default"].createElement(StyleDivider, { color: "#E4E8EC" }),
+        React__default["default"].createElement(StyleSpecialtiesWrapper, null,
+            specialties.length > 0 && !isLoading && (React__default["default"].createElement(React__default["default"].Fragment, null, specialties.map((specialty, index) => {
+                if (index >= 9) {
+                    return React__default["default"].createElement(React__default["default"].Fragment, null);
+                }
+                return (React__default["default"].createElement(StyleSpecialtyItem, { key: specialty.id, onClick: () => handleOnClick(specialty.slug) },
+                    React__default["default"].createElement("div", { className: "image-item" },
+                        React__default["default"].createElement("img", { src: specialty.thumbnail, alt: specialty.name })),
+                    React__default["default"].createElement("div", { className: "infor" },
+                        React__default["default"].createElement("div", { className: "title" }, specialty.name))));
+            }))),
+            specialties.length === 0 && !isLoading && (React__default["default"].createElement(index$2.Text, { size: "sm", color: theme.theme.colors.gray400 }, t('booking.searchBar.noResults'))),
+            isLoading &&
+                Array(6)
+                    .fill(undefined)
+                    .map((_, i) => (React__default["default"].createElement(StyleSpecialtyItem, { key: 'loading' + i },
+                    React__default["default"].createElement("div", { className: "image-item" },
+                        React__default["default"].createElement(core.Skeleton, { height: 40, animate: true })),
+                    React__default["default"].createElement("div", { className: "infor" },
+                        React__default["default"].createElement("div", { className: "title" },
+                            React__default["default"].createElement(core.Skeleton, { height: 20, radius: "sm", animate: true }))))))),
+        showSeeMore && (React__default["default"].createElement(StyleShowMore, null,
+            React__default["default"].createElement("div", { className: "show-more", onClick: handleShowMore }, t('home.seeAll'))))));
+};
+
+const StyleSearchTagWrapper = styled__default["default"].div `
+  display: flex;
+  gap: 5px;
+  margin-top: 16px;
+  flex-wrap: wrap;
+`;
+const StyleTagItem = styled__default["default"].div `
+  color: ${theme.theme.colors.gray600};
+  font-size: 14px;
+  font-weight: 600;
+  line-height: 22px;
+  padding: 4px 12px;
+  background: ${theme.theme.colors.white};
+  border-radius: 32px;
+  cursor: pointer;
+  border: 1px solid ${theme.theme.colors.white};
+  margin-bottom: 5px;
+  border-color: ${theme.theme.colors.neutral100};
+  background: #f7f9fc;
+
+  &.view-all {
+    border-radius: 32px;
+    border-color: ${theme.theme.colors.blue50};
+    background: ${theme.theme.colors.blue50};
+    color: ${theme.theme.colors.blue600};
+
+    &:hover {
+      border-color: ${theme.theme.colors.blue50};
+      background: ${theme.theme.colors.blue50};
+      color: ${theme.theme.colors.blue600};
+    }
+  }
+
+  &:hover {
+    border-color: ${theme.theme.colors.neutral100};
+    background: #f7f9fc;
+  }
+`;
+const StyleTagLabel = styled__default["default"].div `
+  color: ${theme.theme.colors.gray600};
+  font-size: 14px;
+  font-weight: 600;
+  line-height: 22px;
+  padding: 4px 0;
+  background: ${theme.theme.colors.white};
+  border-radius: 32px;
+  border: 1px solid ${theme.theme.colors.white};
+  margin-bottom: 5px;
+  margin-right: 7px;
+`;
+
+const SearchTag = ({ state, type, typeInformation, dispatch }) => {
+    const { t } = useTranslations.useTranslations();
+    const { selectedLocation } = state;
+    const typeSlug = React.useMemo(() => typeInformation[type].slug, [typeInformation, type]);
+    const handleViewAll = () => {
+        const url = `/${selectedLocation.slug}/${typeSlug}`;
+        if (url) {
+            dispatch({ type: ActionTypes.NavigateTo, payload: url });
+        }
+    };
+    const handleClickKeyword = (keyword) => {
+        if (keyword.url) {
+            window.location.href = keyword.url;
+        }
+    };
+    return (React__default["default"].createElement(StyleSearchTagWrapper, null,
+        React__default["default"].createElement(StyleTagLabel, null, t('booking.searchBar.popularKey')),
+        state.popularKeys.map((item) => {
+            return (React__default["default"].createElement(StyleTagItem, { key: item.id, onClick: () => handleClickKeyword(item) }, item.keyword));
+        }),
+        React__default["default"].createElement(StyleTagItem, { className: "view-all", onClick: handleViewAll }, t('booking.searchBar.viewAll'))));
+};
+
+const StyledTabWrapper = styled__default["default"].div `
+  background: rgba(255, 255, 255, 0.64);
+  backdrop-filter: blur(12px);
+  border-bottom: 1px solid ${theme.theme.colors.neutral100};
+`;
+const StyleTabContainer = styled__default["default"](index$3.Container) `
+  padding: 0 16px;
+`;
+
+const itemTabs = () => {
+    const { t } = useTranslations.useTranslations();
+    return [
+        {
+            value: 'hospital',
+            label: t('booking.searchPopup.hospitals'),
+        },
+        {
+            value: 'doctor',
+            label: t('booking.searchPopup.doctors'),
+        },
+        {
+            value: 'service',
+            label: t('booking.searchPopup.services'),
+        },
+        {
+            value: 'specialty',
+            label: t('booking.searchPopup.specialties'),
+        },
+    ];
+};
+const TabSearch = ({ currentTab, hideTabBookingSearch = [], isMobile, setCurrentTab, }) => {
+    const stylesTabs = React.useMemo(() => {
+        return {
+            root: {
+                overflowY: isMobile ? 'hidden' : 'initial',
+                overflowX: isMobile ? 'auto' : 'initial',
+            },
+            tabsList: {
+                background: 'rgba(255, 255, 255, 0)',
+                borderBottom: 'none',
+                flexWrap: 'nowrap',
+                '.mantine-Tabs-tab': {
+                    '&:last-child': {
+                        '&:after': {
+                            display: 'none',
+                        },
+                    },
+                },
+            },
+            tab: {
+                padding: isMobile ? '12px 16px 12px 16px' : '15px 40px 15px 40px',
+                borderTop: '2px solid transparent',
+                borderBottom: 'none',
+                margin: 0,
+                borderRadius: 0,
+                position: 'relative',
+                width: 'auto',
+                '&[data-active="true"]': {
+                    borderColor: '#2d87f3',
+                    backgroundColor: '#ffffff',
+                    '&:after': {
+                        display: 'none',
+                    },
+                    '&:before': {
+                        content: '""',
+                        width: '100%',
+                        height: '1px',
+                        position: 'absolute',
+                        backgroundColor: '#ffffff',
+                        bottom: '-1px',
+                    },
+                },
+                '&:hover': {
+                    borderColor: '#2d87f3',
+                    backgroundColor: '#ffffff',
+                    '&:before': {
+                        content: '""',
+                        width: '100%',
+                        height: '1px',
+                        position: 'absolute',
+                        backgroundColor: '#ffffff',
+                        bottom: '-1px',
+                    },
+                },
+                '&:after': {
+                    content: '""',
+                    width: '1px',
+                    height: '24px',
+                    backgroundColor: '#E4E8EC',
+                    position: 'absolute',
+                    right: '-1px',
+                },
+            },
+            tabLabel: {
+                color: '#595959',
+                fontSize: isMobile ? '14px' : '16px',
+                fontWeight: 600,
+                lineHeight: isMobile ? '22px' : '24px',
+            },
+        };
+    }, [isMobile]);
+    const tabConfig = itemTabs();
+    const activeTabs = React.useMemo(() => {
+        return (tabConfig.filter((item) => !hideTabBookingSearch.includes(item.value)) ||
+            []);
+    }, [hideTabBookingSearch, tabConfig]);
+    return (React__default["default"].createElement(StyledTabWrapper, { className: "booking-search-tab" },
+        React__default["default"].createElement(StyleTabContainer, null,
+            React__default["default"].createElement(core.Tabs, { value: currentTab, onTabChange: (tab) => {
+                    setCurrentTab(tab);
+                }, styles: stylesTabs },
+                React__default["default"].createElement(core.Tabs.List, null, activeTabs.map((tab) => {
+                    return (React__default["default"].createElement(core.Tabs.Tab, { value: tab.value, key: tab.value }, tab.label));
+                }))))));
+};
+
+var TypePopularKeySearch;
+(function (TypePopularKeySearch) {
+    TypePopularKeySearch["doctor"] = "doctor";
+    TypePopularKeySearch["service"] = "hospital_service";
+    TypePopularKeySearch["hospital"] = "hospital_branch";
+})(TypePopularKeySearch || (TypePopularKeySearch = {}));
+
+function useSearchBarApi({ dispatch, careApiDomain, locale = 'vi-VN', client = '', }) {
+    const fetchCitiesApi = React.useCallback(function fetchCitiesApi(path, params = {}) {
+        const url = `${careApiDomain}${path}`;
+        dispatch({ type: ActionTypes.FetchCitiesStart });
+        return fetch(getApiPath(url, params, locale), { method: 'GET' })
+            .then((res) => res.json())
+            .then((data) => {
+            if (data._status !== 1 || !data._data) {
+                console.log('error loading cities', data);
+                return Promise.reject(data);
+            }
+            return data === null || data === void 0 ? void 0 : data._data;
+        })
+            .finally(() => dispatch({ type: ActionTypes.FetchCitiesFinish }));
+    }, [locale]);
+    const fetchCitiesByLocation = React.useCallback(function fetchCitiesByLocation({ coordinates }) {
+        let params = {};
+        const moreParams = {};
+        if (coordinates) {
+            params = {
+                lat: coordinates.lat,
+                lng: coordinates.lng,
+            };
+        }
+        if (locale === 'ms-MY') {
+            moreParams.noPaging = 1;
+        }
+        const requests = [
+            fetchCitiesApi(paths.PATHS.GET_CITY_BY_IP, Object.assign(Object.assign(Object.assign({}, params), moreParams), { client: constants.CLIENT_KEY.MSD === client ? '' : client })),
+        ];
+        if (locale === 'zh-TW') {
+            requests.push(fetchCitiesApi(paths.PATHS.GET_CITIES_LIST, {
+                noPaging: 1,
+                client: constants.CLIENT_KEY.MSD === client ? '' : client,
+            }));
+        }
+        return Promise.all(requests)
+            .then(([data1, data2]) => {
+            const data = Object.assign({}, data1);
+            if (data2) {
+                const citiesIds = data.cities.map((c) => c.id);
+                data.cities = data.cities.concat(data2.cities.filter((c) => !citiesIds.includes(c.id)));
+            }
+            dispatch({
+                type: ActionTypes.FetchCitiesByGeoIpComplete,
+                payload: data,
+            });
+        })
+            .catch((err) => console.error('error loading cities by location', err));
+    }, [locale, careApiDomain, dispatch]);
+    const fetchCitiesByKeyword = React.useCallback(function fetchCitiesByKeyword(keyword) {
+        return fetchCitiesApi(paths.PATHS.GET_CITIES_LIST, {
+            keyword,
+            client,
+        })
+            .then((data) => {
+            dispatch({
+                type: ActionTypes.FetchCitiesByKeywordComplete,
+                payload: data.cities,
+            });
+        })
+            .catch((err) => console.error('error loading cities by keyword', err));
+    }, [locale, careApiDomain, dispatch]);
+    const fetchSearchResults = React.useCallback(function fetchSearchResults(searchKeywords, state, searchType, clientSlug, cacheResult) {
+        const url = searchType === 'specialty'
+            ? `${careApiDomain}${paths.PATHS.GET_SEARCH_SPECIALTY}`
+            : `${careApiDomain}${paths.PATHS.GET_SEARCH_V2}`;
+        dispatch({ type: ActionTypes.FetchSearchResultsStart });
+        const { selectedLocation, geoLocationCoordinates, selectedSpecialty } = state;
+        let cityId = '';
+        if (!selectedLocation) {
+            dispatch({ type: ActionTypes.FetchSearchResultsFinish });
+            return;
+        }
+        if (selectedLocation.id === constants.ID_OPTION_ALL_LOCATION) {
+            cityId = '';
+        }
+        else {
+            cityId = selectedLocation.id;
+        }
+        const lat = (geoLocationCoordinates === null || geoLocationCoordinates === void 0 ? void 0 : geoLocationCoordinates.lat) || '';
+        const lng = (geoLocationCoordinates === null || geoLocationCoordinates === void 0 ? void 0 : geoLocationCoordinates.lng) || '';
+        const specialty_id = (selectedSpecialty === null || selectedSpecialty === void 0 ? void 0 : selectedSpecialty.id) > 0 ? selectedSpecialty === null || selectedSpecialty === void 0 ? void 0 : selectedSpecialty.id : '';
+        const keyword = searchKeywords.trim().length > SEARCH_KEYWORD_MIN_LENGTH[locale]
+            ? searchKeywords.trim()
+            : '';
+        return fetch(getApiPath(url, {
+            domain: careApiDomain,
+            searchType: searchType || 'global',
+            keyword: keyword,
+            city: cityId === constants.ID_OPTION_CURRENT_LOCATION ? '' : cityId,
+            lat,
+            lng,
+            specialty_id,
+            client_slug: constants.CLIENT_KEY.MSD === clientSlug ? '' : clientSlug,
+            msd: constants.CLIENT_KEY.MSD === client ? 1 : '',
+        }, locale), {
+            method: 'GET',
+            headers: {
+                accept: 'version=2.0.0.0',
+            },
+        })
+            .then((res) => res.json())
+            .then((data) => {
+            if (data._status !== 1 || !data._data) {
+                return Promise.reject(data);
+            }
+            return data === null || data === void 0 ? void 0 : data._data;
+        })
+            .then((results) => {
+            let searchesResult = [];
+            if (searchType !== 'specialty') {
+                searchesResult = results.searches;
+            }
+            if (searchType === 'specialty') {
+                if (keyword) {
+                    searchesResult = results.specialties;
+                }
+                else {
+                    searchesResult = results.default;
+                }
+            }
+            dispatch({
+                type: ActionTypes.FetchSearchResultsComplete,
+                payload: {
+                    key: searchType,
+                    searches: searchesResult || [],
+                },
+            });
+            if (cacheResult) {
+                dispatch({
+                    type: ActionTypes.UpdateInitialSearchResults,
+                    payload: {
+                        key: searchType,
+                        searches: searchesResult || [],
+                    },
+                });
+            }
+        })
+            .catch((error) => {
+            console.log('error loading search results', { url, error });
+        })
+            .finally(() => dispatch({ type: ActionTypes.FetchSearchResultsFinish }));
+    }, [locale, careApiDomain, dispatch]);
+    const fetchAllSpecialties = React.useCallback(function fetchSearchSpecialties() {
+        const url = `${careApiDomain}${paths.PATHS.GET_SEARCH_SPECIALTY}`;
+        return fetch(getApiPath(url, {
+            domain: careApiDomain,
+            searchType: '',
+            msd: constants.CLIENT_KEY.MSD === client ? 1 : '',
+        }, locale), {
+            method: 'GET',
+            headers: {
+                accept: 'version=2.0.0.0',
+            },
+        })
+            .then((res) => res.json())
+            .then((data) => {
+            if (data._status !== 1 || !data._data) {
+                return Promise.reject(data);
+            }
+            return data === null || data === void 0 ? void 0 : data._data;
+        })
+            .then((results) => {
+            dispatch({
+                type: ActionTypes.FetchAllSpecialties,
+                payload: results.specialties || [],
+            });
+        })
+            .catch((error) => {
+            console.log('error loading search results', { url, error });
+        });
+    }, [locale, careApiDomain, dispatch]);
+    const fetchPopularKeys = React.useCallback(function fetchPopularKeys(searchType) {
+        const url = `${careApiDomain}${paths.PATHS.GET_SEARCH_POPULAR_KEY}`;
+        return fetch(getApiPath(url, {
+            domain: careApiDomain,
+            searchType: TypePopularKeySearch[searchType],
+            sort_by: 'display_order',
+            sort_order: 'asc',
+        }, locale))
+            .then((res) => res.json())
+            .then((data) => {
+            if (data._status !== 1 || !data._data) {
+                return Promise.reject(data);
+            }
+            return data === null || data === void 0 ? void 0 : data._data;
+        })
+            .then((results) => {
+            dispatch({
+                type: ActionTypes.FetchPopularKeys,
+                payload: results.popular_searches || [],
+            });
+        })
+            .catch((error) => {
+            console.log('error loading search results', { url, error });
+        });
+    }, [locale, careApiDomain, dispatch]);
+    return {
+        fetchCitiesByLocation,
+        fetchCitiesByKeyword,
+        fetchSearchResults,
+        fetchAllSpecialties,
+        fetchPopularKeys,
+    };
+}
+
+const BookingSearchBarV2 = ({ isMobile, careApiDomain, geoLocationPermission: geoLocationPermissionFromProps, geoLocationCoordinates: geoLocationCoordinatesFromProps, initialSelectedCity: initialSelectedCityFromProps, initialSearchValue = '', initTypeSearch = 'hospital', initSpecialty, careFrontDomain = '/care', isDebug = false, 
+// askForGeolocationPermission = false,
+gaTrackingSearchBar, gaTrackingLocationSearch, autoCompleteDisabled = false, inputSearchPlaceholder = '', hideTabBookingSearch = [], hideSpecialtySelection = false, hidePopularSearchKeys = false, clientSlug = '', 
+// isOptionAllLocation = false,
+// hideResults = [],
+// isNavResultItem = true,
+routerPush, onGeoLocationPermissionChange, 
+// onSearch,
+onChangeLocation, }) => {
+    const { locale, t } = useTranslations.useTranslations();
+    const wrapperRef = React.useRef(null);
+    const inputSearchSpecialtyWrapperRef = React.useRef(null);
+    const [currentTab, setCurrentTab] = React.useState(initTypeSearch);
+    const { geoLocationPermission: geoLocationPermissionFromHook, geoLocationCoordinates: geoLocationCoordinatesFromHook, } = useGeolocation();
+    const [state, dispatch] = React.useReducer(reducer, initialState, (s) => (Object.assign(Object.assign({}, s), { isDebug,
+        isMobile, geoLocationPermission: geoLocationPermissionFromProps ||
+            geoLocationPermissionFromHook ||
+            'unset', geoLocationCoordinates: geoLocationCoordinatesFromProps ||
+            geoLocationCoordinatesFromHook ||
+            null, searchKeywords: initialSearchValue, initialSelectedCity: initialSelectedCityFromProps || null, selectedLocation: initialSelectedCityFromProps || s.selectedLocation || null, searchLocationKeywords: (initialSelectedCityFromProps === null || initialSelectedCityFromProps === void 0 ? void 0 : initialSelectedCityFromProps.name) || s.searchLocationKeywords, autoCompleteDisabled,
+        inputSearchPlaceholder,
+        locale })));
+    const { navigateTo, focusedSpecialty, 
+    // isLoadingCities,
+    // cities,
+    searchKeywords, geoLocationPermission, selectedLocation, selectedSpecialty, initialSelectedCity, 
+    // defaultCity,
+    searchResults, isLoadingSearchResults,
+    // isMobileModalOpened,
+    // inputSearchPlaceholder,
+    // allSpecialties,
+     } = state;
+    const { fetchCitiesByLocation, fetchCitiesByKeyword, fetchSearchResults, fetchAllSpecialties, fetchPopularKeys, } = useSearchBarApi({
+        dispatch,
+        locale,
+        careApiDomain,
+        client: clientSlug,
+    });
+    const slugs = React.useMemo(() => constants.LOCALIZED_SLUGS[locale], [locale]);
+    const typeInformation = React.useMemo(() => {
+        return {
+            doctor: {
+                name: t('booking.searchPopup.doctors'),
+                icon: React__default["default"].createElement(DoctorIcon, null),
+                slug: slugs.DOCTOR,
+            },
+            service: {
+                name: t('booking.searchPopup.services'),
+                icon: React__default["default"].createElement(ServiceIcon, null),
+                slug: slugs.SERVICE,
+            },
+            hospital: {
+                name: t('booking.searchPopup.hospitals'),
+                icon: React__default["default"].createElement(HospitalIcon, null),
+                slug: slugs.HOSPITAL,
+            },
+            specialty: {
+                name: t('booking.searchPopup.specialties'),
+                icon: React__default["default"].createElement(SpecialtyIcon, null),
+                slug: slugs.SPECIALTIES,
+            },
+        };
+    }, [currentTab]);
+    const debouncedFetchCitiesByKeyword = React.useMemo(() => debounce__default["default"](fetchCitiesByKeyword, 400), [fetchCitiesByKeyword]);
+    const debouncedFetchSearchResults = React.useMemo(() => debounce__default["default"](fetchSearchResults, 400), [fetchSearchResults]);
+    const handleLocationClick = React.useCallback(function handleLocationClick(city) {
+        dispatch({ type: ActionTypes.SelectLocation, payload: city });
+        focusSearchInput();
+        if (onChangeLocation) {
+            onChangeLocation(city);
+        }
+    }, [t, dispatch]);
+    function focusSearchInput() {
+        var _a;
+        if (wrapperRef.current) {
+            (_a = wrapperRef.current
+                .querySelector('input[name="search-results"]')) === null || _a === void 0 ? void 0 : _a.focus();
+        }
+    }
+    function onClickSearchByKeyword() {
+        let url = '';
+        const { slug: typeSlug } = typeInformation[currentTab];
+        let moreParams = '';
+        const slugClientUrl = constants.MAPPING_CLIENT_WITH_SLUG[locale][clientSlug];
+        if ((currentTab === 'doctor' || currentTab === 'hospital') &&
+            state.selectedSpecialty.id > 0) {
+            moreParams = `&specialtyId=${state.selectedSpecialty.id}`;
+        }
+        if (currentTab === 'specialty') {
+            url = `/${typeSlug}`;
+        }
+        else {
+            url = `/${selectedLocation.slug}/${typeSlug}`;
+        }
+        if (slugClientUrl) {
+            url += `/${slugClientUrl}`;
+        }
+        url += `?q=${searchKeywords}${moreParams}`;
+        if (url) {
+            dispatch({ type: ActionTypes.NavigateTo, payload: url });
+        }
+    }
+    useOutsideClick.useOutsideClick(inputSearchSpecialtyWrapperRef, () => {
+        dispatch({ type: ActionTypes.ClickOutsideInputSearchSpecialty });
+    });
+    React.useEffect(() => {
+        var _a;
+        if (geoLocationPermission !== 'denied' && !initialSelectedCity) {
+            dispatch({
+                type: ActionTypes.SelectLocation,
+                payload: {
+                    name: t('booking.searchBar.allLocations'),
+                    id: constants.ID_OPTION_ALL_LOCATION,
+                    slug: (_a = constants.LOCALIZED_SLUGS[locale]) === null || _a === void 0 ? void 0 : _a.ALL,
+                },
+            });
+        }
+        if (onGeoLocationPermissionChange) {
+            onGeoLocationPermissionChange(geoLocationPermission, state.geoLocationCoordinates);
+        }
+        if (isMobile && geoLocationPermission === 'granted' && selectedLocation) {
+            dispatch({ type: ActionTypes.FocusInputSearch });
+        }
+        fetchCitiesByLocation({ coordinates: state.geoLocationCoordinates });
+    }, [geoLocationPermission]);
+    React.useEffect(() => {
+        const defaultSpecialty = initSpecialty
+            ? initSpecialty
+            : {
+                name: t('booking.searchBar.allSpecialties'),
+                id: -1,
+                thumbnail: '',
+                total_doctor: 0,
+                slug: slugs.SPECIALTIES,
+            };
+        if (!state.selectedSpecialty) {
+            dispatch({
+                type: ActionTypes.SelectSpecialty,
+                payload: defaultSpecialty,
+            });
+        }
+    }, [initSpecialty, state.selectedSpecialty]);
+    React.useEffect(() => {
+        fetchAllSpecialties();
+    }, []);
+    React.useEffect(() => {
+        fetchPopularKeys(currentTab);
+    }, [currentTab]);
+    React.useEffect(() => {
+        if (navigateTo) {
+            if (routerPush) {
+                routerPush(navigateTo);
+            }
+            else {
+                window.location.href = `${careFrontDomain}${navigateTo}`;
+            }
+        }
+    }, [navigateTo]);
+    React.useEffect(() => {
+        fetchSearchResults(state.searchKeywords, state, currentTab, clientSlug, true);
+    }, [selectedLocation, selectedSpecialty, currentTab]);
+    return (React__default["default"].createElement(StyledSearchBarWrapper, { ref: wrapperRef },
+        React__default["default"].createElement(TabSearch, { currentTab: currentTab, setCurrentTab: setCurrentTab, isMobile: isMobile, hideTabBookingSearch: hideTabBookingSearch }),
+        React__default["default"].createElement(StyleWrapperContainer, { className: "booking-search-container" },
+            React__default["default"].createElement(StyleSearchInputContainer, null,
+                React__default["default"].createElement(StyleSearchContent, null,
+                    React__default["default"].createElement("div", { ref: inputSearchSpecialtyWrapperRef },
+                        React__default["default"].createElement(core.Flex, { gap: "12px", justify: "space-between", align: "center", direction: isMobile ? 'column' : 'row', className: "flex-search-input" },
+                            currentTab !== 'specialty' && (React__default["default"].createElement(SearchLocation, { state: state, isMobile: isMobile, dispatch: dispatch, debouncedFetchCitiesByKeyword: debouncedFetchCitiesByKeyword, selectedLocation: selectedLocation, onLocationClick: handleLocationClick, trackingAttributes: gaTrackingLocationSearch })),
+                            React__default["default"].createElement(SearchInputs, { type: currentTab, isMobile: isMobile, state: state, dispatch: dispatch, debouncedFetchSearchResults: debouncedFetchSearchResults, initalSearchValue: initialSearchValue, focusSearchInput: focusSearchInput, onEnterSearch: onClickSearchByKeyword, typeInformation: typeInformation, trackingAttributes: gaTrackingSearchBar, isLoading: isLoadingSearchResults, hideSpecialtySelection: hideSpecialtySelection, clientSlug: clientSlug }),
+                            React__default["default"].createElement(core.Button, { size: isMobile ? 'md' : 'lg', color: "#2D87F3", fullWidth: isMobile, variant: "filled", onClick: onClickSearchByKeyword, styles: {
+                                    root: {
+                                        height: isMobile ? '40px' : '48px',
+                                    },
+                                } }, t('booking.searchBar.searchButton'))),
+                        !hidePopularSearchKeys &&
+                            currentTab !== 'specialty' &&
+                            state.popularKeys.length > 0 && (React__default["default"].createElement(SearchTag, { type: currentTab, state: state, typeInformation: typeInformation, dispatch: dispatch })),
+                        currentTab === 'specialty' && focusedSpecialty === 'search' && (React__default["default"].createElement(SearchResultSpecialties, { state: state, isMobile: isMobile, dispatch: dispatch, specialties: (searchResults === null || searchResults === void 0 ? void 0 : searchResults.specialty) || [], isLoading: isLoadingSearchResults }))))))));
+};
+
+const StyledTextDivider = styled__default["default"].div `
+  background-color: var(--neutral50);
+  padding: 12px 0;
+  box-shadow: inset 0px 1px 0px #e4e8ec;
+
+  > * {
+    display: grid;
+    grid-template-columns: 32px 1fr;
+    align-content: center;
+
+    p {
+      font-weight: 600;
+    }
+  }
+
+  .icon-wrapper {
+    display: flex;
+    align-items: center;
+  }
+`;
+const TextDivider = ({ children, icon, className, style }) => (React__default["default"].createElement(StyledTextDivider, { style: style, className: className },
+    React__default["default"].createElement(index$3.Container, null,
+        React__default["default"].createElement("div", { className: "icon-wrapper" }, icon),
+        React__default["default"].createElement(index$2.Text, { size: "c1", color: "var(--neutral800)" }, children))));
+
+var RedirectType;
+(function (RedirectType) {
+    RedirectType[RedirectType["SPECIALTY"] = 1] = "SPECIALTY";
+    RedirectType[RedirectType["DOCTOR"] = 2] = "DOCTOR";
+    RedirectType[RedirectType["CLINIC"] = 3] = "CLINIC";
+    RedirectType[RedirectType["SERVICE"] = 4] = "SERVICE";
+})(RedirectType || (RedirectType = {}));
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  get RedirectType () { return RedirectType; }
+});
+
+exports.BookingSearchBar = BookingSearchBar;
+exports.BookingSearchBarV2 = BookingSearchBarV2;
+exports.TextDivider = TextDivider;
+exports.types = types;