@kingteza/crud-component 1.22.2 → 1.23.0

package/dist/node_modules/.pnpm/react-phone-number-input@3.4.14_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-phone-number-input/modules/PhoneInputWithCountry.es.js

@@ -0,0 +1,830 @@
+import S from "react";
+import i from "../../../../../../_virtual/index.es.js";
+import V from "../../../../../../_virtual/index.es2.js";
+import J from "./InputSmart.es.js";
+import Q from "./InputBasic.es.js";
+import { CountrySelectWithIcon as Y } from "./CountrySelect.es.js";
+import Z from "./Flag.es.js";
+import tt from "./InternationalIcon.es.js";
+import { validateE164Number as et } from "./helpers/isE164Number.es.js";
+import { sortCountryOptions as nt, getSupportedCountryOptions as ot, isCountrySupportedWithError as rt, getSupportedCountries as it } from "./helpers/countries.es.js";
+import { createCountryIconComponent as at } from "./CountryIcon.es.js";
+import { setRefsValue as ut } from "./useExternalRef.es.js";
+import { metadata as lt, labels as st } from "./PropTypes.es.js";
+import { getCountrySelectOptions as ct, getPhoneDigitsForNewCountry as pt, e164 as ft, onPhoneDigitsChange as yt, couldNumberBelongToCountry as mt, parsePhoneNumber as dt, getPreSelectedCountry as Ct, getInitialPhoneDigits as gt } from "./helpers/phoneInputHelpers.es.js";
+import ht from "./helpers/getPhoneInputWithCountryStateUpdateFromNewProps.es.js";
+import $ from "../../../../libphonenumber-js@1.12.36/node_modules/libphonenumber-js/es6/getCountries.es.js";
+var bt = ["name", "disabled", "readOnly", "autoComplete", "style", "className", "inputRef", "inputComponent", "numberInputProps", "smartCaret", "countrySelectComponent", "countrySelectProps", "containerComponent", "containerComponentProps", "defaultCountry", "countries", "countryOptionsOrder", "labels", "flags", "flagComponent", "flagUrl", "addInternationalOption", "internationalIcon", "displayInitialValueAsLocalNumber", "initialValueFormat", "onCountryChange", "limitMaxLength", "countryCallingCodeEditable", "focusInputOnCountrySelection", "reset", "metadata", "international", "locales"];
+function F(n) {
+  "@babel/helpers - typeof";
+  return F = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+    return typeof e;
+  } : function(e) {
+    return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+  }, F(n);
+}
+function W(n, e) {
+  var o = Object.keys(n);
+  if (Object.getOwnPropertySymbols) {
+    var t = Object.getOwnPropertySymbols(n);
+    e && (t = t.filter(function(r) {
+      return Object.getOwnPropertyDescriptor(n, r).enumerable;
+    })), o.push.apply(o, t);
+  }
+  return o;
+}
+function K(n) {
+  for (var e = 1; e < arguments.length; e++) {
+    var o = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? W(Object(o), !0).forEach(function(t) {
+      p(n, t, o[t]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(n, Object.getOwnPropertyDescriptors(o)) : W(Object(o)).forEach(function(t) {
+      Object.defineProperty(n, t, Object.getOwnPropertyDescriptor(o, t));
+    });
+  }
+  return n;
+}
+function D() {
+  return D = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var o = arguments[e];
+      for (var t in o)
+        Object.prototype.hasOwnProperty.call(o, t) && (n[t] = o[t]);
+    }
+    return n;
+  }, D.apply(this, arguments);
+}
+function Ot(n, e) {
+  if (n == null) return {};
+  var o = vt(n, e), t, r;
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(n);
+    for (r = 0; r < a.length; r++)
+      t = a[r], !(e.indexOf(t) >= 0) && Object.prototype.propertyIsEnumerable.call(n, t) && (o[t] = n[t]);
+  }
+  return o;
+}
+function vt(n, e) {
+  if (n == null) return {};
+  var o = {}, t = Object.keys(n), r, a;
+  for (a = 0; a < t.length; a++)
+    r = t[a], !(e.indexOf(r) >= 0) && (o[r] = n[r]);
+  return o;
+}
+function St(n, e) {
+  if (!(n instanceof e))
+    throw new TypeError("Cannot call a class as a function");
+}
+function k(n, e) {
+  for (var o = 0; o < e.length; o++) {
+    var t = e[o];
+    t.enumerable = t.enumerable || !1, t.configurable = !0, "value" in t && (t.writable = !0), Object.defineProperty(n, z(t.key), t);
+  }
+}
+function Pt(n, e, o) {
+  return e && k(n.prototype, e), o && k(n, o), Object.defineProperty(n, "prototype", { writable: !1 }), n;
+}
+function It(n, e, o) {
+  return e = R(e), _t(n, X() ? Reflect.construct(e, o || [], R(n).constructor) : e.apply(n, o));
+}
+function _t(n, e) {
+  if (e && (F(e) === "object" || typeof e == "function"))
+    return e;
+  if (e !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return Nt(n);
+}
+function Nt(n) {
+  if (n === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return n;
+}
+function X() {
+  try {
+    var n = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (X = function() {
+    return !!n;
+  })();
+}
+function R(n) {
+  return R = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  }, R(n);
+}
+function jt(n, e) {
+  if (typeof e != "function" && e !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  n.prototype = Object.create(e && e.prototype, { constructor: { value: n, writable: !0, configurable: !0 } }), Object.defineProperty(n, "prototype", { writable: !1 }), e && U(n, e);
+}
+function U(n, e) {
+  return U = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t, r) {
+    return t.__proto__ = r, t;
+  }, U(n, e);
+}
+function p(n, e, o) {
+  return e = z(e), e in n ? Object.defineProperty(n, e, { value: o, enumerable: !0, configurable: !0, writable: !0 }) : n[e] = o, n;
+}
+function z(n) {
+  var e = Dt(n, "string");
+  return F(e) == "symbol" ? e : e + "";
+}
+function Dt(n, e) {
+  if (F(n) != "object" || !n) return n;
+  var o = n[Symbol.toPrimitive];
+  if (o !== void 0) {
+    var t = o.call(n, e);
+    if (F(t) != "object") return t;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(n);
+}
+var Ft = /* @__PURE__ */ (function(n) {
+  function e(o) {
+    var t;
+    St(this, e), t = It(this, e, [o]), p(t, "setInputRef", function(l) {
+      ut([t.props.inputRef, t.inputRef], l);
+    }), p(t, "isCountrySupportedWithError", function(l) {
+      var u = t.props.metadata;
+      return rt(l, u);
+    }), p(t, "onCountryChange", function(l) {
+      var u = t.props, c = u.international, m = u.metadata, _ = u.onChange, h = u.focusInputOnCountrySelection, O = t.state, N = O.phoneDigits, j = O.country, d = pt(N, {
+        prevCountry: j,
+        newCountry: l,
+        metadata: m,
+        // Convert the phone number to "national" format
+        // when the user changes the selected country by hand.
+        useNationalFormat: !c
+      }), v = ft(d, l, m);
+      h && t.inputRef.current.focus(), t.setState({
+        country: l,
+        latestCountrySelectedByUser: l,
+        hasUserSelectedACountry: !0,
+        phoneDigits: d,
+        value: v
+      }, function() {
+        _(v);
+      });
+    }), p(t, "onChange", function(l) {
+      var u = t.props, c = u.defaultCountry, m = u.onChange, _ = u.addInternationalOption, h = u.international, O = u.limitMaxLength, N = u.countryCallingCodeEditable, j = u.metadata, d = t.state, v = d.countries, T = d.phoneDigits, G = d.country, A = d.latestCountrySelectedByUser, L = yt(l, {
+        prevPhoneDigits: T,
+        country: G,
+        countryRequired: !_,
+        defaultCountry: c,
+        latestCountrySelectedByUser: A,
+        getAnyCountry: function() {
+          return t.getFirstSupportedCountry({
+            countries: v
+          });
+        },
+        countries: v,
+        international: h,
+        limitMaxLength: O,
+        countryCallingCodeEditable: N,
+        metadata: j
+      }), x = L.phoneDigits, H = L.country, E = L.value, M = {
+        phoneDigits: x,
+        value: E,
+        country: H
+      };
+      A && E && !mt(E, A, j) && (M.latestCountrySelectedByUser = void 0), N === !1 && !E && x === t.state.phoneDigits && (M.forceRerender = {}), t.setState(
+        M,
+        // Update the new `value` property.
+        // Doing it after the `state` has been updated
+        // because `onChange()` will trigger `getDerivedStateFromProps()`
+        // with the new `value` which will be compared to `state.value` there.
+        function() {
+          return m(E);
+        }
+      );
+    }), p(t, "_onFocus", function() {
+      return t.setState({
+        isFocused: !0
+      });
+    }), p(t, "_onBlur", function() {
+      return t.setState({
+        isFocused: !1
+      });
+    }), p(t, "onFocus", function(l) {
+      t._onFocus();
+      var u = t.props.onFocus;
+      u && u(l);
+    }), p(t, "onBlur", function(l) {
+      var u = t.props.onBlur;
+      t._onBlur(), u && u(l);
+    }), p(t, "onCountryFocus", function(l) {
+      t._onFocus();
+      var u = t.props.countrySelectProps;
+      if (u) {
+        var c = u.onFocus;
+        c && c(l);
+      }
+    }), p(t, "onCountryBlur", function(l) {
+      t._onBlur();
+      var u = t.props.countrySelectProps;
+      if (u) {
+        var c = u.onBlur;
+        c && c(l);
+      }
+    }), t.inputRef = /* @__PURE__ */ S.createRef();
+    var r = t.props, a = r.value;
+    r.labels;
+    var f = r.international, w = r.addInternationalOption, P = r.displayInitialValueAsLocalNumber, I = r.initialValueFormat, y = r.metadata, C = t.props, s = C.defaultCountry, b = C.countries;
+    s && (t.isCountrySupportedWithError(s) || (s = void 0)), a && et(a), b = it(b, y);
+    var g = dt(a, y);
+    t.CountryIcon = at(t.props);
+    var B = Ct({
+      value: a,
+      phoneNumber: g,
+      defaultCountry: s,
+      required: !w,
+      countries: b || $(y),
+      getAnyCountry: function() {
+        return t.getFirstSupportedCountry({
+          countries: b
+        });
+      },
+      metadata: y
+    });
+    return t.state = {
+      // Workaround for `this.props` inside `getDerivedStateFromProps()`.
+      props: t.props,
+      // The country selected.
+      country: B,
+      // `countries` are stored in `this.state` because they're filtered.
+      // For example, a developer might theoretically pass some unsupported
+      // countries as part of the `countries` property, and because of that
+      // the component uses `this.state.countries` (which are filtered)
+      // instead of `this.props.countries`
+      // (which could potentially contain unsupported countries).
+      countries: b,
+      // `phoneDigits` state property holds non-formatted user's input.
+      // The reason is that there's no way of finding out
+      // in which form should `value` be displayed: international or national.
+      // E.g. if `value` is `+78005553535` then it could be input
+      // by a user both as `8 (800) 555-35-35` and `+7 800 555 35 35`.
+      // Hence storing just `value` is not sufficient for correct formatting.
+      // E.g. if a user entered `8 (800) 555-35-35`
+      // then value is `+78005553535` and `phoneDigits` are `88005553535`
+      // and if a user entered `+7 800 555 35 35`
+      // then value is `+78005553535` and `phoneDigits` are `+78005553535`.
+      phoneDigits: gt({
+        value: a,
+        phoneNumber: g,
+        defaultCountry: s,
+        international: f,
+        useNationalFormat: P || I === "national",
+        metadata: y
+      }),
+      // `value` property is duplicated in state.
+      // The reason is that `getDerivedStateFromProps()`
+      // needs this `value` to compare to the new `value` property
+      // to find out if `phoneDigits` needs updating:
+      // If the `value` property was changed externally
+      // then it won't be equal to `state.value`
+      // in which case `phoneDigits` and `country` should be updated.
+      value: a
+    }, t;
+  }
+  return jt(e, n), Pt(e, [{
+    key: "componentDidMount",
+    value: function() {
+      var t = this.props.onCountryChange, r = this.props.defaultCountry, a = this.state.country;
+      t && (r && (this.isCountrySupportedWithError(r) || (r = void 0)), a !== r && t(a));
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function(t, r) {
+      var a = this.props.onCountryChange, f = this.state.country;
+      a && f !== r.country && a(f);
+    }
+  }, {
+    key: "getCountrySelectOptions",
+    value: function(t) {
+      var r = t.countries, a = this.props, f = a.international, w = a.countryCallingCodeEditable, P = a.countryOptionsOrder, I = a.addInternationalOption, y = a.labels, C = a.locales, s = a.metadata;
+      return this.useMemoCountrySelectOptions(function() {
+        return nt(ct({
+          countries: r || $(s),
+          countryNames: y,
+          addInternationalOption: f && w === !1 ? !1 : I,
+          compareStringsLocales: C
+          // compareStrings
+        }), ot(P, s));
+      }, [r, P, I, y, s]);
+    }
+  }, {
+    key: "useMemoCountrySelectOptions",
+    value: function(t, r) {
+      return (!this.countrySelectOptionsMemoDependencies || !Rt(r, this.countrySelectOptionsMemoDependencies)) && (this.countrySelectOptionsMemo = t(), this.countrySelectOptionsMemoDependencies = r), this.countrySelectOptionsMemo;
+    }
+  }, {
+    key: "getFirstSupportedCountry",
+    value: function(t) {
+      var r = t.countries, a = this.getCountrySelectOptions({
+        countries: r
+      });
+      return a[0].value;
+    }
+  }, {
+    key: "render",
+    value: function() {
+      var t = this.props, r = t.name, a = t.disabled, f = t.readOnly, w = t.autoComplete, P = t.style, I = t.className;
+      t.inputRef;
+      var y = t.inputComponent, C = t.numberInputProps, s = t.smartCaret, b = t.countrySelectComponent, g = t.countrySelectProps, B = t.containerComponent, l = t.containerComponentProps;
+      t.defaultCountry, t.countries, t.countryOptionsOrder;
+      var u = t.labels;
+      t.flags, t.flagComponent, t.flagUrl, t.addInternationalOption, t.internationalIcon, t.displayInitialValueAsLocalNumber, t.initialValueFormat, t.onCountryChange, t.limitMaxLength, t.countryCallingCodeEditable, t.focusInputOnCountrySelection, t.reset;
+      var c = t.metadata, m = t.international;
+      t.locales;
+      var _ = Ot(t, bt), h = this.state, O = h.country, N = h.countries, j = h.phoneDigits, d = h.isFocused, v = s ? J : Q, T = this.getCountrySelectOptions({
+        countries: N
+      });
+      return /* @__PURE__ */ S.createElement(B, D({
+        style: P,
+        className: V(I, "PhoneInput", {
+          "PhoneInput--focus": d,
+          "PhoneInput--disabled": a,
+          "PhoneInput--readOnly": f
+        })
+      }, l), /* @__PURE__ */ S.createElement(b, D({
+        name: r ? "".concat(r, "Country") : void 0,
+        "aria-label": u.country
+      }, g, {
+        value: O,
+        options: T,
+        onChange: this.onCountryChange,
+        onFocus: this.onCountryFocus,
+        onBlur: this.onCountryBlur,
+        disabled: a || g && g.disabled,
+        readOnly: f || g && g.readOnly,
+        iconComponent: this.CountryIcon
+      })), /* @__PURE__ */ S.createElement(v, D({
+        ref: this.setInputRef,
+        type: "tel",
+        autoComplete: w
+      }, C, _, {
+        inputFormat: m === !0 ? "INTERNATIONAL" : m === !1 ? "NATIONAL" : "INTERNATIONAL_OR_NATIONAL",
+        international: m ? !0 : void 0,
+        withCountryCallingCode: m ? !0 : void 0,
+        name: r,
+        metadata: c,
+        country: O,
+        value: j || "",
+        onChange: this.onChange,
+        onFocus: this.onFocus,
+        onBlur: this.onBlur,
+        disabled: a,
+        readOnly: f,
+        inputComponent: y,
+        className: V("PhoneInputInput", C && C.className, _.className)
+      })));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: (
+      // `state` holds previous props as `props`, and also:
+      // * `country` — The currently selected country, e.g. `"RU"`.
+      // * `value` — The currently entered phone number (E.164), e.g. `+78005553535`.
+      // * `phoneDigits` — The parsed `<input/>` value, e.g. `8005553535`.
+      // (and a couple of other less significant properties)
+      function(t, r) {
+        return K({
+          // Emulate `prevProps` via `state.props`.
+          props: t
+        }, ht(t, r.props, r));
+      }
+    )
+  }]);
+})(S.PureComponent), wt = /* @__PURE__ */ S.forwardRef(function(n, e) {
+  return /* @__PURE__ */ S.createElement(Ft, D({}, Et(n), {
+    inputRef: e
+  }));
+});
+wt.propTypes = {
+  /**
+   * Phone number in `E.164` format.
+   *
+   * Example:
+   *
+   * `"+12223333333"`
+   *
+   * Any "falsy" value like `undefined`, `null` or an empty string `""` is treated like "empty".
+   */
+  value: i.string,
+  /**
+   * A function of `value: string?`.
+   *
+   * Updates the `value` property as the user inputs a phone number.
+   *
+   * If the user erases the input value, the argument is `undefined`.
+   */
+  onChange: i.func.isRequired,
+  /**
+   * Toggles the `--focus` CSS class.
+   * @ignore
+   */
+  onFocus: i.func,
+  /**
+   * `onBlur` is usually passed by `redux-form`.
+   * @ignore
+   */
+  onBlur: i.func,
+  /**
+   * Set to `true` to mark both the phone number `<input/>`
+   * and the country `<select/>` as `disabled`.
+   */
+  disabled: i.bool,
+  /**
+   * Set to `true` to mark both the phone number `<input/>`
+   * and the country `<select/>` as `readonly`.
+   */
+  readOnly: i.bool,
+  /**
+   * Sets `autoComplete` property for phone number `<input/>`.
+   *
+   * Web browser's "autocomplete" feature
+   * remembers the phone number being input
+   * and can also autofill the `<input/>`
+   * with previously remembered phone numbers.
+   *
+   * https://developers.google.com
+   * /web/updates/2015/06/checkout-faster-with-autofill
+   *
+   * For example, can be used to turn it off:
+   *
+   * "So when should you use `autocomplete="off"`?
+   *  One example is when you've implemented your own version
+   *  of autocomplete for search. Another example is any form field
+   *  where users will input and submit different kinds of information
+   *  where it would not be useful to have the browser remember
+   *  what was submitted previously".
+   */
+  // (is `"tel"` by default)
+  autoComplete: i.string,
+  /**
+   * Set to `"national"` to show the initial `value` in
+   * "national" format rather than "international".
+   *
+   * For example, if `initialValueFormat` is `"national"`
+   * and the initial `value="+12133734253"` is passed
+   * then the `<input/>` value will be `"(213) 373-4253"`.
+   *
+   * By default, `initialValueFormat` is `undefined`,
+   * meaning that if the initial `value="+12133734253"` is passed
+   * then the `<input/>` value will be `"+1 213 373 4253"`.
+   *
+   * The reason for such default behaviour is that
+   * the newer generation grows up when there are no stationary phones
+   * and therefore everyone inputs phone numbers in international format
+   * in their smartphones so people gradually get more accustomed to
+   * writing phone numbers in international format rather than in local format.
+   * Future people won't be using "national" format, only "international".
+   */
+  // (is `undefined` by default)
+  initialValueFormat: i.oneOf(["national"]),
+  // `displayInitialValueAsLocalNumber` property has been
+  // superceded by `initialValueFormat` property.
+  displayInitialValueAsLocalNumber: i.bool,
+  /**
+   * The country to be selected by default.
+   * For example, can be set after a GeoIP lookup.
+   *
+   * Example: `"US"`.
+   */
+  // A two-letter country code ("ISO 3166-1 alpha-2").
+  defaultCountry: i.string,
+  /**
+   * If specified, only these countries will be available for selection.
+   *
+   * Example:
+   *
+   * `["RU", "UA", "KZ"]`
+   */
+  countries: i.arrayOf(i.string),
+  /**
+   * Custom country `<select/>` option names.
+   * Also some labels like "ext" and country `<select/>` `aria-label`.
+   *
+   * Example:
+   *
+   * `{ "ZZ": "Международный", RU: "Россия", US: "США", ... }`
+   *
+   * See the `locales` directory for examples.
+   */
+  labels: st,
+  /**
+   * Country `<select/>` options are sorted by their labels.
+   * The default sorting function uses `a.localeCompare(b, locales)`,
+   * and, if that's not available, falls back to simple `a > b` / `a < b`.
+   * Some languages, like Chinese, support multiple sorting variants
+   * (called "collations"), and the user might prefer one or another.
+   * Also, sometimes the Operating System language is not always
+   * the preferred language for a person using a website or an application,
+   * so there should be a way to specify custom locale.
+   * This `locales` property mimicks the `locales` argument of `Intl` constructors,
+   * and can be either a Unicode BCP 47 locale identifier or an array of such locale identifiers.
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument
+   */
+  locales: i.oneOfType([i.string, i.arrayOf(i.string)]),
+  /*
+   * Custom country `<select/>` options sorting function.
+   * The default one uses `a.localeCompare(b)`, and,
+   * if that's not available, falls back to simple `a > b`/`a < b`.
+   * There have been requests to add custom sorter for cases
+   * like Chinese language and "pinyin" (non-default) sorting order.
+   * https://stackoverflow.com/questions/22907288/chinese-sorting-by-pinyin-in-javascript-with-localecompare
+  compareStrings: PropTypes.func,
+   */
+  /**
+   * A URL template of a country flag, where
+   * "{XX}" is a two-letter country code in upper case,
+   * or where "{xx}" is a two-letter country code in lower case.
+   * By default it points to `country-flag-icons` gitlab pages website.
+   * I imagine someone might want to download those country flag icons
+   * and host them on their own servers instead
+   * (all flags are available in the `country-flag-icons` library).
+   * There's a catch though: new countries may be added in future,
+   * so when hosting country flag icons on your own server
+   * one should check the `CHANGELOG.md` every time before updating this library,
+   * otherwise there's a possibility that some new country flag would be missing.
+   */
+  flagUrl: i.string,
+  /**
+   * Custom country flag icon components.
+   * These flags will be used instead of the default ones.
+   * The the "Flags" section of the readme for more info.
+   *
+   * The shape is an object where keys are country codes
+   * and values are flag icon components.
+   * Flag icon components receive the same properties
+   * as `flagComponent` (see below).
+   *
+   * Example:
+   *
+   * `{ "RU": (props) => <img src="..."/> }`
+   *
+   * Example:
+   *
+   * `import flags from 'country-flag-icons/react/3x2'`
+   *
+   * `import PhoneInput from 'react-phone-number-input'`
+   *
+   * `<PhoneInput flags={flags} .../>`
+   */
+  flags: i.objectOf(i.elementType),
+  /**
+   * Country flag icon component.
+   *
+   * Takes properties:
+   *
+   * * `country: string` — The country code.
+   * * `countryName: string` — The country name.
+   * * `flagUrl: string` — The `flagUrl` property (see above).
+   * * `flags: object` — The `flags` property (see above).
+   */
+  flagComponent: i.elementType,
+  /**
+   * Set to `false` to remove the "International" option from country `<select/>`.
+   */
+  addInternationalOption: i.bool,
+  /**
+   * "International" icon component.
+   * Should have the same aspect ratio.
+   *
+   * Receives properties:
+   *
+   * * `title: string` — "International" country option label.
+   */
+  internationalIcon: i.elementType,
+  /**
+   * Can be used to place some countries on top of the list of country `<select/>` options.
+   *
+   * * `"XX"` — inserts an option for "XX" country.
+   * * `"🌐"` — inserts "International" option.
+   * * `"|"` — inserts a separator.
+   * * `"..."` — inserts options for the rest of the countries (can be omitted, in which case it will be automatically added at the end).
+   *
+   * Example:
+   *
+   * `["US", "CA", "AU", "|", "..."]`
+   */
+  countryOptionsOrder: i.arrayOf(i.string),
+  /**
+   * `<Phone/>` component CSS style object.
+   */
+  style: i.object,
+  /**
+   * `<Phone/>` component CSS class.
+   */
+  className: i.string,
+  /**
+   * Country `<select/>` component.
+   *
+   * Receives properties:
+   *
+   * * `name: string?` — HTML `name` attribute.
+   * * `value: string?` — The currently selected country code.
+   * * `onChange(value: string?)` — Updates the `value`.
+   * * `onFocus()` — Is used to toggle the `--focus` CSS class.
+   * * `onBlur()` — Is used to toggle the `--focus` CSS class.
+   * * `options: object[]` — The list of all selectable countries (including "International") each being an object of shape `{ value: string?, label: string }`.
+   * * `iconComponent: PropTypes.elementType` — React component that renders a country icon: `<Icon country={value}/>`. If `country` is `undefined` then it renders an "International" icon.
+   * * `disabled: boolean?` — HTML `disabled` attribute.
+   * * `readOnly: boolean?` — HTML `readOnly` attribute.
+   * * `tabIndex: (number|string)?` — HTML `tabIndex` attribute.
+   * * `className: string` — CSS class name.
+   */
+  countrySelectComponent: i.elementType,
+  /**
+   * Country `<select/>` component props.
+   * Along with the usual DOM properties such as `aria-label` and `tabIndex`,
+   * some custom properties are supported, such as `arrowComponent` and `unicodeFlags`.
+   */
+  countrySelectProps: i.object,
+  /**
+   * Phone number `<input/>` component.
+   *
+   * Receives properties:
+   *
+   * * `value: string` — The formatted `value`.
+   * * `onChange(event: Event)` — Updates the formatted `value` from `event.target.value`.
+   * * `onFocus()` — Is used to toggle the `--focus` CSS class.
+   * * `onBlur()` — Is used to toggle the `--focus` CSS class.
+   * * Other properties like `type="tel"` or `autoComplete="tel"` that should be passed through to the DOM `<input/>`.
+   *
+   * Must also either use `React.forwardRef()` to "forward" `ref` to the `<input/>` or implement `.focus()` method.
+   */
+  inputComponent: i.elementType,
+  /**
+   * Phone number `<input/>` component props.
+   */
+  numberInputProps: i.object,
+  /**
+   * Wrapping `<div/>` component.
+   *
+   * Receives properties:
+   *
+   * * `style: object` — A component CSS style object.
+   * * `className: string` — Classes to attach to the component, typically changes when component focuses or blurs.
+   */
+  containerComponent: i.elementType,
+  /**
+   * Wrapping `<div/>` component props.
+   */
+  containerComponentProps: i.object,
+  /**
+   * When the user attempts to insert a digit somewhere in the middle of a phone number,
+   * the caret position is moved right before the next available digit skipping
+   * any punctuation in between. This is called "smart" caret positioning.
+   * Another case would be the phone number format changing as a result of
+   * the user inserting the digit somewhere in the middle, which would require
+   * re-positioning the caret because all digit positions have changed.
+   * This "smart" caret positioning feature can be turned off by passing
+   * `smartCaret={false}` property: use it in case of any possible issues
+   * with caret position during phone number input.
+   */
+  // Is `true` by default.
+  smartCaret: i.bool,
+  /**
+   * Set to `true` to force "international" phone number format.
+   * Set to `false` to force "national" phone number format.
+   * By default it's `undefined` meaning that it doesn't enforce any phone number format:
+   * the user can input their phone number in either "national" or "international" format.
+   */
+  international: i.bool,
+  /**
+   * If set to `true`, the phone number input will get trimmed
+   * if it exceeds the maximum length for the country.
+   */
+  limitMaxLength: i.bool,
+  /**
+   * If set to `false`, and `international` is `true`, then
+   * users won't be able to erase the "country calling part"
+   * of a phone number in the `<input/>`.
+   */
+  countryCallingCodeEditable: i.bool,
+  /**
+   * `libphonenumber-js` metadata.
+   *
+   * Can be used to pass custom `libphonenumber-js` metadata
+   * to reduce the overall bundle size for those who compile "custom" metadata.
+   */
+  metadata: lt,
+  /**
+   * Is called every time the selected country changes:
+   * either programmatically or when user selects it manually from the list.
+   */
+  // People have been asking for a way to get the selected country.
+  // @see  https://github.com/catamphetamine/react-phone-number-input/issues/128
+  // For some it's just a "business requirement".
+  // I guess it's about gathering as much info on the user as a website can
+  // without introducing any addional fields that would complicate the form
+  // therefore reducing "conversion" (that's a marketing term).
+  // Assuming that the phone number's country is the user's country
+  // is not 100% correct but in most cases I guess it's valid.
+  onCountryChange: i.func,
+  /**
+   * If set to `false`, will not focus the `<input/>` component
+   * when the user selects a country from the list of countries.
+   * This can be used to conform to the Web Content Accessibility Guidelines (WCAG).
+   * Quote:
+   * "On input: Changing the setting of any user interface component
+   *  does not automatically cause a change of context unless the user
+   *  has been advised of the behaviour before using the component."
+   */
+  focusInputOnCountrySelection: i.bool
+};
+var q = {
+  /**
+   * Remember (and autofill) the value as a phone number.
+   */
+  autoComplete: "tel",
+  /**
+   * Country `<select/>` component.
+   */
+  countrySelectComponent: Y,
+  /**
+   * Flag icon component.
+   */
+  flagComponent: Z,
+  /**
+   * By default, uses icons from `country-flag-icons` gitlab pages website.
+   */
+  // Must be equal to `flagUrl` in `./CountryIcon.js`.
+  flagUrl: "https://purecatamphetamine.github.io/country-flag-icons/3x2/{XX}.svg",
+  /**
+   * Default "International" country `<select/>` option icon.
+   */
+  internationalIcon: tt,
+  /**
+   * Phone number `<input/>` component.
+   */
+  inputComponent: "input",
+  /**
+   * Wrapping `<div/>` component.
+   */
+  containerComponent: "div",
+  /**
+   * Some users requested a way to reset the component:
+   * both number `<input/>` and country `<select/>`.
+   * Whenever `reset` property changes both number `<input/>`
+   * and country `<select/>` are reset.
+   * It's not implemented as some instance `.reset()` method
+   * because `ref` is forwarded to `<input/>`.
+   * It's also not replaced with just resetting `country` on
+   * external `value` reset, because a user could select a country
+   * and then not input any `value`, and so the selected country
+   * would be "stuck", if not using this `reset` property.
+   */
+  // https://github.com/catamphetamine/react-phone-number-input/issues/300
+  reset: i.any,
+  /**
+   *
+   */
+  /**
+   * Set to `false` to use "basic" caret instead of the "smart" one.
+   */
+  smartCaret: !0,
+  /**
+   * Whether to add the "International" option
+   * to the list of countries.
+   */
+  addInternationalOption: !0,
+  /**
+   * If set to `false`, and `international` is `true`, then
+   * users won't be able to erase the "country calling part"
+   * of a phone number in the `<input/>`.
+   */
+  countryCallingCodeEditable: !0,
+  /**
+   * If set to `false`, will not focus the `<input/>` component
+   * when the user selects a country from the list of countries.
+   * This can be used to conform to the Web Content Accessibility Guidelines (WCAG).
+   * Quote:
+   * "On input: Changing the setting of any user interface component
+   *  does not automatically cause a change of context unless the user
+   *  has been advised of the behaviour before using the component."
+   */
+  focusInputOnCountrySelection: !0
+};
+function Et(n) {
+  n = K({}, n);
+  for (var e in q)
+    n[e] === void 0 && (n[e] = q[e]);
+  return n;
+}
+function Rt(n, e) {
+  if (n.length !== e.length)
+    return !1;
+  for (var o = 0; o < n.length; ) {
+    if (n[o] !== e[o])
+      return !1;
+    o++;
+  }
+  return !0;
+}
+export {
+  wt as default
+};