ingeniuscliq-core 0.5.38 → 0.5.40

package/dist/node_modules/libphonenumber-js/es6/helpers/checkNumberLength.js

@@ -1,82 +0,0 @@
-import Metadata from '../metadata.js';
-
-function checkNumberLength(nationalNumber, country, metadata) {
-  return checkNumberLengthForType(nationalNumber, country, undefined, metadata);
-}
-
-// Checks whether a number is possible for a certain `country` based on the number length.
-//
-// This function is not supported by metadata generated with ancient versions of
-// `libphonenumber-js` (before version `1.0.18`) which didn't include "possible lengths".
-//
-// There was also a known issue with `checkNumberLength()` function:
-// if a number is possible only in a certain `country` among several `countries`
-// that share the same "country calling code", that function would check
-// the possibility of the phone number only in the "main" `country` for the "country calling code"
-// and would not check if it's actually be possible in the speciifc `country`.
-//
-// For example, "+1310xxxx" numbers are valid in Canada.
-// However, they are not possible in the US due to being too short.
-// Since Canada and the US share the same country calling code — "+1" —
-// `checkNumberLength()` function used to return not "IS_POSSIBLE" for "+1310xxxx" numbers.
-//
-// In such cases, when using "/max" metadata, `isValid()` could output `true`
-// but at the same time `isPossible()` could output `false`, which was contradictory.
-//
-// See https://issuetracker.google.com/issues/335892662 for the discusson in Google's issues.
-//
-// The solution suggested by Google was implemented: an optional `country` argument
-// was added to `checkNumberLength()` function. If present, that `country` will be used
-// to check phone number length for that specific `country` rather than the "main" country
-// for the shared "country calling code".
-//
-function checkNumberLengthForType(nationalNumber, country, type, metadata) {
-  // If the exact `country` is specified, it's no necessarily already selected in `metadata`.
-  // Most likely, in cases when there're multiple countries corresponding to the same
-  // "country calling code", the "main" country for that "country calling code" will be selected.
-  if (country) {
-    metadata = new Metadata(metadata.metadata);
-    metadata.selectNumberingPlan(country);
-  }
-  var type_info = metadata.type(type);
-
-  // There should always be "<possiblePengths/>" set for every type element.
-  // This is declared in the XML schema.
-  // For size efficiency, where a sub-description (e.g. fixed-line)
-  // has the same "<possiblePengths/>" as the "general description", this is missing,
-  // so we fall back to the "general description". Where no numbers of the type
-  // exist at all, there is one possible length (-1) which is guaranteed
-  // not to match the length of any real phone number.
-  var possible_lengths = type_info && type_info.possibleLengths() || metadata.possibleLengths();
-  // let local_lengths = type_info && type.possibleLengthsLocal() || metadata.possibleLengthsLocal()
-
-  // Metadata before version `1.0.18` didn't contain `possible_lengths`.
-  if (!possible_lengths) {
-    return 'IS_POSSIBLE';
-  }
-  var actual_length = nationalNumber.length;
-
-  // In `libphonenumber-js` all "local-only" formats are dropped for simplicity.
-  // // This is safe because there is never an overlap beween the possible lengths
-  // // and the local-only lengths; this is checked at build time.
-  // if (local_lengths && local_lengths.indexOf(nationalNumber.length) >= 0)
-  // {
-  // 	return 'IS_POSSIBLE_LOCAL_ONLY'
-  // }
-
-  var minimum_length = possible_lengths[0];
-  if (minimum_length === actual_length) {
-    return 'IS_POSSIBLE';
-  }
-  if (minimum_length > actual_length) {
-    return 'TOO_SHORT';
-  }
-  if (possible_lengths[possible_lengths.length - 1] < actual_length) {
-    return 'TOO_LONG';
-  }
-
-  // We skip the first element since we've already checked it.
-  return possible_lengths.indexOf(actual_length, 1) >= 0 ? 'IS_POSSIBLE' : 'INVALID_LENGTH';
-}
-
-export { checkNumberLengthForType, checkNumberLength as default };

