@saasquatch/mint-components 2.3.0-11 → 2.3.0-13

package/dist/esm/subregions-7c5112e8.js

@@ -0,0 +1,1055 @@
+import { h } from './index-38ad4957.js';
+import { i as intl } from './global-75e96214.js';
+import { c as createStyleSheet } from './JSS-67b5cff8.js';
+import { m as metadata, c as createExtensionPattern, p as parseDigit, M as Metadata, a as MIN_LENGTH_FOR_NSN, b as MAX_LENGTH_FOR_NSN, P as PhoneNumber, d as matchesEntirely, i as isPossibleNumber, e as parseRFC3966, f as isViablePhoneNumber, g as extractCountryCallingCode, h as getCountryCallingCode, j as extractNationalNumber, k as getCountryByCallingCode, l as PLUS_CHARS, V as VALID_DIGITS, n as isSupportedCountry } from './AsYouType-2d56519e.js';
+
+// Importing from `.json.js` a workaround for a bug in web browsers' "native"
+
+function withMetadata(func, _arguments) {
+	var args = Array.prototype.slice.call(_arguments);
+	args.push(metadata);
+	return func.apply(this, args)
+}
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+// https://stackoverflow.com/a/46971044/970769
+var ParseError = function ParseError(code) {
+  _classCallCheck(this, ParseError);
+
+  this.name = this.constructor.name;
+  this.message = code;
+  this.stack = new Error(code).stack;
+};
+ParseError.prototype = Object.create(Error.prototype);
+ParseError.prototype.constructor = ParseError;
+
+// 1 or more valid digits, for use when parsing.
+
+var EXTN_PATTERN = new RegExp('(?:' + createExtensionPattern() + ')$', 'i'); // Strips any extension (as in, the part of the number dialled after the call is
+// connected, usually indicated with extn, ext, x or similar) from the end of
+// the number, and returns it.
+
+function extractExtension(number) {
+  var start = number.search(EXTN_PATTERN);
+
+  if (start < 0) {
+    return {};
+  } // If we find a potential extension, and the number preceding this is a viable
+  // number, we assume it is an extension.
+
+
+  var numberWithoutExtension = number.slice(0, start);
+  var matches = number.match(EXTN_PATTERN);
+  var i = 1;
+
+  while (i < matches.length) {
+    if (matches[i]) {
+      return {
+        number: numberWithoutExtension,
+        ext: matches[i]
+      };
+    }
+
+    i++;
+  }
+}
+
+/**
+ * Parses phone number characters from a string.
+ * Drops all punctuation leaving only digits and the leading `+` sign (if any).
+ * Also converts wide-ascii and arabic-indic numerals to conventional numerals.
+ * E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.
+ * @param  {string} string
+ * @return {string}
+ * @example
+ * ```js
+ * // Outputs '8800555'.
+ * parseIncompletePhoneNumber('8 (800) 555')
+ * // Outputs '+7800555'.
+ * parseIncompletePhoneNumber('+7 800 555')
+ * ```
+ */
+
+function parseIncompletePhoneNumber(string) {
+  var result = ''; // Using `.split('')` here instead of normal `for ... of`
+  // because the importing application doesn't neccessarily include an ES6 polyfill.
+  // The `.split('')` approach discards "exotic" UTF-8 characters
+  // (the ones consisting of four bytes) but digits
+  // (including non-European ones) don't fall into that range
+  // so such "exotic" characters would be discarded anyway.
+
+  for (var _iterator = string.split(''), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref = _i.value;
+    }
+
+    var character = _ref;
+    result += parsePhoneNumberCharacter(character, result) || '';
+  }
+
+  return result;
+}
+/**
+ * Parses next character while parsing phone number digits (including a `+`)
+ * from text: discards everything except `+` and digits, and `+` is only allowed
+ * at the start of a phone number.
+ * For example, is used in `react-phone-number-input` where it uses
+ * [`input-format`](https://gitlab.com/catamphetamine/input-format).
+ * @param  {string} character - Yet another character from raw input string.
+ * @param  {string?} prevParsedCharacters - Previous parsed characters.
+ * @param  {object} meta - Optional custom use-case-specific metadata.
+ * @return {string?} The parsed character.
+ */
+
+function parsePhoneNumberCharacter(character, prevParsedCharacters) {
+  // Only allow a leading `+`.
+  if (character === '+') {
+    // If this `+` is not the first parsed character
+    // then discard it.
+    if (prevParsedCharacters) {
+      return;
+    }
+
+    return '+';
+  } // Allow digits.
+
+
+  return parseDigit(character);
+}
+
+// This is a port of Google Android `libphonenumber`'s
+// This prevents malicious input from consuming CPU.
+
+var MAX_INPUT_STRING_LENGTH = 250; // This consists of the plus symbol, digits, and arabic-indic digits.
+
+var PHONE_NUMBER_START_PATTERN = new RegExp('[' + PLUS_CHARS + VALID_DIGITS + ']'); // Regular expression of trailing characters that we want to remove.
+// A trailing `#` is sometimes used when writing phone numbers with extensions in US.
+// Example: "+1 (645) 123 1234-910#" number has extension "910".
+
+var AFTER_PHONE_NUMBER_END_PATTERN = new RegExp('[^' + VALID_DIGITS + '#' + ']+$');
+//
+// ```js
+// parse('8 (800) 555-35-35', 'RU')
+// parse('8 (800) 555-35-35', 'RU', metadata)
+// parse('8 (800) 555-35-35', { country: { default: 'RU' } })
+// parse('8 (800) 555-35-35', { country: { default: 'RU' } }, metadata)
+// parse('+7 800 555 35 35')
+// parse('+7 800 555 35 35', metadata)
+// ```
+//
+
+function parse(text, options, metadata) {
+  // If assigning the `{}` default value is moved to the arguments above,
+  // code coverage would decrease for some weird reason.
+  options = options || {};
+  metadata = new Metadata(metadata); // Validate `defaultCountry`.
+
+  if (options.defaultCountry && !metadata.hasCountry(options.defaultCountry)) {
+    if (options.v2) {
+      throw new ParseError('INVALID_COUNTRY');
+    }
+
+    throw new Error("Unknown country: ".concat(options.defaultCountry));
+  } // Parse the phone number.
+
+
+  var _parseInput = parseInput(text, options.v2, options.extract),
+      formattedPhoneNumber = _parseInput.number,
+      ext = _parseInput.ext; // If the phone number is not viable then return nothing.
+
+
+  if (!formattedPhoneNumber) {
+    if (options.v2) {
+      throw new ParseError('NOT_A_NUMBER');
+    }
+
+    return {};
+  }
+
+  var _parsePhoneNumber = parsePhoneNumber(formattedPhoneNumber, options.defaultCountry, options.defaultCallingCode, metadata),
+      country = _parsePhoneNumber.country,
+      nationalNumber = _parsePhoneNumber.nationalNumber,
+      countryCallingCode = _parsePhoneNumber.countryCallingCode,
+      carrierCode = _parsePhoneNumber.carrierCode;
+
+  if (!metadata.hasSelectedNumberingPlan()) {
+    if (options.v2) {
+      throw new ParseError('INVALID_COUNTRY');
+    }
+
+    return {};
+  } // Validate national (significant) number length.
+
+
+  if (!nationalNumber || nationalNumber.length < MIN_LENGTH_FOR_NSN) {
+    // Won't throw here because the regexp already demands length > 1.
+
+    /* istanbul ignore if */
+    if (options.v2) {
+      throw new ParseError('TOO_SHORT');
+    } // Google's demo just throws an error in this case.
+
+
+    return {};
+  } // Validate national (significant) number length.
+  //
+  // A sidenote:
+  //
+  // They say that sometimes national (significant) numbers
+  // can be longer than `MAX_LENGTH_FOR_NSN` (e.g. in Germany).
+  // https://github.com/googlei18n/libphonenumber/blob/7e1748645552da39c4e1ba731e47969d97bdb539/resources/phonenumber.proto#L36
+  // Such numbers will just be discarded.
+  //
+
+
+  if (nationalNumber.length > MAX_LENGTH_FOR_NSN) {
+    if (options.v2) {
+      throw new ParseError('TOO_LONG');
+    } // Google's demo just throws an error in this case.
+
+
+    return {};
+  }
+
+  if (options.v2) {
+    var phoneNumber = new PhoneNumber(countryCallingCode, nationalNumber, metadata.metadata);
+
+    if (country) {
+      phoneNumber.country = country;
+    }
+
+    if (carrierCode) {
+      phoneNumber.carrierCode = carrierCode;
+    }
+
+    if (ext) {
+      phoneNumber.ext = ext;
+    }
+
+    return phoneNumber;
+  } // Check if national phone number pattern matches the number.
+  // National number pattern is different for each country,
+  // even for those ones which are part of the "NANPA" group.
+
+
+  var valid = (options.extended ? metadata.hasSelectedNumberingPlan() : country) ? matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) : false;
+
+  if (!options.extended) {
+    return valid ? result(country, nationalNumber, ext) : {};
+  } // isInternational: countryCallingCode !== undefined
+
+
+  return {
+    country: country,
+    countryCallingCode: countryCallingCode,
+    carrierCode: carrierCode,
+    valid: valid,
+    possible: valid ? true : options.extended === true && metadata.possibleLengths() && isPossibleNumber(nationalNumber, metadata) ? true : false,
+    phone: nationalNumber,
+    ext: ext
+  };
+}
+/**
+ * Extracts a formatted phone number from text.
+ * Doesn't guarantee that the extracted phone number
+ * is a valid phone number (for example, doesn't validate its length).
+ * @param  {string} text
+ * @param  {boolean} [extract] — If `false`, then will parse the entire `text` as a phone number.
+ * @param  {boolean} [throwOnError] — By default, it won't throw if the text is too long.
+ * @return {string}
+ * @example
+ * // Returns "(213) 373-4253".
+ * extractFormattedPhoneNumber("Call (213) 373-4253 for assistance.")
+ */
+
+function extractFormattedPhoneNumber(text, extract, throwOnError) {
+  if (!text) {
+    return;
+  }
+
+  if (text.length > MAX_INPUT_STRING_LENGTH) {
+    if (throwOnError) {
+      throw new ParseError('TOO_LONG');
+    }
+
+    return;
+  }
+
+  if (extract === false) {
+    return text;
+  } // Attempt to extract a possible number from the string passed in
+
+
+  var startsAt = text.search(PHONE_NUMBER_START_PATTERN);
+
+  if (startsAt < 0) {
+    return;
+  }
+
+  return text // Trim everything to the left of the phone number
+  .slice(startsAt) // Remove trailing non-numerical characters
+  .replace(AFTER_PHONE_NUMBER_END_PATTERN, '');
+}
+/**
+ * @param  {string} text - Input.
+ * @param  {boolean} v2 - Legacy API functions don't pass `v2: true` flag.
+ * @param  {boolean} [extract] - Whether to extract a phone number from `text`, or attempt to parse the entire text as a phone number.
+ * @return {object} `{ ?number, ?ext }`.
+ */
+
+
+function parseInput(text, v2, extract) {
+  // Parse RFC 3966 phone number URI.
+  if (text && text.indexOf('tel:') === 0) {
+    return parseRFC3966(text);
+  }
+
+  var number = extractFormattedPhoneNumber(text, extract, v2); // If the phone number is not viable, then abort.
+
+  if (!number || !isViablePhoneNumber(number)) {
+    return {};
+  } // Attempt to parse extension first, since it doesn't require region-specific
+  // data and we want to have the non-normalised number here.
+
+
+  var withExtensionStripped = extractExtension(number);
+
+  if (withExtensionStripped.ext) {
+    return withExtensionStripped;
+  }
+
+  return {
+    number: number
+  };
+}
+/**
+ * Creates `parse()` result object.
+ */
+
+
+function result(country, nationalNumber, ext) {
+  var result = {
+    country: country,
+    phone: nationalNumber
+  };
+
+  if (ext) {
+    result.ext = ext;
+  }
+
+  return result;
+}
+/**
+ * Parses a viable phone number.
+ * @param {string} formattedPhoneNumber — Example: "(213) 373-4253".
+ * @param {string} [defaultCountry]
+ * @param {string} [defaultCallingCode]
+ * @param {Metadata} metadata
+ * @return {object} Returns `{ country: string?, countryCallingCode: string?, nationalNumber: string? }`.
+ */
+
+
+function parsePhoneNumber(formattedPhoneNumber, defaultCountry, defaultCallingCode, metadata) {
+  // Extract calling code from phone number.
+  var _extractCountryCallin = extractCountryCallingCode(parseIncompletePhoneNumber(formattedPhoneNumber), defaultCountry, defaultCallingCode, metadata.metadata),
+      countryCallingCode = _extractCountryCallin.countryCallingCode,
+      number = _extractCountryCallin.number; // Choose a country by `countryCallingCode`.
+
+
+  var country;
+
+  if (countryCallingCode) {
+    metadata.selectNumberingPlan(countryCallingCode);
+  } // If `formattedPhoneNumber` is in "national" format
+  // then `number` is defined and `countryCallingCode` isn't.
+  else if (number && (defaultCountry || defaultCallingCode)) {
+      metadata.selectNumberingPlan(defaultCountry, defaultCallingCode);
+
+      if (defaultCountry) {
+        country = defaultCountry;
+      }
+
+      countryCallingCode = defaultCallingCode || getCountryCallingCode(defaultCountry, metadata.metadata);
+    } else return {};
+
+  if (!number) {
+    return {
+      countryCallingCode: countryCallingCode
+    };
+  }
+
+  var _extractNationalNumbe = extractNationalNumber(parseIncompletePhoneNumber(number), metadata),
+      nationalNumber = _extractNationalNumbe.nationalNumber,
+      carrierCode = _extractNationalNumbe.carrierCode; // Sometimes there are several countries
+  // corresponding to the same country phone code
+  // (e.g. NANPA countries all having `1` country phone code).
+  // Therefore, to reliably determine the exact country,
+  // national (significant) number should have been parsed first.
+  //
+  // When `metadata.json` is generated, all "ambiguous" country phone codes
+  // get their countries populated with the full set of
+  // "phone number type" regular expressions.
+  //
+
+
+  var exactCountry = getCountryByCallingCode(countryCallingCode, nationalNumber, metadata);
+
+  if (exactCountry) {
+    country = exactCountry;
+    /* istanbul ignore if */
+
+    if (exactCountry === '001') ; else {
+      metadata.country(country);
+    }
+  }
+
+  return {
+    country: country,
+    countryCallingCode: countryCallingCode,
+    nationalNumber: nationalNumber,
+    carrierCode: carrierCode
+  };
+}
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function parsePhoneNumber$1(text, options, metadata) {
+  return parse(text, _objectSpread({}, options, {
+    v2: true
+  }), metadata);
+}
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } return target; }
+
+function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function normalizeArguments(args) {
+  var _Array$prototype$slic = Array.prototype.slice.call(args),
+      _Array$prototype$slic2 = _slicedToArray(_Array$prototype$slic, 4),
+      arg_1 = _Array$prototype$slic2[0],
+      arg_2 = _Array$prototype$slic2[1],
+      arg_3 = _Array$prototype$slic2[2],
+      arg_4 = _Array$prototype$slic2[3];
+
+  var text;
+  var options;
+  var metadata; // If the phone number is passed as a string.
+  // `parsePhoneNumber('88005553535', ...)`.
+
+  if (typeof arg_1 === 'string') {
+    text = arg_1;
+  } else throw new TypeError('A text for parsing must be a string.'); // If "default country" argument is being passed then move it to `options`.
+  // `parsePhoneNumber('88005553535', 'RU', [options], metadata)`.
+
+
+  if (!arg_2 || typeof arg_2 === 'string') {
+    if (arg_4) {
+      options = arg_3;
+      metadata = arg_4;
+    } else {
+      options = undefined;
+      metadata = arg_3;
+    }
+
+    if (arg_2) {
+      options = _objectSpread$1({
+        defaultCountry: arg_2
+      }, options);
+    }
+  } // `defaultCountry` is not passed.
+  // Example: `parsePhoneNumber('+78005553535', [options], metadata)`.
+  else if (isObject(arg_2)) {
+      if (arg_3) {
+        options = arg_2;
+        metadata = arg_3;
+      } else {
+        metadata = arg_2;
+      }
+    } else throw new Error("Invalid second argument: ".concat(arg_2));
+
+  return {
+    text: text,
+    options: options,
+    metadata: metadata
+  };
+} // Otherwise istanbul would show this as "branch not covered".
+
+/* istanbul ignore next */
+
+var isObject = function isObject(_) {
+  return _typeof(_) === 'object';
+};
+
+function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } return target; }
+
+function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function parsePhoneNumberFromString(text, options, metadata) {
+  // Validate `defaultCountry`.
+  if (options && options.defaultCountry && !isSupportedCountry(options.defaultCountry, metadata)) {
+    options = _objectSpread$2({}, options, {
+      defaultCountry: undefined
+    });
+  } // Parse phone number.
+
+
+  try {
+    return parsePhoneNumber$1(text, options, metadata);
+  } catch (error) {
+    /* istanbul ignore else */
+    if (error instanceof ParseError) ; else {
+      throw error;
+    }
+  }
+}
+
+function parsePhoneNumberFromString$1() {
+  var _normalizeArguments = normalizeArguments(arguments),
+      text = _normalizeArguments.text,
+      options = _normalizeArguments.options,
+      metadata = _normalizeArguments.metadata;
+
+  return parsePhoneNumberFromString(text, options, metadata);
+}
+
+function parsePhoneNumberFromString$2() {
+	return withMetadata(parsePhoneNumberFromString$1, arguments)
+}
+
+/**
+ * Normalize user input to the domestic form Impact stores: digits only,
+ * with the country dial code and trunk-zero prefix removed.
+ */
+function toDomesticNumber(phoneCountryCode, input) {
+  var _a;
+  if (!input)
+    return "";
+  const parsed = parsePhoneNumberFromString$2(input, phoneCountryCode === null || phoneCountryCode === void 0 ? void 0 : phoneCountryCode.toUpperCase());
+  return (_a = parsed === null || parsed === void 0 ? void 0 : parsed.nationalNumber) !== null && _a !== void 0 ? _a : input.replace(/\D/g, "");
+}
+/**
+ * Validates a phone number against both libphonenumber-js's per-country
+ * pattern rules AND Impact's I18nPhoneNumber length rules, applied to the
+ * sanitized value we'll submit.
+ */
+function isValidI18nPhoneNumber(phoneCountryCode, phoneNumber) {
+  if (!phoneCountryCode || !(phoneNumber === null || phoneNumber === void 0 ? void 0 : phoneNumber.trim()))
+    return false;
+  const country = phoneCountryCode.toUpperCase();
+  const parsed = parsePhoneNumberFromString$2(phoneNumber, country);
+  if (!(parsed === null || parsed === void 0 ? void 0 : parsed.isValid()))
+    return false;
+  return passesImpactBackendLengthCheck(country, toDomesticNumber(country, phoneNumber));
+}
+/**
+ * Mirrors estalea.bucket.phone.I18nPhoneNumber.isValidI18nPhoneNumber()
+ * length rules on the already-sanitized (digits-only) submission value.
+ */
+function passesImpactBackendLengthCheck(country, digits) {
+  if (!digits)
+    return false;
+  switch (country) {
+    case "US":
+    case "CA": {
+      const n = digits.startsWith("1") ? digits.slice(1) : digits;
+      return n.length === 10;
+    }
+    case "AU":
+      return digits.length === 9 || digits.length === 10;
+    case "NZ": {
+      let n = digits;
+      if (n.length > 9) {
+        if (n.startsWith("640"))
+          n = n.slice(3);
+        else if (n.startsWith("0"))
+          n = n.slice(1);
+      }
+      return n.length >= 8 && n.length <= 10;
+    }
+    default:
+      return stripLeadingZero(digits).length >= 6;
+  }
+}
+function stripLeadingZero(digits) {
+  return digits.startsWith("0") ? digits.slice(1) : digits;
+}
+function validTaxDocument(requiredType) {
+  const validTypes = ["W9", "W8BENE", "W8BEN"];
+  if (validTypes.includes(requiredType))
+    return true;
+  return false;
+}
+const objectIsFull = (obj) => {
+  return !Object.keys(obj).find((k) => obj[k] == undefined);
+};
+const taxTypeToName = (taxType) => {
+  switch (taxType) {
+    case "W9":
+      return "W-9";
+    case "W8BEN":
+    case "W8BENE":
+      return "W-8";
+    default:
+      return "";
+  }
+};
+function validateBillingField(regex, value) {
+  const trimmed = value.trim();
+  const idx = trimmed.search(regex);
+  return idx > -1;
+}
+const formatErrorMessage = (fieldName, errorMessage) => {
+  return intl.formatMessage({
+    id: fieldName,
+    defaultMessage: errorMessage,
+  }, {
+    fieldName,
+  });
+};
+function getCountryObj({ countryCode, locale, }) {
+  // @ts-ignore DisplayNames not in Intl type
+  const displayName = new Intl.DisplayNames([locale], {
+    type: "region",
+  }).of(countryCode);
+  return {
+    countryCode,
+    displayName,
+  };
+}
+
+const style = {
+  Container: {
+    display: "flex",
+    flexDirection: "column",
+    gap: "35px",
+  },
+  HeaderContainer: {
+    display: "flex",
+    flexDirection: "column",
+    gap: "10px",
+  },
+};
+const sheet = createStyleSheet(style);
+const styleString = sheet.toString();
+const LoadingView = () => {
+  return (h("div", { class: sheet.classes.Container },
+    h("style", { type: "text/css" }, styleString),
+    h("sqm-skeleton", { width: "45%", height: "40px !important" }),
+    h("div", { class: sheet.classes.HeaderContainer },
+      h("sqm-skeleton", { width: "15%" }),
+      h("sqm-skeleton", { width: "25%", height: "30px !important" })),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "75%", height: "35px" }),
+    h("sqm-skeleton", { width: "15%" }),
+    h("sqm-skeleton", { width: "80px", height: "30px !important" })));
+};
+
+const INDIRECT_TAX_PROVINCES = [
+  { regionCode: "ALBERTA", taxType: "GST", displayName: "Alberta" },
+  {
+    regionCode: "BRITISHCOLUMBIA",
+    taxType: "HST",
+    displayName: "British Columbia",
+  },
+  { regionCode: "MANITOBA", taxType: "HST", displayName: "Manitoba" },
+  {
+    regionCode: "NEWBRUNSWICK",
+    taxType: "HST",
+    displayName: "New Brunswick",
+  },
+  {
+    regionCode: "NEWFOUNDLANDLABRADOR",
+    taxType: "HST",
+    displayName: "Newfoundland",
+  },
+  {
+    regionCode: "NORTHWESTTERRITORIES",
+    taxType: "GST",
+    displayName: "North West Territories",
+  },
+  { regionCode: "NOVASCOTIA", taxType: "HST", displayName: "Nova Scotia" },
+  { regionCode: "NUNAVUT", taxType: "HST", displayName: "Nunavut" },
+  { regionCode: "ONTARIO", taxType: "HST", displayName: "Ontario" },
+  {
+    regionCode: "PRINCEEDWARDISLAND",
+    taxType: "HST",
+    displayName: "Prince Edward Island",
+  },
+  { regionCode: "QUEBEC", taxType: "GST", displayName: "Quebec" },
+  { regionCode: "SASKATCHEWAN", taxType: "HST", displayName: "Saskatchewan" },
+  { regionCode: "YUKON", taxType: "GST", displayName: "Yukon" },
+];
+const INDIRECT_TAX_SPAIN_REGIONS = [
+  { regionCode: "SPAINPROPER", taxType: "VAT", displayName: "Spain Proper" },
+  {
+    regionCode: "CANARYISLANDS",
+    taxType: "VAT",
+    displayName: "Canary Islands",
+  },
+];
+const ADDRESS_REGIONS = {
+  CA: {
+    labelEnum: "PROVINCE",
+    regions: [
+      {
+        label: "Alberta",
+        value: "ALBERTA",
+      },
+      {
+        label: "British Columbia",
+        value: "BRITISHCOLUMBIA",
+      },
+      {
+        label: "Manitoba",
+        value: "MANITOBA",
+      },
+      {
+        label: "New Brunswick",
+        value: "NEWBRUNSWICK",
+      },
+      {
+        label: "Newfoundland & Labrador",
+        value: "NEWFOUNDLANDANDLABRADOR",
+      },
+      {
+        label: "Northwest Territories",
+        value: "NORTHWESTTERRITORIES",
+      },
+      {
+        label: "Nova Scotia",
+        value: "NOVASCOTIA",
+      },
+      {
+        label: "Nunavut",
+        value: "NUNAVUT",
+      },
+      {
+        label: "Ontario",
+        value: "ONTARIO",
+      },
+      {
+        label: "Prince Edward Island",
+        value: "PRINCEEDWARDISLAND",
+      },
+      {
+        label: "Quebec",
+        value: "QUEBEC",
+      },
+      {
+        label: "Saskatchewan",
+        value: "SASKATCHEWAN",
+      },
+      {
+        label: "Yukon",
+        value: "YUKON",
+      },
+    ],
+  },
+  ES: {
+    labelEnum: "REGION",
+    regions: [
+      {
+        label: "Canary Islands",
+        value: "CANARYISLANDS",
+      },
+      {
+        label: "Spain Proper",
+        value: "SPAINPROPER",
+      },
+    ],
+  },
+  AU: {
+    labelEnum: "STATE",
+    regions: [
+      {
+        label: "Australian Capital Territory",
+        value: "CAPITALTERRITORY",
+      },
+      {
+        label: "New South Wales",
+        value: "NEWSOUTHWALES",
+      },
+      {
+        label: "Northern Territory",
+        value: "NORTHERNTERRITORY",
+      },
+      {
+        label: "Queensland",
+        value: "QUEENSLAND",
+      },
+      {
+        label: "South Australia",
+        value: "SOUTHAUSTRALIA",
+      },
+      {
+        label: "Tasmania",
+        value: "TASMANIA",
+      },
+      {
+        label: "Victoria",
+        value: "VICTORIA",
+      },
+      {
+        label: "Western Australia",
+        value: "WESTERNAUSTRALIA",
+      },
+    ],
+  },
+  US: {
+    labelEnum: "STATE",
+    regions: [
+      {
+        label: "Alabama",
+        value: "ALABAMA",
+      },
+      {
+        label: "Alaska",
+        value: "ALASKA",
+      },
+      {
+        label: "Arizona",
+        value: "ARIZONA",
+      },
+      {
+        label: "Arkansas",
+        value: "ARKANSAS",
+      },
+      {
+        label: "California",
+        value: "CALIFORNIA",
+      },
+      {
+        label: "Colorado",
+        value: "COLORADO",
+      },
+      {
+        label: "Connecticut",
+        value: "CONNECTICUT",
+      },
+      {
+        label: "Delaware",
+        value: "DELAWARE",
+      },
+      {
+        label: "District of Columbia",
+        value: "DISTRICTOFCOLUMBIA",
+      },
+      {
+        label: "Florida",
+        value: "FLORIDA",
+      },
+      {
+        label: "Georgia",
+        value: "GEORGIA",
+      },
+      {
+        label: "Hawaii",
+        value: "HAWAII",
+      },
+      {
+        label: "Idaho",
+        value: "IDAHO",
+      },
+      {
+        label: "Illinois",
+        value: "ILLINOIS",
+      },
+      {
+        label: "Indiana",
+        value: "INDIANA",
+      },
+      {
+        label: "Iowa",
+        value: "IOWA",
+      },
+      {
+        label: "Kansas",
+        value: "KANSAS",
+      },
+      {
+        label: "Kentucky",
+        value: "KENTUCKY",
+      },
+      {
+        label: "Louisiana",
+        value: "LOUISIANA",
+      },
+      {
+        label: "Maine",
+        value: "MAINE",
+      },
+      {
+        label: "Maryland",
+        value: "MARYLAND",
+      },
+      {
+        label: "Massachusetts",
+        value: "MASSACHUSETTS",
+      },
+      {
+        label: "Michigan",
+        value: "MICHIGAN",
+      },
+      {
+        label: "Minnesota",
+        value: "MINNESOTA",
+      },
+      {
+        label: "Mississippi",
+        value: "MISSISSIPPI",
+      },
+      {
+        label: "Missouri",
+        value: "MISSOURI",
+      },
+      {
+        label: "Montana",
+        value: "MONTANA",
+      },
+      {
+        label: "Nebraska",
+        value: "NEBRASKA",
+      },
+      {
+        label: "Nevada",
+        value: "NEVADA",
+      },
+      {
+        label: "New Hampshire",
+        value: "NEWHAMPSHIRE",
+      },
+      {
+        label: "New Jersey",
+        value: "NEWJERSEY",
+      },
+      {
+        label: "New Mexico",
+        value: "NEWMEXICO",
+      },
+      {
+        label: "New York",
+        value: "NEWYORK",
+      },
+      {
+        label: "North Carolina",
+        value: "NORTHCAROLINA",
+      },
+      {
+        label: "North Dakota",
+        value: "NORTHDAKOTA",
+      },
+      {
+        label: "Ohio",
+        value: "OHIO",
+      },
+      {
+        label: "Oklahoma",
+        value: "OKLAHOMA",
+      },
+      {
+        label: "Oregon",
+        value: "OREGON",
+      },
+      {
+        label: "Pennsylvania",
+        value: "PENNSYLVANIA",
+      },
+      {
+        label: "Rhode Island",
+        value: "RHODEISLAND",
+      },
+      {
+        label: "South Carolina",
+        value: "SOUTHCAROLINA",
+      },
+      {
+        label: "South Dakota",
+        value: "SOUTHDAKOTA",
+      },
+      {
+        label: "Tennessee",
+        value: "TENNESSEE",
+      },
+      {
+        label: "Texas",
+        value: "TEXAS",
+      },
+      {
+        label: "Utah",
+        value: "UTAH",
+      },
+      {
+        label: "Vermont",
+        value: "VERMONT",
+      },
+      {
+        label: "Virgin Islands",
+        value: "VIRGINISLANDS",
+      },
+      {
+        label: "Virginia",
+        value: "VIRGINIA",
+      },
+      {
+        label: "Washington",
+        value: "WASHINGTON",
+      },
+      {
+        label: "West Virginia",
+        value: "WESTVIRGINIA",
+      },
+      {
+        label: "Wisconsin",
+        value: "WISCONSIN",
+      },
+      {
+        label: "Wyoming",
+        value: "WYOMING",
+      },
+      {
+        label: "Americas Forces",
+        value: "AAMILITARY",
+      },
+      {
+        label: "Europe, Middle East, Canada, Africa and Canada Forces",
+        value: "AEMILITARY",
+      },
+      {
+        label: "Pacific Forces",
+        value: "APMILITARY",
+      },
+      {
+        label: "Other",
+        value: "OTHER",
+      },
+    ],
+  },
+};
+
+export { ADDRESS_REGIONS as A, INDIRECT_TAX_SPAIN_REGIONS as I, LoadingView as L, INDIRECT_TAX_PROVINCES as a, validTaxDocument as b, toDomesticNumber as c, formatErrorMessage as f, getCountryObj as g, isValidI18nPhoneNumber as i, objectIsFull as o, taxTypeToName as t, validateBillingField as v };