@splunk/react-ui 5.3.0 → 5.5.0

package/PhoneNumber.js

@@ -0,0 +1,769 @@
+/******/ (() => {
+    // webpackBootstrap
+    /******/ "use strict";
+    /******/    var e = {
+        /***/ 5183: 
+        /***/ e => {
+            e.exports = require("intl-tel-input/intlTelInputWithUtils");
+            /***/
+            /******/        }
+    };
+    /************************************************************************/
+    /******/ // The module cache
+    /******/    var r = {};
+    /******/
+    /******/ // The require function
+    /******/    function t(n) {
+        /******/ // Check if module is in cache
+        /******/ var a = r[n];
+        /******/        if (a !== undefined) {
+            /******/ return a.exports;
+            /******/        }
+        /******/ // Create a new module (and put it into the cache)
+        /******/        var o = r[n] = {
+            /******/ // no module.id needed
+            /******/ // no module.loaded needed
+            /******/ exports: {}
+            /******/        };
+        /******/
+        /******/ // Execute the module function
+        /******/        e[n](o, o.exports, t);
+        /******/
+        /******/ // Return the exports of the module
+        /******/        return o.exports;
+        /******/    }
+    /******/
+    /************************************************************************/
+    /******/ /* webpack/runtime/compat get default export */
+    /******/    (() => {
+        /******/ // getDefaultExport function for compatibility with non-harmony modules
+        /******/ t.n = e => {
+            /******/ var r = e && e.__esModule ? 
+            /******/ () => e["default"]
+            /******/ : () => e
+            /******/;
+            t.d(r, {
+                a: r
+            });
+            /******/            return r;
+            /******/        };
+        /******/    })();
+    /******/
+    /******/ /* webpack/runtime/create fake namespace object */
+    /******/    (() => {
+        /******/ var e = Object.getPrototypeOf ? e => Object.getPrototypeOf(e) : e => e.__proto__
+        /******/;
+        var r;
+        /******/ // create a fake namespace object
+        /******/ // mode & 1: value is a module id, require it
+        /******/ // mode & 2: merge all properties of value into the ns
+        /******/ // mode & 4: return value when already ns object
+        /******/ // mode & 16: return value when it's Promise-like
+        /******/ // mode & 8|1: behave like require
+        /******/        t.t = function(n, a) {
+            /******/ if (a & 1) n = this(n);
+            /******/            if (a & 8) return n;
+            /******/            if (typeof n === "object" && n) {
+                /******/ if (a & 4 && n.__esModule) return n;
+                /******/                if (a & 16 && typeof n.then === "function") return n;
+                /******/            }
+            /******/            var o = Object.create(null);
+            /******/            t.r(o);
+            /******/            var l = {};
+            /******/            r = r || [ null, e({}), e([]), e(e) ];
+            /******/            for (var i = a & 2 && n; typeof i == "object" && !~r.indexOf(i); i = e(i)) {
+                /******/ Object.getOwnPropertyNames(i).forEach((e => l[e] = () => n[e]));
+                /******/            }
+            /******/            l["default"] = () => n
+            /******/;
+            t.d(o, l);
+            /******/            return o;
+            /******/        };
+        /******/    })();
+    /******/
+    /******/ /* webpack/runtime/define property getters */
+    /******/    (() => {
+        /******/ // define getter functions for harmony exports
+        /******/ t.d = (e, r) => {
+            /******/ for (var n in r) {
+                /******/ if (t.o(r, n) && !t.o(e, n)) {
+                    /******/ Object.defineProperty(e, n, {
+                        enumerable: true,
+                        get: r[n]
+                    });
+                    /******/                }
+                /******/            }
+            /******/        };
+        /******/    })();
+    /******/
+    /******/ /* webpack/runtime/hasOwnProperty shorthand */
+    /******/    (() => {
+        /******/ t.o = (e, r) => Object.prototype.hasOwnProperty.call(e, r)
+        /******/;
+    })();
+    /******/
+    /******/ /* webpack/runtime/make namespace object */
+    /******/    (() => {
+        /******/ // define __esModule on exports
+        /******/ t.r = e => {
+            /******/ if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
+                /******/ Object.defineProperty(e, Symbol.toStringTag, {
+                    value: "Module"
+                });
+                /******/            }
+            /******/            Object.defineProperty(e, "__esModule", {
+                value: true
+            });
+            /******/        };
+        /******/    })();
+    /******/
+    /************************************************************************/    var n = {};
+    // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+        (() => {
+        // ESM COMPAT FLAG
+        t.r(n);
+        // EXPORTS
+                t.d(n, {
+            default: () => /* reexport */ X
+        });
+        // CONCATENATED MODULE: external "react"
+        const e = require("react");
+        var r =  t.n(e);
+        // CONCATENATED MODULE: external "prop-types"
+        const a = require("prop-types");
+        var o =  t.n(a);
+        // CONCATENATED MODULE: external "@splunk/react-ui/Button"
+        const l = require("@splunk/react-ui/Button");
+        var i =  t.n(l);
+        // CONCATENATED MODULE: external "@splunk/react-ui/Select"
+        const u = require("@splunk/react-ui/Select");
+        var c =  t.n(u);
+        // CONCATENATED MODULE: external "@splunk/react-ui/Text"
+        const f = require("@splunk/react-ui/Text");
+        var s =  t.n(f);
+        // CONCATENATED MODULE: external "@splunk/react-ui/useControlled"
+        const v = require("@splunk/react-ui/useControlled");
+        var d =  t.n(v);
+        // CONCATENATED MODULE: external "@splunk/ui-utils/i18n"
+        const p = require("@splunk/ui-utils/i18n");
+        // CONCATENATED MODULE: external "styled-components"
+        const y = require("styled-components");
+        var b =  t.n(y);
+        // CONCATENATED MODULE: ./src/PhoneNumber/PhoneNumberStyles.ts
+        var m = "230px";
+        var g = b().div.withConfig({
+            displayName: "PhoneNumberStyles__StyledWrapper",
+            componentId: "sc-197mlvr-0"
+        })([ "display:flex;&[data-inline]{display:inline-flex;width:", ";flex-basis:", ";}" ], m, m);
+        var h = b().span.attrs({
+            "aria-hidden": "true"
+        }).withConfig({
+            displayName: "PhoneNumberStyles__StyledFlagIcon",
+            componentId: "sc-197mlvr-1"
+        })([ "" ]);
+        var C = b()(c()).withConfig({
+            displayName: "PhoneNumberStyles__StyledSelect",
+            componentId: "sc-197mlvr-2"
+        })([ "flex:0 1 auto;" ]);
+        var O = b().span.withConfig({
+            displayName: "PhoneNumberStyles__StyledCountryCode",
+            componentId: "sc-197mlvr-3"
+        })([ "min-width:4ch;" ]);
+        // CONCATENATED MODULE: external "intl-tel-input"
+        const S = require("intl-tel-input");
+        var P =  t.n(S);
+        // CONCATENATED MODULE: ./src/PhoneNumber/utils.ts
+        // TODO(SUI-8145): Remove eslint-disable, needed for now for utils import
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        // this is the fallback validation length if utils fail to load
+        // the shortest valid phone number is 4 digits, for Niue (iso2 code "nu")
+        var j = 4;
+        var w = /[^+0-9]/g;
+        var k = "🌐";
+        var E = null;
+        var N = function e() {
+            if (!E) {
+                E = Promise.resolve().then(t.t.bind(t, 5183, 23)).then((function(e) {
+                    var r, t;
+                    return (r = (t = e["default"] || e) === null || t === void 0 ? void 0 : t.utils) !== null && r !== void 0 ? r : null;
+                }))["catch"]((function(e) {
+                    // eslint-disable-next-line no-console
+                    console.error("Error loading intl-tel-input utils:", e);
+                    return null;
+                }));
+            }
+            return E;
+        };
+        var x = function e(r) {
+            if (!r || r.length !== 2) {
+                return k;
+            }
+            // this converts ISO2 country code to corresponding emoji flag
+            // by converting each character to its regional indicator symbol
+            // and then returning the combined value, which maps to the flag emoji
+            // 127397 (127462 - 65) is the offset between ASCII uppercase letters and regional indicator symbols
+            // because the character A starts at 65 in ASCII and regional indicator A starts at 127462 in Unicode
+                        return r.toUpperCase().replace(/./g, (function(e) {
+                return String.fromCodePoint(e.charCodeAt(0) + 127397);
+            }));
+        };
+        var _ = function e() {
+            return P().getCountryData().map((function(e) {
+                return {
+                    areaCodes: e.areaCodes,
+                    countryName: e.name,
+                    dialCode: e.dialCode,
+                    flag: x(e.iso2),
+                    iso2: e.iso2,
+                    iso2Upper: e.iso2.toUpperCase(),
+                    nationalPrefix: e.nationalPrefix,
+                    priority: e.priority
+                };
+            }));
+        };
+        var R = function e(r, t, n) {
+            var a;
+            // intlFormat always has a leading plus sign
+            // but it may be incorrect (ie. inserting a double country code)
+            // for incomplete numbers, so we also check the input value
+            // and only format if the input value starts with a plus sign
+                        if (!r.startsWith("+") || !t.startsWith("+")) {
+                return null;
+            }
+            var o = t.slice(1);
+            var l = null;
+            var i = null;
+            for (var u = 0; u < n.length; u += 1) {
+                // if we have a primary match already, we can stop checking
+                // but if we only have a secondary match, we need to keep looking
+                if (l) {
+                    break;
+                }
+                var c = n[u];
+                if (o.startsWith(c.dialCode)) {
+                    if (c.areaCodes && c.areaCodes.length > 0) {
+                        var f = o.slice(c.dialCode.length);
+                        for (var s = 0; s < c.areaCodes.length; s += 1) {
+                            var v = c.areaCodes[s];
+                            if (f.startsWith(v)) {
+                                l = c;
+                                break;
+                            }
+                        }
+                    } else {
+                        i = c;
+                    }
+                }
+            }
+            // Prioritize countries with matching area codes over those without
+            // for example, +17788888888 should match Canada (area code 778 is a Canadian area code)
+            // but it also matches US (because the US matches any +1 number regardless of area code)
+            // so prefer the more specific match
+                        return (a = l) !== null && a !== void 0 ? a : i;
+        };
+        /**
+ * Main function to process phone input using intl-tel-input utilities
+ */        var V = function e(r, t) {
+            var n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "US";
+            var a = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+            var o = n.toLowerCase();
+            var l = t.replace(w, "");
+            var i = l;
+            var u = l;
+            var c = false;
+            var f = false;
+            var s = n;
+            if (r) {
+                // Formats as the user types, so incomplete input may still be formatted
+                i = r.formatNumberAsYouType(l, o).trim() || l;
+                // Create E164 format
+                                u = r.formatNumber(l, o, r.numberFormat.E164) || l;
+                c = r.isPossibleNumber(l, o);
+                f = r.isValidNumber(l, o);
+                var v = R(i, u, a);
+                if (v != null) {
+                    s = v.iso2Upper;
+                }
+            } else {
+                // if utils fail to load, we accept any input of length MIN_NUMBER_LENGTH or more as valid
+                // given that front-end validation should only be used as a hint to the user
+                // and proper validation should be done on the back-end;
+                // it is better to allow potentially invalid input than to risk blocking user flows
+                c = l.length >= j;
+                f = l.length >= j;
+            }
+            return {
+                displayValue: i,
+                value: l,
+                internationalFormat: u,
+                country: s,
+                isPossibleNumber: c,
+                isValidNumber: f
+            };
+        };
+        var I = function e(r, t, n, a) {
+            var o = a.find((function(e) {
+                return e.iso2Upper === t;
+            }));
+            var l = a.find((function(e) {
+                return e.iso2Upper === n;
+            }));
+            if (r.startsWith("+") && t !== n && o != null && l != null) {
+                var i = o.dialCode;
+                var u = l.dialCode;
+                if (i && u) {
+                    return r.replace(new RegExp("^\\+".concat(i)), "+".concat(u));
+                }
+            }
+            return r;
+        };
+        // CONCATENATED MODULE: ./src/utils/updateReactRef.ts
+        /**
+ * Updates a React ref. Callback refs and object refs (from `createRef` and `useRef`) are supported.
+ *
+ * @param ref - The React callback or object ref. Can be `null` or `undefined`.
+ * @param current - The new value of the ref.
+ */
+        function T(e, r) {
+            if (e) {
+                if (typeof e === "function") {
+                    e(r);
+                } else {
+                    // the public signature of this util uses React.Ref<T> to mirror the way React types refs.
+                    // the intention here is to signal "we will take care of setting 'current', not you".
+                    e.current = r;
+ // eslint-disable-line no-param-reassign
+                                }
+            }
+        }
+        // CONCATENATED MODULE: ./src/PhoneNumber/PhoneNumber.tsx
+        function U(e) {
+            "@babel/helpers - typeof";
+            return U = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e) {
+                return typeof e;
+            } : function(e) {
+                return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+            }, U(e);
+        }
+        function B() {
+            return B = Object.assign ? Object.assign.bind() : function(e) {
+                for (var r = 1; r < arguments.length; r++) {
+                    var t = arguments[r];
+                    for (var n in t) {
+                        ({}).hasOwnProperty.call(t, n) && (e[n] = t[n]);
+                    }
+                }
+                return e;
+            }, B.apply(null, arguments);
+        }
+        function M(e, r) {
+            var t = Object.keys(e);
+            if (Object.getOwnPropertySymbols) {
+                var n = Object.getOwnPropertySymbols(e);
+                r && (n = n.filter((function(r) {
+                    return Object.getOwnPropertyDescriptor(e, r).enumerable;
+                }))), t.push.apply(t, n);
+            }
+            return t;
+        }
+        function q(e) {
+            for (var r = 1; r < arguments.length; r++) {
+                var t = null != arguments[r] ? arguments[r] : {};
+                r % 2 ? M(Object(t), !0).forEach((function(r) {
+                    D(e, r, t[r]);
+                })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : M(Object(t)).forEach((function(r) {
+                    Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+                }));
+            }
+            return e;
+        }
+        function D(e, r, t) {
+            return (r = F(r)) in e ? Object.defineProperty(e, r, {
+                value: t,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : e[r] = t, e;
+        }
+        function F(e) {
+            var r = A(e, "string");
+            return "symbol" == U(r) ? r : r + "";
+        }
+        function A(e, r) {
+            if ("object" != U(e) || !e) return e;
+            var t = e[Symbol.toPrimitive];
+            if (void 0 !== t) {
+                var n = t.call(e, r || "default");
+                if ("object" != U(n)) return n;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+            }
+            return ("string" === r ? String : Number)(e);
+        }
+        function W(e, r) {
+            return Y(e) || z(e, r) || L(e, r) || K();
+        }
+        function K() {
+            throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function L(e, r) {
+            if (e) {
+                if ("string" == typeof e) return $(e, r);
+                var t = {}.toString.call(e).slice(8, -1);
+                return "Object" === t && e.constructor && (t = e.constructor.name), "Map" === t || "Set" === t ? Array.from(e) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? $(e, r) : void 0;
+            }
+        }
+        function $(e, r) {
+            (null == r || r > e.length) && (r = e.length);
+            for (var t = 0, n = Array(r); t < r; t++) {
+                n[t] = e[t];
+            }
+            return n;
+        }
+        function z(e, r) {
+            var t = null == e ? null : "undefined" != typeof Symbol && e[Symbol.iterator] || e["@@iterator"];
+            if (null != t) {
+                var n, a, o, l, i = [], u = !0, c = !1;
+                try {
+                    if (o = (t = t.call(e)).next, 0 === r) {
+                        if (Object(t) !== t) return;
+                        u = !1;
+                    } else for (;!(u = (n = o.call(t)).done) && (i.push(n.value), i.length !== r); u = !0) {
+                    }
+                } catch (e) {
+                    c = !0, a = e;
+                } finally {
+                    try {
+                        if (!u && null != t["return"] && (l = t["return"](), Object(l) !== l)) return;
+                    } finally {
+                        if (c) throw a;
+                    }
+                }
+                return i;
+            }
+        }
+        function Y(e) {
+            if (Array.isArray(e)) return e;
+        }
+        function G(e, r) {
+            if (null == e) return {};
+            var t, n, a = H(e, r);
+            if (Object.getOwnPropertySymbols) {
+                var o = Object.getOwnPropertySymbols(e);
+                for (n = 0; n < o.length; n++) {
+                    t = o[n], -1 === r.indexOf(t) && {}.propertyIsEnumerable.call(e, t) && (a[t] = e[t]);
+                }
+            }
+            return a;
+        }
+        function H(e, r) {
+            if (null == e) return {};
+            var t = {};
+            for (var n in e) {
+                if ({}.hasOwnProperty.call(e, n)) {
+                    if (-1 !== r.indexOf(n)) continue;
+                    t[n] = e[n];
+                }
+            }
+            return t;
+        }
+        /** @public */
+        /** @public */
+        /** @public */        var J = {
+            append: o().bool,
+            canClear: o().bool,
+            defaultCountry: o().string,
+            defaultValue: o().string,
+            describedBy: o().string,
+            disabled: o().bool,
+            elementRef: o().oneOfType([ o().func, o().object ]),
+            error: o().bool,
+            inline: o().bool,
+            inputId: o().string,
+            inputRef: o().oneOfType([ o().func, o().object ]),
+            labelledBy: o().string,
+            name: o().string,
+            onBlur: o().func,
+            onChange: o().func,
+            onClick: o().func,
+            onFocus: o().func,
+            onSelect: o().func,
+            prepend: o().bool,
+            /** @private */
+            skipFormatting: o().bool,
+            value: o().string
+        };
+        function Q(t) {
+            var n = t.append, a = t.canClear, o = a === void 0 ? true : a, l = t.defaultCountry, c = t.defaultValue, f = t.describedBy, v = t.disabled, y = t.elementRef, b = t.error, m = t.inline, S = t.inputRef, P = t.name, j = t.onBlur, w = t.onChange, E = t.onFocus, x = t.prepend, R = t.skipFormatting, U = t.toggleRef, M = t.value, D = G(t, [ "append", "canClear", "defaultCountry", "defaultValue", "describedBy", "disabled", "elementRef", "error", "inline", "inputRef", "name", "onBlur", "onChange", "onFocus", "prepend", "skipFormatting", "toggleRef", "value" ]);
+            // @docs-props-type PhoneNumberPropsBase
+                        var F = d()({
+                componentName: "PhoneNumber",
+                /* eslint-disable-next-line prefer-rest-params */
+                componentProps: arguments[0]
+            });
+            var A = (0, e.useState)(_), K = W(A, 1), L = K[0];
+            var $ = (0, e.useState)(null), z = W($, 2), Y = z[0], H = z[1];
+            (0, e.useEffect)((function() {
+                if (!R) {
+                    N().then((function(e) {
+                        H(e);
+                    }));
+                }
+            }), [ R ]);
+            // processPhoneInputImpl needs utils, so we memoize that here to avoid including them on each call
+                        var J = (0, e.useCallback)((function(e, r) {
+                return V(Y, e, r, L);
+            }), [ L, Y ]);
+            // If country prop is not passed, use Intl.Locale to get the region from the user's language, falls back to US
+                        var Q = new Intl.Locale(navigator.language);
+            var X = (0, e.useState)(l || Q.region || "US"), Z = W(X, 2), ee = Z[0], re = Z[1];
+            var te = (0, e.useRef)(null);
+            var ne = (0, e.useRef)(0);
+            var ae = (0, e.useCallback)((function(e) {
+                T(te, e);
+                T(S, e);
+            }), [ S ]);
+            var oe = (0, e.useState)(""), le = W(oe, 2), ie = le[0], ue = le[1];
+            var ce = (0, e.useState)(""), fe = W(ce, 2), se = fe[0], ve = fe[1];
+ // this effect formats the phone number on mount
+                        (0, e.useEffect)((function() {
+                var e = F ? M : c;
+                if (e) {
+                    var r = J(e, ee);
+                    ue(r.value);
+                    re(r.country);
+                    if (!F) {
+                        ve(r.displayValue);
+                    }
+                }
+                // this effect should only run on mount
+                // eslint-disable-next-line react-hooks/exhaustive-deps
+                        }), []);
+            (0, e.useLayoutEffect)((function() {
+                if (!R && te.current) {
+                    te.current.selectionStart = ne.current;
+                    te.current.selectionEnd = ne.current;
+                }
+            }));
+            // Update display value when controlled value or country changes
+                        (0, e.useEffect)((function() {
+                var e = "";
+                var r = ee;
+                var t = null;
+                if (F && M) {
+                    t = M;
+                } else if (!F && ie) {
+                    t = ie;
+                }
+                if (t) {
+                    var n = J(t, ee);
+                    r = n.country;
+                    e = n.displayValue;
+                }
+                ve(e);
+                re(r);
+            }), [ M, ie, ee, F, J ]);
+            var de = (0, e.useCallback)((function(e, r) {
+                var t;
+                var n = r.value;
+                var a = J(n, ee);
+                if (!F) {
+                    ue(a.value);
+                }
+                var o = ((t = te.current) === null || t === void 0 ? void 0 : t.selectionStart) || 0;
+                var l = n.slice(0, o);
+                var i = (l.match(/\d/g) || []).length;
+                var u = l.match(/\D*$/);
+                var c = u ? u[0].length : 0;
+                var f = function e(r, t) {
+                    if (t <= 0) {
+                        return -1;
+                    }
+                    var n = 0;
+                    for (var a = 0; a < r.length; a += 1) {
+                        if (/\d/.test(r[a])) {
+                            n += 1;
+                            if (n === t) {
+                                return a;
+                            }
+                        }
+                    }
+                    return -1;
+                };
+                var s = a.displayValue.length;
+                if (i === 0) {
+                    var v = f(a.displayValue, 1);
+                    var d = v === -1 ? a.displayValue.length : v;
+                    s = Math.min(c, d);
+                } else {
+                    var p = f(a.displayValue, i);
+                    if (p === -1) {
+                        s = a.displayValue.length;
+                    } else {
+                        var y = f(a.displayValue, i + 1);
+                        var b = Math.max(0, (y === -1 ? a.displayValue.length : y) - (p + 1));
+                        var m = Math.min(c, b);
+                        s = p + 1 + m;
+                    }
+                }
+                ne.current = s;
+                w === null || w === void 0 ? void 0 : w(e, q({
+                    name: P
+                }, a));
+            }), [ ee, F, P, w, J ]);
+            var pe = (0, e.useCallback)((function(e) {
+                var r = e.target.value;
+                j === null || j === void 0 ? void 0 : j(e, q({
+                    name: P
+                }, J(r, ee)));
+            }), [ ee, P, j, J ]);
+            var ye = (0, e.useCallback)((function(e) {
+                var r = e.target.value;
+                E === null || E === void 0 ? void 0 : E(e, q({
+                    name: P
+                }, J(r, ee)));
+            }), [ ee, P, E, J ]);
+            var be = (0, e.useCallback)((function(e) {
+                if (R) {
+                    return;
+                }
+                var r = e.key;
+                var t = e.currentTarget;
+                var n = t.selectionStart || 0;
+                var a = t.selectionEnd || 0;
+                var o = n;
+                var l = r === "Backspace";
+                var i = r === "Delete";
+                var u = r.length === 1 && !/\d/.test(r) && !e.ctrlKey && !e.metaKey && !e.altKey;
+                var c = r === "+" && n === 0;
+                if (u && !l && !i && !c) {
+                    // prevent non-numeric keys from being entered
+                    e.preventDefault();
+                    return;
+                }
+                if ((l || i || c) && n === a) {
+                    if (l) {
+                        // if the affected character is a non-digit, adjust the caret position to before the next digit
+                        while (o > 0) {
+                            var f = t.value[o - 1];
+                            if (/[\d+]/.test(f)) {
+                                break;
+                            }
+                            o -= 1;
+                        }
+                    } else if (i) {
+                        // if the affected character is a non-digit, adjust the caret position to after the next digit
+                        while (o < t.value.length) {
+                            var s = t.value[o];
+                            if (/[\d+]/.test(s)) {
+                                break;
+                            }
+                            o += 1;
+                        }
+                    } else if (c && t.value.startsWith("+")) {
+                        // if the first character is already a plus, skip over it
+                        o += 1;
+                    }
+                    if (o !== n) {
+                        var v;
+                        // if the caret position has changed, prevent the keystroke from taking effect and set the new position
+                        // if the key wasn't backspace or delete, or if the caret position wasn't changed because the prev/next
+                        // character was a digit, let the key event proceed normally and be handled in onChange
+                                                e.preventDefault();
+                        ne.current = o;
+                        (v = te.current) === null || v === void 0 ? void 0 : v.setSelectionRange(o, o);
+                    }
+                }
+            }), [ R ]);
+            var me = (0, e.useCallback)((function(e, r) {
+                var t = r.value;
+                if (te.current && typeof t === "string") {
+                    var n = te.current.value;
+                    var a = I(n, ee, t, L);
+                    re(t);
+                    var o = J(a, t);
+                    if (!F) {
+                        ue(o.value);
+                    }
+                    w === null || w === void 0 ? void 0 : w(e, q({
+                        name: P
+                    }, o));
+                }
+            }), [ ee, L, F, P, w, J, re ]);
+            var ge = (0, e.useMemo)((function() {
+                var e = L.find((function(e) {
+                    return e.iso2Upper === ee;
+                }));
+                if (!e) {
+                    if (false) {}
+                }
+                var t = e || {
+                    flag: k
+                }, n = t.flag;
+                
+                return r().createElement(i(), {
+                    append: true,
+                    icon: n,
+                    isMenu: true
+                });
+            }), [ L, ee ]);
+            var he = (0, e.useMemo)((function() {
+                return L.map((function(e) {
+                    var t = e.countryName, n = e.dialCode, a = e.flag, o = e.iso2Upper;
+                    
+                    return r().createElement(u.Option, {
+                        icon:  r().createElement(h, null, a),
+                        key: o,
+                        label: "".concat(t, " +").concat(n),
+                        value: o,
+                        endAdornment:  r().createElement(O, null, "+", n)
+                    }, t);
+                }));
+            }), [ L ]);
+            
+            return r().createElement(g, {
+                "data-inline": m || undefined,
+                "data-test": "phone-number",
+                "data-test-disabled": v ? "disabled" : undefined
+            },  r().createElement(C, {
+                "aria-label": (0, p._)("Country code"),
+                append: true,
+                disabled: v,
+                elementRef: U,
+                error: b,
+                filter: true,
+                toggle: ge,
+                onChange: me,
+                prepend: x,
+                value: ee
+            }, he),  r().createElement(s(), B({
+                append: n,
+                "aria-describedby": f,
+                "aria-invalid": b,
+                autoCapitalize: "off",
+                autoComplete: "tel",
+                autoCorrect: "off",
+                canClear: o,
+                disabled: v,
+                describedBy: f,
+                elementRef: y,
+                error: b,
+                inputRef: ae,
+                name: P,
+                onBlur: pe,
+                onChange: de,
+                onFocus: ye,
+                prepend: true,
+                type: "tel",
+                value: se,
+                onKeyDown: be
+            }, D, {
+                spellCheck: false
+            })));
+        }
+        Q.componentType = "PhoneNumber";
+        Q.propTypes = J;
+        /* harmony default export */        const X = Q;
+    }) // CONCATENATED MODULE: ./src/PhoneNumber/index.ts
+    ();
+    module.exports = n;
+    /******/})();