package/dist/node_modules/libphonenumber-js/es6/helpers/extension/createExtensionPattern.js

@@ -1,96 +0,0 @@
-import { VALID_DIGITS } from '../../constants.js';
-
-// The RFC 3966 format for extensions.
-var RFC3966_EXTN_PREFIX = ';ext=';
-
-/**
- * Helper method for constructing regular expressions for parsing. Creates
- * an expression that captures up to max_length digits.
- * @return {string} RegEx pattern to capture extension digits.
- */
-var getExtensionDigitsPattern = function getExtensionDigitsPattern(maxLength) {
-  return "([".concat(VALID_DIGITS, "]{1,").concat(maxLength, "})");
-};
-
-/**
- * Helper initialiser method to create the regular-expression pattern to match
- * extensions.
- * Copy-pasted from Google's `libphonenumber`:
- * https://github.com/google/libphonenumber/blob/55b2646ec9393f4d3d6661b9c82ef9e258e8b829/javascript/i18n/phonenumbers/phonenumberutil.js#L759-L766
- * @return {string} RegEx pattern to capture extensions.
- */
-function createExtensionPattern(purpose) {
-  // We cap the maximum length of an extension based on the ambiguity of the way
-  // the extension is prefixed. As per ITU, the officially allowed length for
-  // extensions is actually 40, but we don't support this since we haven't seen real
-  // examples and this introduces many false interpretations as the extension labels
-  // are not standardized.
-  /** @type {string} */
-  var extLimitAfterExplicitLabel = '20';
-  /** @type {string} */
-  var extLimitAfterLikelyLabel = '15';
-  /** @type {string} */
-  var extLimitAfterAmbiguousChar = '9';
-  /** @type {string} */
-  var extLimitWhenNotSure = '6';
-
-  /** @type {string} */
-  var possibleSeparatorsBetweenNumberAndExtLabel = "[ \xA0\\t,]*";
-  // Optional full stop (.) or colon, followed by zero or more spaces/tabs/commas.
-  /** @type {string} */
-  var possibleCharsAfterExtLabel = "[:\\.\uFF0E]?[ \xA0\\t,-]*";
-  /** @type {string} */
-  var optionalExtnSuffix = "#?";
-
-  // Here the extension is called out in more explicit way, i.e mentioning it obvious
-  // patterns like "ext.".
-  /** @type {string} */
-  var explicitExtLabels = "(?:e?xt(?:ensi(?:o\u0301?|\xF3))?n?|\uFF45?\uFF58\uFF54\uFF4E?|\u0434\u043E\u0431|anexo)";
-  // One-character symbols that can be used to indicate an extension, and less
-  // commonly used or more ambiguous extension labels.
-  /** @type {string} */
-  var ambiguousExtLabels = "(?:[x\uFF58#\uFF03~\uFF5E]|int|\uFF49\uFF4E\uFF54)";
-  // When extension is not separated clearly.
-  /** @type {string} */
-  var ambiguousSeparator = "[- ]+";
-  // This is the same as possibleSeparatorsBetweenNumberAndExtLabel, but not matching
-  // comma as extension label may have it.
-  /** @type {string} */
-  var possibleSeparatorsNumberExtLabelNoComma = "[ \xA0\\t]*";
-  // ",," is commonly used for auto dialling the extension when connected. First
-  // comma is matched through possibleSeparatorsBetweenNumberAndExtLabel, so we do
-  // not repeat it here. Semi-colon works in Iphone and Android also to pop up a
-  // button with the extension number following.
-  /** @type {string} */
-  var autoDiallingAndExtLabelsFound = "(?:,{2}|;)";
-
-  /** @type {string} */
-  var rfcExtn = RFC3966_EXTN_PREFIX + getExtensionDigitsPattern(extLimitAfterExplicitLabel);
-  /** @type {string} */
-  var explicitExtn = possibleSeparatorsBetweenNumberAndExtLabel + explicitExtLabels + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterExplicitLabel) + optionalExtnSuffix;
-  /** @type {string} */
-  var ambiguousExtn = possibleSeparatorsBetweenNumberAndExtLabel + ambiguousExtLabels + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterAmbiguousChar) + optionalExtnSuffix;
-  /** @type {string} */
-  var americanStyleExtnWithSuffix = ambiguousSeparator + getExtensionDigitsPattern(extLimitWhenNotSure) + "#";
-
-  /** @type {string} */
-  var autoDiallingExtn = possibleSeparatorsNumberExtLabelNoComma + autoDiallingAndExtLabelsFound + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterLikelyLabel) + optionalExtnSuffix;
-  /** @type {string} */
-  var onlyCommasExtn = possibleSeparatorsNumberExtLabelNoComma + "(?:,)+" + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterAmbiguousChar) + optionalExtnSuffix;
-
-  // The first regular expression covers RFC 3966 format, where the extension is added
-  // using ";ext=". The second more generic where extension is mentioned with explicit
-  // labels like "ext:". In both the above cases we allow more numbers in extension than
-  // any other extension labels. The third one captures when single character extension
-  // labels or less commonly used labels are used. In such cases we capture fewer
-  // extension digits in order to reduce the chance of falsely interpreting two
-  // numbers beside each other as a number + extension. The fourth one covers the
-  // special case of American numbers where the extension is written with a hash
-  // at the end, such as "- 503#". The fifth one is exclusively for extension
-  // autodialling formats which are used when dialling and in this case we accept longer
-  // extensions. The last one is more liberal on the number of commas that acts as
-  // extension labels, so we have a strict cap on the number of digits in such extensions.
-  return rfcExtn + "|" + explicitExtn + "|" + ambiguousExtn + "|" + americanStyleExtnWithSuffix + "|" + autoDiallingExtn + "|" + onlyCommasExtn;
-}
-
-export { createExtensionPattern as default };

