ingeniuscliq-core 0.5.37 → 0.5.38

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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,142 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,117 @@
+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 };