package/dist/node_modules/libphonenumber-js/es6/helpers/extension/extractExtension.js

@@ -1,31 +0,0 @@
-import createExtensionPattern from './createExtensionPattern.js';
-
-// Regexp of all known extension prefixes used by different regions followed by
-// 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++;
-  }
-}
-
-export { extractExtension as default };

package/dist/node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCode.js

@@ -1,142 +0,0 @@
-import stripIddPrefix from './stripIddPrefix.js';
-import extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js';
-import Metadata from '../metadata.js';
-import { MAX_LENGTH_COUNTRY_CODE } from '../constants.js';
-
-/**
- * Converts a phone number digits (possibly with a `+`)
- * into a calling code and the rest phone number digits.
- * The "rest phone number digits" could include
- * a national prefix, carrier code, and national
- * (significant) number.
- * @param  {string} number — Phone number digits (possibly with a `+`).
- * @param  {string} [country] — Country.
- * @param  {string} [defaultCountry] — Default country.
- * @param  {string} [defaultCallingCode] — Default calling code (some phone numbering plans are non-geographic).
- * @param  {object} metadata
- * @return {object} `{ countryCallingCodeSource: string?, countryCallingCode: string?, number: string }`
- * @example
- * // Returns `{ countryCallingCode: "1", number: "2133734253" }`.
- * extractCountryCallingCode('2133734253', null, 'US', null, metadata)
- * extractCountryCallingCode('2133734253', null, null, '1', metadata)
- * extractCountryCallingCode('+12133734253', null, null, null, metadata)
- * extractCountryCallingCode('+12133734253', null, 'RU', null, metadata)
- */
-function extractCountryCallingCode(number, country, defaultCountry, defaultCallingCode, metadata) {
-  if (!number) {
-    return {};
-  }
-  var isNumberWithIddPrefix;
-
-  // If this is not an international phone number,
-  // then either extract an "IDD" prefix, or extract a
-  // country calling code from a number by autocorrecting it
-  // by prepending a leading `+` in cases when it starts
-  // with the country calling code.
-  // https://wikitravel.org/en/International_dialling_prefix
-  // https://github.com/catamphetamine/libphonenumber-js/issues/376
-  if (number[0] !== '+') {
-    // Convert an "out-of-country" dialing phone number
-    // to a proper international phone number.
-    var numberWithoutIDD = stripIddPrefix(number, defaultCountry, defaultCallingCode, metadata);
-    // If an IDD prefix was stripped then
-    // convert the number to international one
-    // for subsequent parsing.
-    if (numberWithoutIDD && numberWithoutIDD !== number) {
-      isNumberWithIddPrefix = true;
-      number = '+' + numberWithoutIDD;
-    } else {
-      // Check to see if the number starts with the country calling code
-      // for the default country. If so, we remove the country calling code,
-      // and do some checks on the validity of the number before and after.
-      // https://github.com/catamphetamine/libphonenumber-js/issues/376
-      if (defaultCountry || defaultCallingCode) {
-        var _extractCountryCallin = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, defaultCountry, defaultCallingCode, metadata),
-          countryCallingCode = _extractCountryCallin.countryCallingCode,
-          shorterNumber = _extractCountryCallin.number;
-        if (countryCallingCode) {
-          return {
-            countryCallingCodeSource: 'FROM_NUMBER_WITHOUT_PLUS_SIGN',
-            countryCallingCode: countryCallingCode,
-            number: shorterNumber
-          };
-        }
-      }
-      return {
-        // No need to set it to `UNSPECIFIED`. It can be just `undefined`.
-        // countryCallingCodeSource: 'UNSPECIFIED',
-        number: number
-      };
-    }
-  }
-
-  // `number` can only be international at this point.
-
-  // Fast abortion: country codes do not begin with a '0'
-  if (number[1] === '0') {
-    return {};
-  }
-  metadata = new Metadata(metadata);
-
-  // The thing with country phone codes
-  // is that they are orthogonal to each other
-  // i.e. there's no such country phone code A
-  // for which country phone code B exists
-  // where B starts with A.
-  // Therefore, while scanning digits,
-  // if a valid country code is found,
-  // that means that it is the country code.
-  //
-  var i = 2;
-  while (i - 1 <= MAX_LENGTH_COUNTRY_CODE && i <= number.length) {
-    var _countryCallingCode = number.slice(1, i);
-    if (metadata.hasCallingCode(_countryCallingCode)) {
-      metadata.selectNumberingPlan(_countryCallingCode);
-      return {
-        countryCallingCodeSource: isNumberWithIddPrefix ? 'FROM_NUMBER_WITH_IDD' : 'FROM_NUMBER_WITH_PLUS_SIGN',
-        countryCallingCode: _countryCallingCode,
-        number: number.slice(i)
-      };
-    }
-    i++;
-  }
-  return {};
-}
-
-// The possible values for the returned `countryCallingCodeSource` are:
-//
-// Copy-pasted from:
-// https://github.com/google/libphonenumber/blob/master/resources/phonenumber.proto
-//
-// // The source from which the country_code is derived. This is not set in the
-// // general parsing method, but in the method that parses and keeps raw_input.
-// // New fields could be added upon request.
-// enum CountryCodeSource {
-//  // Default value returned if this is not set, because the phone number was
-//  // created using parse, not parseAndKeepRawInput. hasCountryCodeSource will
-//  // return false if this is the case.
-//  UNSPECIFIED = 0;
-//
-//  // The country_code is derived based on a phone number with a leading "+",
-//  // e.g. the French number "+33 1 42 68 53 00".
-//  FROM_NUMBER_WITH_PLUS_SIGN = 1;
-//
-//  // The country_code is derived based on a phone number with a leading IDD,
-//  // e.g. the French number "011 33 1 42 68 53 00", as it is dialled from US.
-//  FROM_NUMBER_WITH_IDD = 5;
-//
-//  // The country_code is derived based on a phone number without a leading
-//  // "+", e.g. the French number "33 1 42 68 53 00" when defaultCountry is
-//  // supplied as France.
-//  FROM_NUMBER_WITHOUT_PLUS_SIGN = 10;
-//
-//  // The country_code is derived NOT based on the phone number itself, but
-//  // from the defaultCountry parameter provided in the parsing function by the
-//  // clients. This happens mostly for numbers written in the national format
-//  // (without country code). For example, this would be set when parsing the
-//  // French number "01 42 68 53 00", when defaultCountry is supplied as
-//  // France.
-//  FROM_DEFAULT_COUNTRY = 20;
-// }
-
-export { extractCountryCallingCode as default };

package/dist/node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js

@@ -1,47 +0,0 @@
-import Metadata, { getCountryCallingCode } from '../metadata.js';
-import matchesEntirely from './matchesEntirely.js';
-import extractNationalNumber from './extractNationalNumber.js';
-import checkNumberLength from './checkNumberLength.js';
-
-/**
- * Sometimes some people incorrectly input international phone numbers
- * without the leading `+`. This function corrects such input.
- * @param  {string} number — Phone number digits.
- * @param  {string} [country] — Exact country of the phone number.
- * @param  {string} [defaultCountry]
- * @param  {string} [defaultCallingCode]
- * @param  {object} metadata
- * @return {object} `{ countryCallingCode: string?, number: string }`.
- */
-function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, defaultCountry, defaultCallingCode, metadata) {
-  var countryCallingCode = defaultCountry ? getCountryCallingCode(defaultCountry, metadata) : defaultCallingCode;
-  if (number.indexOf(countryCallingCode) === 0) {
-    metadata = new Metadata(metadata);
-    metadata.selectNumberingPlan(defaultCountry, countryCallingCode);
-    var possibleShorterNumber = number.slice(countryCallingCode.length);
-    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, country, metadata),
-      possibleShorterNationalNumber = _extractNationalNumbe.nationalNumber;
-    var _extractNationalNumbe2 = extractNationalNumber(number, country, metadata),
-      nationalNumber = _extractNationalNumbe2.nationalNumber;
-
-    // If the number was not valid before but is valid now,
-    // or if it was too long before, we consider the number
-    // with the country calling code stripped to be a better result
-    // and keep that instead.
-    // For example, in Germany (+49), `49` is a valid area code,
-    // so if a number starts with `49`, it could be both a valid
-    // national German number or an international number without
-    // a leading `+`.
-    if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) && matchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern()) || checkNumberLength(nationalNumber, country, metadata) === 'TOO_LONG') {
-      return {
-        countryCallingCode: countryCallingCode,
-        number: possibleShorterNumber
-      };
-    }
-  }
-  return {
-    number: number
-  };
-}
-
-export { extractCountryCallingCodeFromInternationalNumberWithoutPlusSign as default };

package/dist/node_modules/libphonenumber-js/es6/helpers/extractFormattedPhoneNumberFromPossibleRfc3966NumberUri.js

@@ -1,66 +0,0 @@
-import extractPhoneContext, { isPhoneContextValid, PLUS_SIGN, RFC3966_PREFIX_, RFC3966_PHONE_CONTEXT_, RFC3966_ISDN_SUBADDRESS_ } from './extractPhoneContext.js';
-import ParseError from '../ParseError.js';
-
-/**
- * @param  {string} numberToParse
- * @param  {string} nationalNumber
- * @return {}
- */
-function extractFormattedPhoneNumberFromPossibleRfc3966NumberUri(numberToParse, _ref) {
-  var extractFormattedPhoneNumber = _ref.extractFormattedPhoneNumber;
-  var phoneContext = extractPhoneContext(numberToParse);
-  if (!isPhoneContextValid(phoneContext)) {
-    throw new ParseError('NOT_A_NUMBER');
-  }
-  var phoneNumberString;
-  if (phoneContext === null) {
-    // Extract a possible number from the string passed in.
-    // (this strips leading characters that could not be the start of a phone number)
-    phoneNumberString = extractFormattedPhoneNumber(numberToParse) || '';
-  } else {
-    phoneNumberString = '';
-
-    // If the phone context contains a phone number prefix, we need to capture
-    // it, whereas domains will be ignored.
-    if (phoneContext.charAt(0) === PLUS_SIGN) {
-      phoneNumberString += phoneContext;
-    }
-
-    // Now append everything between the "tel:" prefix and the phone-context.
-    // This should include the national number, an optional extension or
-    // isdn-subaddress component. Note we also handle the case when "tel:" is
-    // missing, as we have seen in some of the phone number inputs.
-    // In that case, we append everything from the beginning.
-    var indexOfRfc3966Prefix = numberToParse.indexOf(RFC3966_PREFIX_);
-    var indexOfNationalNumber;
-    // RFC 3966 "tel:" prefix is preset at this stage because
-    // `isPhoneContextValid()` requires it to be present.
-    /* istanbul ignore else */
-    if (indexOfRfc3966Prefix >= 0) {
-      indexOfNationalNumber = indexOfRfc3966Prefix + RFC3966_PREFIX_.length;
-    } else {
-      indexOfNationalNumber = 0;
-    }
-    var indexOfPhoneContext = numberToParse.indexOf(RFC3966_PHONE_CONTEXT_);
-    phoneNumberString += numberToParse.substring(indexOfNationalNumber, indexOfPhoneContext);
-  }
-
-  // Delete the isdn-subaddress and everything after it if it is present.
-  // Note extension won't appear at the same time with isdn-subaddress
-  // according to paragraph 5.3 of the RFC3966 spec.
-  var indexOfIsdn = phoneNumberString.indexOf(RFC3966_ISDN_SUBADDRESS_);
-  if (indexOfIsdn > 0) {
-    phoneNumberString = phoneNumberString.substring(0, indexOfIsdn);
-  }
-  // If both phone context and isdn-subaddress are absent but other
-  // parameters are present, the parameters are left in nationalNumber.
-  // This is because we are concerned about deleting content from a potential
-  // number string when there is no strong evidence that the number is
-  // actually written in RFC3966.
-
-  if (phoneNumberString !== '') {
-    return phoneNumberString;
-  }
-}
-
-export { extractFormattedPhoneNumberFromPossibleRfc3966NumberUri as default };

package/dist/node_modules/libphonenumber-js/es6/helpers/extractNationalNumber.js

@@ -1,117 +0,0 @@
-import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber.js';
-import matchesEntirely from './matchesEntirely.js';
-import checkNumberLength from './checkNumberLength.js';
-import getCountryByCallingCode from './getCountryByCallingCode.js';
-
-/**
- * Strips national prefix and carrier code from a complete phone number.
- * The difference from the non-"FromCompleteNumber" function is that
- * it won't extract national prefix if the resultant number is too short
- * to be a complete number for the selected phone numbering plan.
- * @param  {string} number — Complete phone number digits.
- * @param  {string?} country — Country, if known.
- * @param  {Metadata} metadata — Metadata with a phone numbering plan selected.
- * @return {object} `{ nationalNumber: string, carrierCode: string? }`.
- */
-function extractNationalNumber(number, country, metadata) {
-  // Parsing national prefixes and carrier codes
-  // is only required for local phone numbers
-  // but some people don't understand that
-  // and sometimes write international phone numbers
-  // with national prefixes (or maybe even carrier codes).
-  // http://ucken.blogspot.ru/2016/03/trunk-prefixes-in-skype4b.html
-  // Google's original library forgives such mistakes
-  // and so does this library, because it has been requested:
-  // https://github.com/catamphetamine/libphonenumber-js/issues/127
-  var _extractNationalNumbe = extractNationalNumberFromPossiblyIncompleteNumber(number, metadata),
-    carrierCode = _extractNationalNumbe.carrierCode,
-    nationalNumber = _extractNationalNumbe.nationalNumber;
-  if (nationalNumber !== number) {
-    if (!shouldHaveExtractedNationalPrefix(number, nationalNumber, metadata)) {
-      // Don't strip the national prefix.
-      return {
-        nationalNumber: number
-      };
-    }
-    // Check the national (significant) number length after extracting national prefix and carrier code.
-    // Legacy generated metadata (before `1.0.18`) didn't support the "possible lengths" feature.
-    if (metadata.numberingPlan.possibleLengths()) {
-      // If an exact `country` is not specified, attempt to detect it from the assumed national number.
-      if (!country) {
-        country = getCountryByCallingCode(metadata.numberingPlan.callingCode(), {
-          nationalNumber: nationalNumber,
-          metadata: metadata
-        });
-      }
-
-      // The number remaining after stripping the national prefix and carrier code
-      // should be long enough to have a possible length for the country.
-      // Otherwise, don't strip the national prefix and carrier code,
-      // since the original number could be a valid number.
-      // This check has been copy-pasted "as is" from Google's original library:
-      // https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250
-      // It doesn't check for the "possibility" of the original `number`.
-      // I guess it's fine not checking that one. It works as is anyway.
-      if (!isPossibleIncompleteNationalNumber(nationalNumber, country, metadata)) {
-        // Don't strip the national prefix.
-        return {
-          nationalNumber: number
-        };
-      }
-    }
-  }
-  return {
-    nationalNumber: nationalNumber,
-    carrierCode: carrierCode
-  };
-}
-
-// In some countries, the same digit could be a national prefix
-// or a leading digit of a valid phone number.
-// For example, in Russia, national prefix is `8`,
-// and also `800 555 35 35` is a valid number
-// in which `8` is not a national prefix, but the first digit
-// of a national (significant) number.
-// Same's with Belarus:
-// `82004910060` is a valid national (significant) number,
-// but `2004910060` is not.
-// To support such cases (to prevent the code from always stripping
-// national prefix), a condition is imposed: a national prefix
-// is not extracted when the original number is "viable" and the
-// resultant number is not, a "viable" national number being the one
-// that matches `national_number_pattern`.
-function shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberAfter, metadata) {
-  // The equivalent in Google's code is:
-  // https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L2969-L3004
-  if (matchesEntirely(nationalNumberBefore, metadata.nationalNumberPattern()) && !matchesEntirely(nationalNumberAfter, metadata.nationalNumberPattern())) {
-    return false;
-  }
-  // This "is possible" national number (length) check has been commented out
-  // because it's superceded by the (effectively) same check done in the
-  // `extractNationalNumber()` function after it calls `shouldHaveExtractedNationalPrefix()`.
-  // In other words, why run the same check twice if it could only be run once.
-  // // Check the national (significant) number length after extracting national prefix and carrier code.
-  // // Fixes a minor "weird behavior" bug: https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/57
-  // // (Legacy generated metadata (before `1.0.18`) didn't support the "possible lengths" feature).
-  // if (metadata.possibleLengths()) {
-  // 	if (isPossibleIncompleteNationalNumber(nationalNumberBefore, metadata) &&
-  // 		!isPossibleIncompleteNationalNumber(nationalNumberAfter, metadata)) {
-  // 		return false
-  // 	}
-  // }
-  return true;
-}
-function isPossibleIncompleteNationalNumber(nationalNumber, country, metadata) {
-  switch (checkNumberLength(nationalNumber, country, metadata)) {
-    case 'TOO_SHORT':
-    case 'INVALID_LENGTH':
-      // This library ignores "local-only" phone numbers (for simplicity).
-      // See the readme for more info on what are "local-only" phone numbers.
-      // case 'IS_POSSIBLE_LOCAL_ONLY':
-      return false;
-    default:
-      return true;
-  }
-}
-
-export { extractNationalNumber as default };