@rpcbase/ui 0.287.0 → 0.289.0

package/dist/index322.js.map

@@ -1 +1 @@
-{"version":3,"file":"index322.js","names":[],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/extractNationalNumber.js"],"sourcesContent":["import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport checkNumberLength from './checkNumberLength.js';\nimport getCountryByCallingCode from './getCountryByCallingCode.js';\n\n/**\n * Strips national prefix and carrier code from a complete phone number.\n * The difference from the non-\"FromCompleteNumber\" function is that\n * it won't extract national prefix if the resultant number is too short\n * to be a complete number for the selected phone numbering plan.\n * @param  {string} number — Complete phone number digits.\n * @param  {string?} country — Specific country to use instead of the one that is pre-selected in the metadata instance.\n * @param  {Metadata} metadata — Metadata instance with a selected numbering plan.\n * @return {object} `{ nationalNumber: string, carrierCode: string? }`.\n */\nexport default function extractNationalNumber(number, country, metadata) {\n  // Parsing national prefixes and carrier codes\n  // is only required for local phone numbers\n  // but some people don't understand that\n  // and sometimes write international phone numbers\n  // with national prefixes (or maybe even carrier codes).\n  // http://ucken.blogspot.ru/2016/03/trunk-prefixes-in-skype4b.html\n  // Google's original library forgives such mistakes\n  // and so does this library, because it has been requested:\n  // https://github.com/catamphetamine/libphonenumber-js/issues/127\n  var _extractNationalNumbe = extractNationalNumberFromPossiblyIncompleteNumber(number, metadata),\n    carrierCode = _extractNationalNumbe.carrierCode,\n    nationalNumber = _extractNationalNumbe.nationalNumber;\n  if (nationalNumber !== number) {\n    if (!shouldHaveExtractedNationalPrefix(number, nationalNumber, metadata)) {\n      // Don't strip the national prefix.\n      return {\n        nationalNumber: number\n      };\n    }\n    // Check the national (significant) number length after extracting national prefix and carrier code.\n    // Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature,\n    // so this `if` will only be executed with newer metadata.\n    if (metadata.numberingPlan.possibleLengths()) {\n      // If an exact `country` is not specified, attempt to detect it from the assumed national number.\n      if (!country) {\n        country = getCountryByCallingCode(metadata.numberingPlan.callingCode(), {\n          nationalNumber: nationalNumber,\n          metadata: metadata\n        });\n      }\n\n      // The number remaining after stripping the national prefix and carrier code\n      // should be long enough to have a possible length for the country.\n      // Otherwise, don't strip the national prefix and carrier code,\n      // since the original number could be a valid number.\n      // This check has been copy-pasted \"as is\" from Google's original library:\n      // https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250\n      // It doesn't check for the \"possibility\" of the original `number`.\n      // I guess it's fine not checking that one. It works as is anyway.\n      if (!isPossibleIncompleteNationalNumber(nationalNumber, country, metadata)) {\n        // Don't strip the national prefix.\n        return {\n          nationalNumber: number\n        };\n      }\n    }\n  }\n  return {\n    nationalNumber: nationalNumber,\n    carrierCode: carrierCode\n  };\n}\n\n// In some countries, the same digit could be a national prefix\n// or a leading digit of a valid phone number.\n// For example, in Russia, national prefix is `8`,\n// and also `800 555 35 35` is a valid number\n// in which `8` is not a national prefix, but the first digit\n// of a national (significant) number.\n// Same's with Belarus:\n// `82004910060` is a valid national (significant) number,\n// but `2004910060` is not.\n// To support such cases (to prevent the code from always stripping\n// national prefix), a condition is imposed: a national prefix\n// is not extracted when the original number is \"viable\" and the\n// resultant number is not, a \"viable\" national number being the one\n// that matches `national_number_pattern`.\nfunction shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberAfter, metadata) {\n  // The equivalent in Google's code is:\n  // https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L2969-L3004\n  if (matchesEntirely(nationalNumberBefore, metadata.nationalNumberPattern()) && !matchesEntirely(nationalNumberAfter, metadata.nationalNumberPattern())) {\n    return false;\n  }\n  // This \"is possible\" national number (length) check has been commented out\n  // because it's superceded by the (effectively) same check done in the\n  // `extractNationalNumber()` function after it calls `shouldHaveExtractedNationalPrefix()`.\n  // In other words, why run the same check twice if it could only be run once.\n  // // Check the national (significant) number length after extracting national prefix and carrier code.\n  // // Fixes a minor \"weird behavior\" bug: https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/57\n  // // (Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature).\n  // if (metadata.possibleLengths()) {\n  // \tif (isPossibleIncompleteNationalNumber(nationalNumberBefore, metadata) &&\n  // \t\t!isPossibleIncompleteNationalNumber(nationalNumberAfter, metadata)) {\n  // \t\treturn false\n  // \t}\n  // }\n  return true;\n}\n\n/**\n * Tells if a given incomplete national number is possible or not.\n * @param {string} nationalNumber\n * @param {string?} country — Specific country rather than the one that is pre-selected in the metadata instance.\n * @param {Metadata} metadata — Metadata instance with a selected numbering plan.\n * @returns {boolean}\n */\nfunction isPossibleIncompleteNationalNumber(nationalNumber, country, metadata) {\n  switch (checkNumberLength(nationalNumber, country, metadata)) {\n    case 'TOO_SHORT':\n    case 'INVALID_LENGTH':\n      // This library ignores \"local-only\" phone numbers (for simplicity).\n      // See the readme for more info on what are \"local-only\" phone numbers.\n      // case 'IS_POSSIBLE_LOCAL_ONLY':\n      return false;\n    default:\n      return true;\n  }\n}\n//# sourceMappingURL=extractNationalNumber.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AAeA,SAAwB,EAAsB,GAAQ,GAAS,GAAU;CAUvE,IAAI,IAAwB,EAAkD,GAAQ,CAAQ,GAC5F,IAAc,EAAsB,aACpC,IAAiB,EAAsB;CAoCzC,OAnCI,MAAmB,MACjB,CAAC,EAAkC,GAAQ,GAAgB,CAAQ,KASnE,EAAS,cAAc,gBAAgB,MAEzC,AACE,MAAU,EAAwB,EAAS,cAAc,YAAY,GAAG;EACtD;EACN;CACZ,CAAC,GAWC,CAAC,EAAmC,GAAgB,GAAS,CAAQ,MAEhE,EACL,gBAAgB,EAClB,IAIC;EACW;EACH;CACf;AACF;AAgBA,SAAS,EAAkC,GAAsB,GAAqB,GAAU;CAmB9F,OAhBA,EAAI,EAAgB,GAAsB,EAAS,sBAAsB,CAAC,KAAK,CAAC,EAAgB,GAAqB,EAAS,sBAAsB,CAAC;AAiBvJ;AASA,SAAS,EAAmC,GAAgB,GAAS,GAAU;CAC7E,QAAQ,EAAkB,GAAgB,GAAS,CAAQ,GAA3D;EACE,KAAK;EACL,KAAK,kBAIH,OAAO;EACT,SACE,OAAO;CACX;AACF"}
+{"version":3,"file":"index322.js","names":["VALID_DIGITS","DASHES","SLASHES","DOTS","WHITESPACE","VALID_PUNCTUATION","PLUS_CHARS"],"sources":["../../../node_modules/libphonenumber-js/es6/constants.js"],"sourcesContent":["// The minimum length of the national significant number.\nexport var MIN_LENGTH_FOR_NSN = 2;\n\n// The ITU says the maximum length should be 15,\n// but one can find longer numbers in Germany.\nexport var MAX_LENGTH_FOR_NSN = 17;\n\n// The maximum length of the country calling code.\nexport var MAX_LENGTH_COUNTRY_CODE = 3;\n\n// Digits accepted in phone numbers\n// (ascii, fullwidth, arabic-indic, and eastern arabic digits).\nexport var VALID_DIGITS = \"0-9\\uFF10-\\uFF19\\u0660-\\u0669\\u06F0-\\u06F9\";\n\n// `DASHES` will be right after the opening square bracket of the \"character class\"\nvar DASHES = \"-\\u2010-\\u2015\\u2212\\u30FC\\uFF0D\";\nvar SLASHES = \"\\uFF0F/\";\nvar DOTS = \"\\uFF0E.\";\nexport var WHITESPACE = \" \\xA0\\xAD\\u200B\\u2060\\u3000\";\nvar BRACKETS = \"()\\uFF08\\uFF09\\uFF3B\\uFF3D\\\\[\\\\]\";\n// export const OPENING_BRACKETS = '(\\uFF08\\uFF3B\\\\\\['\nvar TILDES = \"~\\u2053\\u223C\\uFF5E\";\n\n// Regular expression of acceptable punctuation found in phone numbers. This\n// excludes punctuation found as a leading character only. This consists of dash\n// characters, white space characters, full stops, slashes, square brackets,\n// parentheses and tildes. Full-width variants are also present.\nexport var VALID_PUNCTUATION = \"\".concat(DASHES).concat(SLASHES).concat(DOTS).concat(WHITESPACE).concat(BRACKETS).concat(TILDES);\nexport var PLUS_CHARS = \"+\\uFF0B\";\n// const LEADING_PLUS_CHARS_PATTERN = new RegExp('^[' + PLUS_CHARS + ']+')\n//# sourceMappingURL=constants.js.map"],"ignoreList":[0],"mappings":";AAYA,IAAWA,IAAe,gBAGtBC,IAAS,WACTC,IAAU,MACVC,IAAO,MACAC,IAAa,aASbC,IAAoB,GAAUJ,IAAeC,IAAgBC,IAAaC,qBAC1EE,IAAa"}

package/dist/index323.js

@@ -1,23 +1,20 @@
-import e, { getCountryCallingCode as t } from "./index307.js";
-import n from "./index309.js";
-import r from "./index311.js";
-import i from "./index322.js";
-//#region ../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js
-function a(a, o, s, c, l) {
-	if (!(o || s || c)) return { number: a };
-	var u = o || s ? t(o || s, l) : c;
-	if (a.indexOf(u) === 0) {
-		var d = new e(l);
-		d.selectNumberingPlan(o || s || c);
-		var f = a.slice(u.length), p = i(f, void 0, d).nationalNumber, m = i(a, void 0, d).nationalNumber;
-		if (!r(m, d.nationalNumberPattern()) && r(p, d.nationalNumberPattern()) || n(m, void 0, d) === "TOO_LONG") return {
-			countryCallingCode: u,
-			number: f
-		};
+import e from "./index312.js";
+import { VALID_DIGITS as t } from "./index322.js";
+//#region ../../node_modules/libphonenumber-js/es6/helpers/stripIddPrefix.js
+var n = RegExp("([" + t + "])");
+function r(t, r, i, a) {
+	if (r) {
+		var o = new e(a);
+		o.selectNumberingPlan(r || i);
+		var s = new RegExp(o.IDDPrefix());
+		if (t.search(s) === 0) {
+			t = t.slice(t.match(s)[0].length);
+			var c = t.match(n);
+			if (!(c && c[1] != null && c[1].length > 0 && c[1] === "0")) return t;
+		}
 	}
-	return { number: a };
 }
 //#endregion
-export { a as default };
+export { r as default };
 
 //# sourceMappingURL=index323.js.map

package/dist/index323.js.map

@@ -1 +1 @@
-{"version":3,"file":"index323.js","names":[],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js"],"sourcesContent":["import Metadata from '../metadata.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport extractNationalNumber from './extractNationalNumber.js';\nimport checkNumberLength from './checkNumberLength.js';\nimport getCountryCallingCode from '../getCountryCallingCode.js';\n\n/**\n * Sometimes some people incorrectly input international phone numbers\n * without the leading `+`. This function corrects such input.\n * @param  {string} number — Phone number digits (only digits, no `+`).\n * @param  {string} [country] — Exact country of the phone number.\n * @param  {string} [defaultCountry]\n * @param  {string} [defaultCallingCode]\n * @param  {object} metadataJson\n * @return {object} `{ countryCallingCode: string?, number: string }`, where `countryCallingCode` is the calling code that was extracted from the input `number` string, and `number` is the originally passed `number` without the extracted calling code.\n */\nexport default function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, defaultCountry, defaultCallingCode, metadataJson) {\n  // Validate arguments.\n  // The `number` is known to be in a non-international form\n  // because there's no leading \"+\" character.\n  // Therefore, there must be either `country` or `defaultCountry` or `defaultCallingCode`.\n  // Otherwise, there'd be no source for the calling code to search for in the `number`.\n  if (!(country || defaultCountry || defaultCallingCode)) {\n    // There's no source for the calling code to search for in the `number`.\n    return {\n      number: number\n    };\n  }\n  var countryCallingCode = country || defaultCountry ? getCountryCallingCode(country || defaultCountry, metadataJson) : defaultCallingCode;\n  if (number.indexOf(countryCallingCode) === 0) {\n    var metadata = new Metadata(metadataJson);\n    metadata.selectNumberingPlan(country || defaultCountry || defaultCallingCode);\n    var possibleShorterNumber = number.slice(countryCallingCode.length);\n    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, undefined, metadata),\n      possibleShorterNationalNumber = _extractNationalNumbe.nationalNumber;\n    var _extractNationalNumbe2 = extractNationalNumber(number, undefined, metadata),\n      nationalNumber = _extractNationalNumbe2.nationalNumber;\n\n    // If the number was not valid before but is valid now,\n    // or if it was too long before, we consider the number\n    // with the country calling code stripped to be a better result\n    // and keep that instead.\n    // For example, in Germany (+49), `49` is a valid area code,\n    // so if a number starts with `49`, it could be both a valid\n    // national German number or an international number without\n    // a leading `+`.\n    if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) && matchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern()) || checkNumberLength(nationalNumber, undefined, metadata) === 'TOO_LONG') {\n      return {\n        countryCallingCode: countryCallingCode,\n        number: possibleShorterNumber\n      };\n    }\n  }\n  return {\n    number: number\n  };\n}\n//# sourceMappingURL=extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AAgBA,SAAwB,EAAgE,GAAQ,GAAS,GAAgB,GAAoB,GAAc;CAMzJ,IAAI,EAAE,KAAW,KAAkB,IAEjC,OAAO,EACG,UACV;CAEF,IAAI,IAAqB,KAAW,IAAiB,EAAsB,KAAW,GAAgB,CAAY,IAAI;CACtH,IAAI,EAAO,QAAQ,CAAkB,MAAM,GAAG;EAC5C,IAAI,IAAW,IAAI,EAAS,CAAY;EACxC,EAAS,oBAAoB,KAAW,KAAkB,CAAkB;EAC5E,IAAI,IAAwB,EAAO,MAAM,EAAmB,MAAM,GAEhE,IAD0B,EAAsB,GAAuB,KAAA,GAAW,CAC9B,CAAC,CAAC,gBAEtD,IAD2B,EAAsB,GAAQ,KAAA,GAAW,CAC9B,CAAC,CAAC;EAU1C,IAAI,CAAC,EAAgB,GAAgB,EAAS,sBAAsB,CAAC,KAAK,EAAgB,GAA+B,EAAS,sBAAsB,CAAC,KAAK,EAAkB,GAAgB,KAAA,GAAW,CAAQ,MAAM,YACvN,OAAO;GACe;GACpB,QAAQ;EACV;CAEJ;CACA,OAAO,EACG,UACV;AACF"}
+{"version":3,"file":"index323.js","names":["Metadata","CAPTURING_DIGIT_PATTERN","VALID_DIGITS","stripIddPrefix","country","metadata","metadataJson","callingCode","IDDPrefixPattern","number","matchedGroups"],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/stripIddPrefix.js"],"sourcesContent":["import Metadata from '../metadata.js';\nimport { VALID_DIGITS } from '../constants.js';\nvar CAPTURING_DIGIT_PATTERN = new RegExp('([' + VALID_DIGITS + '])');\nexport default function stripIddPrefix(number, country, callingCode, metadataJson) {\n  if (!country) {\n    return;\n  }\n\n  // Get the IDD prefix pattern.\n  var metadata = new Metadata(metadataJson);\n  metadata.selectNumberingPlan(country || callingCode);\n  var IDDPrefixPattern = new RegExp(metadata.IDDPrefix());\n\n  // Check if the number is IDD-prefixed.\n  if (number.search(IDDPrefixPattern) !== 0) {\n    return;\n  }\n\n  // Strip IDD prefix.\n  number = number.slice(number.match(IDDPrefixPattern)[0].length);\n\n  // If there're any digits after an IDD prefix,\n  // then those digits are a country calling code.\n  // Since no country code starts with a `0`,\n  // the code below validates that the next digit (if present) is not `0`.\n  var matchedGroups = number.match(CAPTURING_DIGIT_PATTERN);\n  if (matchedGroups && matchedGroups[1] != null && matchedGroups[1].length > 0) {\n    if (matchedGroups[1] === '0') {\n      return;\n    }\n  }\n  return number;\n}\n//# sourceMappingURL=stripIddPrefix.js.map"],"ignoreList":[0],"mappings":";;;AAEA,IAAIC,IAA8B,OAAO,OAAOC,IAAe,IAAI;AACnE,SAAwBC,EAAe,GAAQ,GAAS,GAAa,GAAc;CACjF,IAAKC,GAKL;MAAIC,IAAW,IAAIL,EAASM,CAAY;EACxC,EAAS,oBAAoBF,KAAWG,CAAW;EACnD,IAAIC,IAAmB,IAAI,OAAOH,EAAS,UAAU,CAAC;EAGtD,IAAII,EAAO,OAAOD,CAAgB,MAAM,GAKxC;OAASC,EAAO,MAAMA,EAAO,MAAMD,CAAgB,CAAC,CAAC,EAAE,CAAC,MAAM;GAM9D,IAAIE,IAAgBD,EAAO,MAAMR,CAAuB;GACxD,IACM,EADFS,KAAiBA,EAAc,MAAM,QAAQA,EAAc,EAAE,CAAC,SAAS,KACrEA,EAAc,OAAO,MAI3B,OAAOD;EAZuD;CAVtB;AAuB1C"}

package/dist/index324.js

@@ -1,38 +1,29 @@
-import e from "./index307.js";
-import t from "./index318.js";
-import n from "./index323.js";
-//#region ../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCode.js
-function r(r, i, a, o, s) {
-	if (!r) return {};
-	var c;
-	if (r[0] !== "+") {
-		var l = t(r, i || a, o, s);
-		if (l && l !== r) c = !0, r = "+" + l;
-		else {
-			if (i || a || o) {
-				var u = n(r, i, a, o, s), d = u.countryCallingCode, f = u.number;
-				if (d) return {
-					countryCallingCodeSource: "FROM_NUMBER_WITHOUT_PLUS_SIGN",
-					countryCallingCode: d,
-					number: f
-				};
+//#region ../../node_modules/libphonenumber-js/es6/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js
+function e(e, t) {
+	if (e && t.numberingPlan.nationalPrefixForParsing()) {
+		var n = RegExp("^(?:" + t.numberingPlan.nationalPrefixForParsing() + ")"), r = n.exec(e);
+		if (r) {
+			var i, a, o = r.length - 1, s = o > 0 && r[o];
+			if (t.nationalPrefixTransformRule() && s) i = e.replace(n, t.nationalPrefixTransformRule()), o > 1 && (a = r[1]);
+			else {
+				var c = r[0];
+				i = e.slice(c.length), s && (a = r[1]);
 			}
-			return { number: r };
+			var l;
+			if (s) {
+				var u = e.indexOf(r[1]);
+				e.slice(0, u) === t.numberingPlan.nationalPrefix() && (l = t.numberingPlan.nationalPrefix());
+			} else l = r[0];
+			return {
+				nationalNumber: i,
+				nationalPrefix: l,
+				carrierCode: a
+			};
 		}
 	}
-	if (r[1] === "0") return {};
-	for (var p = new e(s), m = 2; m - 1 <= 3 && m <= r.length;) {
-		var h = r.slice(1, m);
-		if (p.hasCallingCode(h)) return p.selectNumberingPlan(h), {
-			countryCallingCodeSource: c ? "FROM_NUMBER_WITH_IDD" : "FROM_NUMBER_WITH_PLUS_SIGN",
-			countryCallingCode: h,
-			number: r.slice(m)
-		};
-		m++;
-	}
-	return {};
+	return { nationalNumber: e };
 }
 //#endregion
-export { r as default };
+export { e as default };
 
 //# sourceMappingURL=index324.js.map

package/dist/index324.js.map

@@ -1 +1 @@
-{"version":3,"file":"index324.js","names":[],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCode.js"],"sourcesContent":["import stripIddPrefix from './stripIddPrefix.js';\nimport extractCountryCallingCodeFromInternationalNumberWithoutPlusSign from './extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js';\nimport Metadata from '../metadata.js';\nimport { MAX_LENGTH_COUNTRY_CODE } from '../constants.js';\n\n/**\n * Attempts to extract a calling code from a phone number.\n * * If the phone number is found to be \"international\":\n *   * It will attempt to identify the calling code part of it and whether that part is complete and valid.\n *     * If the calling code part is complete and valid, it will return two properties:\n *       that calling code part (without `+`) and the rest of the digits.\n *     * Otherwise, i.e. if the calling code part is incomplete or invalid,\n *       it will return an empty object.\n * * Otherwise, i.e. if the phone number is national, there's no callind code to extract\n *   so it will just return the originally-passed `number` string as the only property.\n * @param  {string} number — Phone number digits (possibly with a `+`).\n * @param  {string} [country] — Country.\n * @param  {string} [defaultCountry] — Default country.\n * @param  {string} [defaultCallingCode] — Default calling code (some phone numbering plans are non-geographic).\n * @param  {object} metadataJson\n * @return {object} `{ countryCallingCodeSource: string?, countryCallingCode: string?, number: string }`, where `countryCallingCodeSource` tells how the returned calling code was extracted (if it was extracted), `countryCallingCode` is the calling code that was extracted from the input `number` string, and `number` is the originally passed `number` without the extracted calling code (and without a `+`). If the calling code is present but incomplete or invalid, it will return an empty object.\n * @example\n * // Returns `{ countryCallingCode: \"1\", number: \"2133734253\" }`.\n * extractCountryCallingCode('2133734253', 'US', null, null, metadata)\n * extractCountryCallingCode('2133734253', null, 'US', null, metadata)\n * extractCountryCallingCode('2133734253', null, null, '1', metadata)\n * extractCountryCallingCode('+12133734253', null, null, null, metadata)\n * extractCountryCallingCode('+12133734253', null, 'RU', null, metadata)\n */\nexport default function extractCountryCallingCode(number, country, defaultCountry, defaultCallingCode, metadataJson) {\n  if (!number) {\n    return {};\n  }\n  var isNumberWithIddPrefix;\n\n  // If this is not an international phone number,\n  // then either extract an \"IDD\" prefix, or extract a\n  // country calling code from a number by autocorrecting it\n  // by prepending a leading `+` in cases when it starts\n  // with the country calling code.\n  // https://wikitravel.org/en/International_dialling_prefix\n  // https://github.com/catamphetamine/libphonenumber-js/issues/376\n  if (number[0] !== '+') {\n    // Convert an \"out-of-country\" dialing phone number\n    // to a proper international phone number.\n    var numberWithoutIDD = stripIddPrefix(number, country || defaultCountry, defaultCallingCode, metadataJson);\n    // If an IDD prefix was stripped then\n    // convert the number to international one\n    // for subsequent parsing.\n    if (numberWithoutIDD && numberWithoutIDD !== number) {\n      isNumberWithIddPrefix = true;\n      number = '+' + numberWithoutIDD;\n    } else {\n      // Check to see if the number starts with the country calling code\n      // for the default country. If so, we remove the country calling code,\n      // and do some checks on the validity of the number before and after.\n      // https://github.com/catamphetamine/libphonenumber-js/issues/376\n      if (country || defaultCountry || defaultCallingCode) {\n        var _extractCountryCallin = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, defaultCountry, defaultCallingCode, metadataJson),\n          countryCallingCode = _extractCountryCallin.countryCallingCode,\n          shorterNumber = _extractCountryCallin.number;\n        if (countryCallingCode) {\n          return {\n            countryCallingCodeSource: 'FROM_NUMBER_WITHOUT_PLUS_SIGN',\n            countryCallingCode: countryCallingCode,\n            number: shorterNumber\n          };\n        }\n      }\n      return {\n        // No need to set it to `UNSPECIFIED`. It can be just `undefined`.\n        // countryCallingCodeSource: 'UNSPECIFIED',\n        number: number\n      };\n    }\n  }\n\n  // `number` can only be international at this point.\n\n  // Fast abortion: country codes do not begin with a '0'\n  if (number[1] === '0') {\n    return {};\n  }\n  var metadata = new Metadata(metadataJson);\n\n  // The thing with country phone codes\n  // is that they are orthogonal to each other\n  // i.e. there's no such country phone code A\n  // for which country phone code B exists\n  // where B starts with A.\n  // Therefore, while scanning digits,\n  // if a valid country code is found,\n  // that means that it is the country code.\n  //\n  var i = 2;\n  while (i - 1 <= MAX_LENGTH_COUNTRY_CODE && i <= number.length) {\n    var _countryCallingCode = number.slice(1, i);\n    if (metadata.hasCallingCode(_countryCallingCode)) {\n      metadata.selectNumberingPlan(_countryCallingCode);\n      return {\n        countryCallingCodeSource: isNumberWithIddPrefix ? 'FROM_NUMBER_WITH_IDD' : 'FROM_NUMBER_WITH_PLUS_SIGN',\n        countryCallingCode: _countryCallingCode,\n        number: number.slice(i)\n      };\n    }\n    i++;\n  }\n  return {};\n}\n\n// The possible values for the returned `countryCallingCodeSource` are:\n//\n// Copy-pasted from:\n// https://github.com/google/libphonenumber/blob/master/resources/phonenumber.proto\n//\n// // The source from which the country_code is derived. This is not set in the\n// // general parsing method, but in the method that parses and keeps raw_input.\n// // New fields could be added upon request.\n// enum CountryCodeSource {\n//  // Default value returned if this is not set, because the phone number was\n//  // created using parse, not parseAndKeepRawInput. hasCountryCodeSource will\n//  // return false if this is the case.\n//  UNSPECIFIED = 0;\n//\n//  // The country_code is derived based on a phone number with a leading \"+\",\n//  // e.g. the French number \"+33 1 42 68 53 00\".\n//  FROM_NUMBER_WITH_PLUS_SIGN = 1;\n//\n//  // The country_code is derived based on a phone number with a leading IDD,\n//  // e.g. the French number \"011 33 1 42 68 53 00\", as it is dialled from US.\n//  FROM_NUMBER_WITH_IDD = 5;\n//\n//  // The country_code is derived based on a phone number without a leading\n//  // \"+\", e.g. the French number \"33 1 42 68 53 00\" when defaultCountry is\n//  // supplied as France.\n//  FROM_NUMBER_WITHOUT_PLUS_SIGN = 10;\n//\n//  // The country_code is derived NOT based on the phone number itself, but\n//  // from the defaultCountry parameter provided in the parsing function by the\n//  // clients. This happens mostly for numbers written in the national format\n//  // (without country code). For example, this would be set when parsing the\n//  // French number \"01 42 68 53 00\", when defaultCountry is supplied as\n//  // France.\n//  FROM_DEFAULT_COUNTRY = 20;\n// }\n//# sourceMappingURL=extractCountryCallingCode.js.map"],"x_google_ignoreList":[0],"mappings":";;;;AA6BA,SAAwB,EAA0B,GAAQ,GAAS,GAAgB,GAAoB,GAAc;CACnH,IAAI,CAAC,GACH,OAAO,CAAC;CAEV,IAAI;CASJ,IAAI,EAAO,OAAO,KAAK;EAGrB,IAAI,IAAmB,EAAe,GAAQ,KAAW,GAAgB,GAAoB,CAAY;EAIzG,IAAI,KAAoB,MAAqB,GAE3C,AADA,IAAwB,IACxB,IAAS,MAAM;OACV;GAKL,IAAI,KAAW,KAAkB,GAAoB;IACnD,IAAI,IAAwB,EAAgE,GAAQ,GAAS,GAAgB,GAAoB,CAAY,GAC3J,IAAqB,EAAsB,oBAC3C,IAAgB,EAAsB;IACxC,IAAI,GACF,OAAO;KACL,0BAA0B;KACN;KACpB,QAAQ;IACV;GAEJ;GACA,OAAO,EAGG,UACV;EACF;CACF;CAKA,IAAI,EAAO,OAAO,KAChB,OAAO,CAAC;CAcV,KAZA,IAAI,IAAW,IAAI,EAAS,CAAY,GAWpC,IAAI,GACD,IAAI,KAAA,KAAgC,KAAK,EAAO,SAAQ;EAC7D,IAAI,IAAsB,EAAO,MAAM,GAAG,CAAC;EAC3C,IAAI,EAAS,eAAe,CAAmB,GAE7C,OADA,EAAS,oBAAoB,CAAmB,GACzC;GACL,0BAA0B,IAAwB,yBAAyB;GAC3E,oBAAoB;GACpB,QAAQ,EAAO,MAAM,CAAC;EACxB;EAEF;CACF;CACA,OAAO,CAAC;AACV"}
+{"version":3,"file":"index324.js","names":["extractNationalNumberFromPossiblyIncompleteNumber","number","metadata","prefixPattern","prefixMatch","nationalNumber","carrierCode","capturedGroupsCount","hasCapturedGroups","prefixBeforeNationalNumber","nationalPrefix","possiblePositionOfTheFirstCapturedGroup"],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/extractNationalNumberFromPossiblyIncompleteNumber.js"],"sourcesContent":["/**\n * Strips any national prefix (such as 0, 1) present in a\n * (possibly incomplete) number provided.\n * \"Carrier codes\" are only used  in Colombia and Brazil,\n * and only when dialing within those countries from a mobile phone to a fixed line number.\n * Sometimes it won't actually strip national prefix\n * and will instead prepend some digits to the `number`:\n * for example, when number `2345678` is passed with `VI` country selected,\n * it will return `{ number: \"3402345678\" }`, because `340` area code is prepended.\n * @param {string} number — National number digits.\n * @param {object} metadata — Metadata with country selected.\n * @return {object} `{ nationalNumber: string, nationalPrefix: string? carrierCode: string? }`. Even if a national prefix was extracted, it's not necessarily present in the returned object, so don't rely on its presence in the returned object in order to find out whether a national prefix has been extracted or not.\n */\nexport default function extractNationalNumberFromPossiblyIncompleteNumber(number, metadata) {\n  if (number && metadata.numberingPlan.nationalPrefixForParsing()) {\n    // See METADATA.md for the description of\n    // `national_prefix_for_parsing` and `national_prefix_transform_rule`.\n    // Attempt to parse the first digits as a national prefix.\n    var prefixPattern = new RegExp('^(?:' + metadata.numberingPlan.nationalPrefixForParsing() + ')');\n    var prefixMatch = prefixPattern.exec(number);\n    if (prefixMatch) {\n      var nationalNumber;\n      var carrierCode;\n      // https://gitlab.com/catamphetamine/libphonenumber-js/-/blob/master/METADATA.md#national_prefix_for_parsing--national_prefix_transform_rule\n      // If a `national_prefix_for_parsing` has any \"capturing groups\"\n      // then it means that the national (significant) number is equal to\n      // those \"capturing groups\" transformed via `national_prefix_transform_rule`,\n      // and nothing could be said about the actual national prefix:\n      // what is it and was it even there.\n      // If a `national_prefix_for_parsing` doesn't have any \"capturing groups\",\n      // then everything it matches is a national prefix.\n      // To determine whether `national_prefix_for_parsing` matched any\n      // \"capturing groups\", the value of the result of calling `.exec()`\n      // is looked at, and if it has non-undefined values where there're\n      // \"capturing groups\" in the regular expression, then it means\n      // that \"capturing groups\" have been matched.\n      // It's not possible to tell whether there'll be any \"capturing gropus\"\n      // before the matching process, because a `national_prefix_for_parsing`\n      // could exhibit both behaviors.\n      var capturedGroupsCount = prefixMatch.length - 1;\n      var hasCapturedGroups = capturedGroupsCount > 0 && prefixMatch[capturedGroupsCount];\n      if (metadata.nationalPrefixTransformRule() && hasCapturedGroups) {\n        nationalNumber = number.replace(prefixPattern, metadata.nationalPrefixTransformRule());\n        // If there's more than one captured group,\n        // then carrier code is the second one.\n        if (capturedGroupsCount > 1) {\n          carrierCode = prefixMatch[1];\n        }\n      }\n      // If there're no \"capturing groups\",\n      // or if there're \"capturing groups\" but no\n      // `national_prefix_transform_rule`,\n      // then just strip the national prefix from the number,\n      // and possibly a carrier code.\n      // Seems like there could be more.\n      else {\n        // `prefixBeforeNationalNumber` is the whole substring matched by\n        // the `national_prefix_for_parsing` regular expression.\n        // There seem to be no guarantees that it's just a national prefix.\n        // For example, if there's a carrier code, it's gonna be a\n        // part of `prefixBeforeNationalNumber` too.\n        var prefixBeforeNationalNumber = prefixMatch[0];\n        nationalNumber = number.slice(prefixBeforeNationalNumber.length);\n        // If there's at least one captured group,\n        // then carrier code is the first one.\n        if (hasCapturedGroups) {\n          carrierCode = prefixMatch[1];\n        }\n      }\n      // Tries to guess whether a national prefix was present in the input.\n      // This is not something copy-pasted from Google's library:\n      // they don't seem to have an equivalent for that.\n      // So this isn't an \"officially approved\" way of doing something like that.\n      // But since there seems no other existing method, this library uses it.\n      var nationalPrefix;\n      if (hasCapturedGroups) {\n        var possiblePositionOfTheFirstCapturedGroup = number.indexOf(prefixMatch[1]);\n        var possibleNationalPrefix = number.slice(0, possiblePositionOfTheFirstCapturedGroup);\n        // Example: an Argentinian (AR) phone number `0111523456789`.\n        // `prefixMatch[0]` is `01115`, and `$1` is `11`,\n        // and the rest of the phone number is `23456789`.\n        // The national number is transformed via `9$1` to `91123456789`.\n        // National prefix `0` is detected being present at the start.\n        // if (possibleNationalPrefix.indexOf(metadata.numberingPlan.nationalPrefix()) === 0) {\n        if (possibleNationalPrefix === metadata.numberingPlan.nationalPrefix()) {\n          nationalPrefix = metadata.numberingPlan.nationalPrefix();\n        }\n      } else {\n        nationalPrefix = prefixMatch[0];\n      }\n      return {\n        nationalNumber: nationalNumber,\n        nationalPrefix: nationalPrefix,\n        carrierCode: carrierCode\n      };\n    }\n  }\n  return {\n    nationalNumber: number\n  };\n}\n//# sourceMappingURL=extractNationalNumberFromPossiblyIncompleteNumber.js.map"],"ignoreList":[0],"mappings":";AAaA,SAAwBA,EAAkD,GAAQ,GAAU;CAC1F,IAAIC,KAAUC,EAAS,cAAc,yBAAyB,GAAG;EAI/D,IAAIC,IAAoB,OAAO,SAASD,EAAS,cAAc,yBAAyB,IAAI,GAAG,GAC3FE,IAAcD,EAAc,KAAKF,CAAM;EAC3C,IAAIG,GAAa;GACf,IAAIC,GACAC,GAiBAC,IAAsBH,EAAY,SAAS,GAC3CI,IAAoBD,IAAsB,KAAKH,EAAYG;GAC/D,IAAIL,EAAS,4BAA4B,KAAKM,GAI5C,AAHA,IAAiBP,EAAO,QAAQE,GAAeD,EAAS,4BAA4B,CAAC,GAGjFK,IAAsB,MACxB,IAAcH,EAAY;QASzB;IAMH,IAAIK,IAA6BL,EAAY;IAI7C,AAHA,IAAiBH,EAAO,MAAMQ,EAA2B,MAAM,GAG3DD,MACF,IAAcJ,EAAY;GAE9B;GAMA,IAAIM;GACJ,IAAIF,GAAmB;IACrB,IAAIG,IAA0CV,EAAO,QAAQG,EAAY,EAAE;IAQ3E,AAP6BH,EAAO,MAAM,GAAGU,CAOpB,MAAMT,EAAS,cAAc,eAAe,MACnE,IAAiBA,EAAS,cAAc,eAAe;GAE3D,OACE,IAAiBE,EAAY;GAE/B,OAAO;IACW;IACA;IACH;GACf;EACF;CACF;CACA,OAAO,EACL,gBAAgBH,EAClB;AACF"}

package/dist/index325.js

@@ -1,9 +1,45 @@
-import { VALID_PUNCTUATION as e } from "./index317.js";
-//#region ../../node_modules/libphonenumber-js/es6/helpers/applyInternationalSeparatorStyle.js
-function t(t) {
-	return t.replace(RegExp(`[${e}]+`, "g"), " ").trim();
+import e from "./index312.js";
+import t from "./index317.js";
+//#region ../../node_modules/libphonenumber-js/es6/helpers/getCountryByNationalNumber.js
+function n(e, t) {
+	var n = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+	if (n) return (n = n.call(e)).next.bind(n);
+	if (Array.isArray(e) || (n = r(e)) || t && e && typeof e.length == "number") {
+		n && (e = n);
+		var i = 0;
+		return function() {
+			return i >= e.length ? { done: !0 } : {
+				done: !1,
+				value: e[i++]
+			};
+		};
+	}
+	throw TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function r(e, t) {
+	if (e) {
+		if (typeof e == "string") return i(e, t);
+		var n = {}.toString.call(e).slice(8, -1);
+		return n === "Object" && e.constructor && (n = e.constructor.name), n === "Map" || n === "Set" ? Array.from(e) : n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? i(e, t) : void 0;
+	}
+}
+function i(e, t) {
+	(t == null || t > e.length) && (t = e.length);
+	for (var n = 0, r = Array(t); n < t; n++) r[n] = e[n];
+	return r;
+}
+function a(r, i, a) {
+	for (var o = new e(a), s = n(i), c; !(c = s()).done;) {
+		var l = c.value;
+		if (o.selectNumberingPlan(l), o.leadingDigits()) {
+			if (r && r.search(o.leadingDigits()) === 0) return l;
+		} else if (t({
+			phone: r,
+			country: l
+		}, void 0, o.metadata)) return l;
+	}
 }
 //#endregion
-export { t as default };
+export { a as default };
 
 //# sourceMappingURL=index325.js.map

package/dist/index325.js.map

@@ -1 +1 @@
-{"version":3,"file":"index325.js","names":[],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/applyInternationalSeparatorStyle.js"],"sourcesContent":["import { VALID_PUNCTUATION } from '../constants.js';\n\n// Removes brackets and replaces dashes with spaces.\n//\n// E.g. \"(999) 111-22-33\" -> \"999 111 22 33\"\n//\n// For some reason Google's metadata contains `<intlFormat/>`s with brackets and dashes.\n// Meanwhile, there's no single opinion about using punctuation in international phone numbers.\n//\n// For example, Google's `<intlFormat/>` for USA is `+1 213-373-4253`.\n// And here's a quote from WikiPedia's \"North American Numbering Plan\" page:\n// https://en.wikipedia.org/wiki/North_American_Numbering_Plan\n//\n// \"The country calling code for all countries participating in the NANP is 1.\n// In international format, an NANP number should be listed as +1 301 555 01 00,\n// where 301 is an area code (Maryland).\"\n//\n// I personally prefer the international format without any punctuation.\n// For example, brackets are remnants of the old age, meaning that the\n// phone number part in brackets (so called \"area code\") can be omitted\n// if dialing within the same \"area\".\n// And hyphens were clearly introduced for splitting local numbers into memorizable groups.\n// For example, remembering \"5553535\" is difficult but \"555-35-35\" is much simpler.\n// Imagine a man taking a bus from home to work and seeing an ad with a phone number.\n// He has a couple of seconds to memorize that number until it passes by.\n// If it were spaces instead of hyphens the man wouldn't necessarily get it,\n// but with hyphens instead of spaces the grouping is more explicit.\n// I personally think that hyphens introduce visual clutter,\n// so I prefer replacing them with spaces in international numbers.\n// In the modern age all output is done on displays where spaces are clearly distinguishable\n// so hyphens can be safely replaced with spaces without losing any legibility.\n//\nexport default function applyInternationalSeparatorStyle(formattedNumber) {\n  return formattedNumber.replace(new RegExp(\"[\".concat(VALID_PUNCTUATION, \"]+\"), 'g'), ' ').trim();\n}\n//# sourceMappingURL=applyInternationalSeparatorStyle.js.map"],"x_google_ignoreList":[0],"mappings":";;AAgCA,SAAwB,EAAiC,GAAiB;CACxE,OAAO,EAAgB,QAAY,OAAO,IAAW,OAA0B,GAAG,GAAG,GAAG,CAAC,CAAC,KAAK;AACjG"}
+{"version":3,"file":"index325.js","names":["Metadata","getNumberType","_createForOfIteratorHelperLoose","t","r","_unsupportedIterableToArray","e","o","_arrayLikeToArray","a","n","getCountryByNationalNumber","metadata","metadataJson","_iterator","countries","_step","country","nationalNumber"],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/getCountryByNationalNumber.js"],"sourcesContent":["function _createForOfIteratorHelperLoose(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nimport Metadata from '../metadata.js';\nimport getNumberType from './getNumberType.js';\n\n/**\n * Returns the exact country that a given national (significant) number belongs to\n * in case of ambiguity, i.e. when multiple countries share the same \"country calling code\".\n * @param {string} [nationalNumber]\n * @param {string[]} countries — A list of countries that share the same calling code.\n * @param {object} metadata — Metadata JSON.\n * @returns {string?} Returns the exact country this number belongs to, or `undefined` if the exact country couldn't be determined.\n */\nexport default function getCountryByNationalNumber(nationalNumber, countries, metadataJson) {\n  // Create a new `metadata` instance because it will be selecting a `country`.\n  var metadata = new Metadata(metadataJson);\n\n  // const matchingCountries = []\n\n  for (var _iterator = _createForOfIteratorHelperLoose(countries), _step; !(_step = _iterator()).done;) {\n    var country = _step.value;\n    metadata.selectNumberingPlan(country);\n    // \"Leading digits\" patterns are only defined for about 20% of all countries.\n    // By definition, matching \"leading digits\" is a sufficient but not a necessary\n    // condition for a phone number to belong to a country.\n    // The point of \"leading digits\" check is that it's the fastest one to get a match.\n    // https://gitlab.com/catamphetamine/libphonenumber-js/blob/master/METADATA.md#leading_digits\n    // I'd suppose that \"leading digits\" patterns are mutually exclusive for different countries\n    // because of the intended use of that feature.\n    if (metadata.leadingDigits()) {\n      if (nationalNumber && nationalNumber.search(metadata.leadingDigits()) === 0) {\n        return country;\n      }\n    }\n    // Else perform full validation with all of those\n    // fixed-line/mobile/etc regular expressions.\n    else if (getNumberType({\n      phone: nationalNumber,\n      country: country\n    }, undefined, metadata.metadata)) {\n      // When multiple countries share the same \"country calling code\",\n      // type patterns aren't guaranteed to be unique among them.\n      // For example, both `US` and `CA` have the same pattern for `toll_free` numbers.\n      // https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/103#note_1417147572\n      //\n      // That means that this `if` condition could be `true` for multiple countries from the list.\n      // Currently, it just returns the first one, which is also the \"main\" country for the \"country calling code\".\n      // In an example with `toll_free` numbers above, `\"US\"` would be returned even though\n      // it could as well be `\"CA\"`.\n      //\n      // There was also a time when this attempted to be overly smart\n      // and kept track of all such multiple matching countries\n      // and then picked the one that matched the `defaultCountry`, if provided.\n      // For example, with `toll_free` numbers above, and with `defaultCountry: \"CA\"`,\n      // it would've returned `\"CA\"` instead of `\"US\"`.\n      // Later it turned out that such \"overly smart\" behavior turned out to be just confusing,\n      // so this \"overly smart\" country detection was reverted to returning the \"main\" country\n      // for the \"country calling code\".\n      // https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/154\n      //\n      return country;\n      //\n      // The \"overly smart\" behavior code:\n      //\n      // if (defaultCountry) {\n      // \tif (country === defaultCountry) {\n      // \t\treturn country\n      // \t} else {\n      // \t\tmatchingCountries.push(country)\n      // \t}\n      // } else {\n      // \treturn country\n      // }\n    }\n  }\n\n  // // Return the first (\"main\") one of the `matchingCountries`.\n  // if (matchingCountries.length > 0) {\n  // \treturn matchingCountries[0]\n  // }\n}\n//# sourceMappingURL=getCountryByNationalNumber.js.map"],"ignoreList":[0],"mappings":";;;AAAA,SAASE,EAAgC,GAAG,GAAG;CAAE,IAAIC,IAAmB,OAAO,SAAtB,OAAgCC,EAAE,OAAO,aAAaA,EAAE;CAAe,IAAID,GAAG,QAAQ,IAAIA,EAAE,KAAKC,CAAC,EAAA,CAAG,KAAK,KAAKD,CAAC;CAAG,IAAI,MAAM,QAAQC,CAAC,MAAM,IAAIC,EAA4BD,CAAC,MAAME,KAAKF,KAAiB,OAAOA,EAAE,UAArB,UAA6B;EAAE,MAAM,IAAID;EAAI,IAAII,IAAI;EAAG,OAAO,WAAY;GAAE,OAAOA,KAAKH,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,IAAI;IAAE,MAAM,CAAC;IAAG,OAAOA,EAAE;GAAK;EAAG;CAAG;CAAE,MAAU,UAAU,uIAAuI;AAAG;AACziB,SAASC,EAA4B,GAAG,GAAG;CAAE,IAAID,GAAG;EAAE,IAAgB,OAAOA,KAAnB,UAAsB,OAAOI,EAAkBJ,GAAGK,CAAC;EAAG,IAAIN,IAAI,CAAC,EAAE,SAAS,KAAKC,CAAC,CAAC,CAAC,MAAM,GAAG,EAAE;EAAG,OAAoBD,MAAb,YAAkBC,EAAE,gBAAgB,IAAIA,EAAE,YAAY,OAAiBD,MAAV,SAAyBA,MAAV,QAAc,MAAM,KAAKC,CAAC,IAAoBD,MAAhB,eAAqB,2CAA2C,KAAKA,CAAC,IAAIK,EAAkBJ,GAAGK,CAAC,IAAI,KAAK;CAAG;AAAE;AACzX,SAASD,EAAkB,GAAG,GAAG;CAAE,CAASC,KAAR,QAAaA,IAAIL,EAAE,YAAY,IAAIA,EAAE;CAAS,KAAK,IAAIE,IAAI,GAAGI,IAAI,MAAMD,CAAC,GAAGH,IAAIG,GAAG,KAAK,EAAEH,KAAKF,EAAEE;CAAI,OAAOI;AAAG;AAYnJ,SAAwBC,EAA2B,GAAgB,GAAW,GAAc;CAM1F,KAAK,IAJDC,IAAW,IAAIZ,EAASa,CAAY,GAI/BC,IAAYZ,EAAgCa,CAAS,GAAGC,GAAO,EAAE,IAAQF,EAAU,EAAA,CAAG,OAAO;EACpG,IAAIG,IAAUD,EAAM;EASpB,IARAJ,EAAS,oBAAoBK,CAAO,GAQhCL,EAAS,cAAc,GACrB;OAAAM,KAAkBA,EAAe,OAAON,EAAS,cAAc,CAAC,MAAM,GACxE,OAAOK;EAAA,OAKN,IAAIhB,EAAc;GACrB,OAAOiB;GACE;EACX,GAAG,KAAA,GAAWN,EAAS,QAAQ,GAqB7B,OAAOK;CAcX;AAMF"}

package/dist/index326.js

@@ -1,13 +1,9 @@
 import e from "./index325.js";
-//#region ../../node_modules/libphonenumber-js/es6/helpers/formatNationalNumberUsingFormat.js
-var t = /(\$\d)/;
-function n(n, r, i) {
-	var a = i.useInternationalFormat, o = i.withNationalPrefix;
-	i.carrierCode, i.metadata;
-	var s = n.replace(new RegExp(r.pattern()), a ? r.internationalFormat() : o && r.nationalPrefixFormattingRule() ? r.format().replace(t, r.nationalPrefixFormattingRule()) : r.format());
-	return a ? e(s) : s;
+function t(t, n) {
+	var r = n.nationalNumber, i = n.metadata, a = i.getCountryCodesForCallingCode(t);
+	if (a) return a.length === 1 ? a[0] : e(r, a, i.metadata);
 }
 //#endregion
-export { t as FIRST_GROUP_PATTERN, n as default };
+export { t as default };
 
 //# sourceMappingURL=index326.js.map

package/dist/index326.js.map

@@ -1 +1 @@
-{"version":3,"file":"index326.js","names":[],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/formatNationalNumberUsingFormat.js"],"sourcesContent":["import applyInternationalSeparatorStyle from './applyInternationalSeparatorStyle.js';\n\n// This was originally set to $1 but there are some countries for which the\n// first group is not used in the national pattern (e.g. Argentina) so the $1\n// group does not match correctly. Therefore, we use `\\d`, so that the first\n// group actually used in the pattern will be matched.\nexport var FIRST_GROUP_PATTERN = /(\\$\\d)/;\nexport default function formatNationalNumberUsingFormat(number, format, _ref) {\n  var useInternationalFormat = _ref.useInternationalFormat,\n    withNationalPrefix = _ref.withNationalPrefix,\n    carrierCode = _ref.carrierCode,\n    metadata = _ref.metadata;\n  var formattedNumber = number.replace(new RegExp(format.pattern()), useInternationalFormat ? format.internationalFormat() :\n  // This library doesn't use `domestic_carrier_code_formatting_rule`,\n  // because that one is only used when formatting phone numbers\n  // for dialing from a mobile phone, and this is not a dialing library.\n  // carrierCode && format.domesticCarrierCodeFormattingRule()\n  // \t// First, replace the $CC in the formatting rule with the desired carrier code.\n  // \t// Then, replace the $FG in the formatting rule with the first group\n  // \t// and the carrier code combined in the appropriate way.\n  // \t? format.format().replace(FIRST_GROUP_PATTERN, format.domesticCarrierCodeFormattingRule().replace('$CC', carrierCode))\n  // \t: (\n  // \t\twithNationalPrefix && format.nationalPrefixFormattingRule()\n  // \t\t\t? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule())\n  // \t\t\t: format.format()\n  // \t)\n  withNationalPrefix && format.nationalPrefixFormattingRule() ? format.format().replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule()) : format.format());\n  if (useInternationalFormat) {\n    return applyInternationalSeparatorStyle(formattedNumber);\n  }\n  return formattedNumber;\n}\n//# sourceMappingURL=formatNationalNumberUsingFormat.js.map"],"x_google_ignoreList":[0],"mappings":";;AAMA,IAAW,IAAsB;AACjC,SAAwB,EAAgC,GAAQ,GAAQ,GAAM;CAC5E,IAAI,IAAyB,EAAK,wBAChC,IAAqB,EAAK;CAEf,AADG,EAAK,aACR,EAAK;CAClB,IAAI,IAAkB,EAAO,QAAQ,IAAI,OAAO,EAAO,QAAQ,CAAC,GAAG,IAAyB,EAAO,oBAAoB,IAcvH,KAAsB,EAAO,6BAA6B,IAAI,EAAO,OAAO,CAAC,CAAC,QAAQ,GAAqB,EAAO,6BAA6B,CAAC,IAAI,EAAO,OAAO,CAAC;CAInK,OAHI,IACK,EAAiC,CAAe,IAElD;AACT"}
+{"version":3,"file":"index326.js","names":["getCountryByNationalNumber","getCountryByCallingCode","nationalNumber","_ref","metadata","possibleCountries","callingCode"],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/getCountryByCallingCode.js"],"sourcesContent":["import getCountryByNationalNumber from './getCountryByNationalNumber.js';\nvar USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;\n\n/**\n * Returns the exact country that a given national (significant) number belongs to\n * in case of ambiguity, i.e. when multiple countries share the same \"country calling code\".\n * @param {string} [callingCode]\n * @param {string} [options.nationalNumber] — National (significant) number.\n * @param {Metadata} options.metadata — Metadata instance.\n * @returns {string?} Returns the most suitable country for this calling code and national (significant) number.\n */\nexport default function getCountryByCallingCode(callingCode, _ref) {\n  var nationalNumber = _ref.nationalNumber,\n    metadata = _ref.metadata;\n  /* istanbul ignore if */\n  if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {\n    if (metadata.isNonGeographicCallingCode(callingCode)) {\n      return '001';\n    }\n  }\n  var possibleCountries = metadata.getCountryCodesForCallingCode(callingCode);\n  if (!possibleCountries) {\n    return;\n  }\n  // If there's just one country corresponding to the country code,\n  // then just return it, without further phone number digits validation.\n  if (possibleCountries.length === 1) {\n    return possibleCountries[0];\n  }\n  return getCountryByNationalNumber(nationalNumber, possibleCountries, metadata.metadata);\n}\n//# sourceMappingURL=getCountryByCallingCode.js.map"],"ignoreList":[0],"mappings":";AAWA,SAAwBC,EAAwB,GAAa,GAAM;CACjE,IAAIC,IAAiBC,EAAK,gBACxBC,IAAWD,EAAK,UAOdE,IAAoBD,EAAS,8BAA8BE,CAAW;CAC1E,IAAKD,GAQL,OAHIA,EAAkB,WAAW,IACxBA,EAAkB,KAEpBL,EAA2BE,GAAgBG,GAAmBD,EAAS,QAAQ;AACxF"}

package/dist/index327.js

@@ -1,12 +1,29 @@
-import e from "./index307.js";
-//#region ../../node_modules/libphonenumber-js/es6/helpers/getIddPrefix.js
-var t = /^[\d]+(?:[~\u2053\u223C\uFF5E][\d]+)?$/;
-function n(n, r, i) {
-	var a = new e(i);
-	if (a.selectNumberingPlan(n || r), a.defaultIDDPrefix()) return a.defaultIDDPrefix();
-	if (t.test(a.IDDPrefix())) return a.IDDPrefix();
+import e from "./index314.js";
+import t from "./index316.js";
+import n from "./index324.js";
+import r from "./index326.js";
+//#region ../../node_modules/libphonenumber-js/es6/helpers/extractNationalNumber.js
+function i(e, t, i) {
+	var s = n(e, i), c = s.carrierCode, l = s.nationalNumber;
+	return l !== e && (!a(e, l, i) || i.numberingPlan.possibleLengths() && (t ||= r(i.numberingPlan.callingCode(), {
+		nationalNumber: l,
+		metadata: i
+	}), !o(l, t, i))) ? { nationalNumber: e } : {
+		nationalNumber: l,
+		carrierCode: c
+	};
+}
+function a(e, n, r) {
+	return !(t(e, r.nationalNumberPattern()) && !t(n, r.nationalNumberPattern()));
+}
+function o(t, n, r) {
+	switch (e(t, n, r)) {
+		case "TOO_SHORT":
+		case "INVALID_LENGTH": return !1;
+		default: return !0;
+	}
 }
 //#endregion
-export { n as default };
+export { i as default };
 
 //# sourceMappingURL=index327.js.map

package/dist/index327.js.map

@@ -1 +1 @@
-{"version":3,"file":"index327.js","names":[],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/getIddPrefix.js"],"sourcesContent":["import Metadata from '../metadata.js';\n\n/**\n * Pattern that makes it easy to distinguish whether a region has a single\n * international dialing prefix or not. If a region has a single international\n * prefix (e.g. 011 in USA), it will be represented as a string that contains\n * a sequence of ASCII digits, and possibly a tilde, which signals waiting for\n * the tone. If there are multiple available international prefixes in a\n * region, they will be represented as a regex string that always contains one\n * or more characters that are not ASCII digits or a tilde.\n */\nvar SINGLE_IDD_PREFIX_REG_EXP = /^[\\d]+(?:[~\\u2053\\u223C\\uFF5E][\\d]+)?$/;\n\n// If the `country` supports IDD calling, it returns a preferred IDD prefix.\n// If the `country` doesn't support IDD calling, it returns `undefined`.\nexport default function getIddPrefix(country, callingCode, metadata) {\n  var countryMetadata = new Metadata(metadata);\n  countryMetadata.selectNumberingPlan(country || callingCode);\n  if (countryMetadata.defaultIDDPrefix()) {\n    return countryMetadata.defaultIDDPrefix();\n  }\n  if (SINGLE_IDD_PREFIX_REG_EXP.test(countryMetadata.IDDPrefix())) {\n    return countryMetadata.IDDPrefix();\n  }\n}\n//# sourceMappingURL=getIddPrefix.js.map"],"x_google_ignoreList":[0],"mappings":";;AAWA,IAAI,IAA4B;AAIhC,SAAwB,EAAa,GAAS,GAAa,GAAU;CACnE,IAAI,IAAkB,IAAI,EAAS,CAAQ;CAE3C,IADA,EAAgB,oBAAoB,KAAW,CAAW,GACtD,EAAgB,iBAAiB,GACnC,OAAO,EAAgB,iBAAiB;CAE1C,IAAI,EAA0B,KAAK,EAAgB,UAAU,CAAC,GAC5D,OAAO,EAAgB,UAAU;AAErC"}
+{"version":3,"file":"index327.js","names":["checkNumberLength","matchesEntirely","extractNationalNumberFromPossiblyIncompleteNumber","getCountryByCallingCode","extractNationalNumber","_extractNationalNumbe","number","metadata","carrierCode","nationalNumber","shouldHaveExtractedNationalPrefix","country","isPossibleIncompleteNationalNumber","nationalNumberBefore","nationalNumberAfter"],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/extractNationalNumber.js"],"sourcesContent":["import extractNationalNumberFromPossiblyIncompleteNumber from './extractNationalNumberFromPossiblyIncompleteNumber.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport checkNumberLength from './checkNumberLength.js';\nimport getCountryByCallingCode from './getCountryByCallingCode.js';\n\n/**\n * Strips national prefix and carrier code from a complete phone number.\n * The difference from the non-\"FromCompleteNumber\" function is that\n * it won't extract national prefix if the resultant number is too short\n * to be a complete number for the selected phone numbering plan.\n * @param  {string} number — Complete phone number digits.\n * @param  {string?} country — Specific country to use instead of the one that is pre-selected in the metadata instance.\n * @param  {Metadata} metadata — Metadata instance with a selected numbering plan.\n * @return {object} `{ nationalNumber: string, carrierCode: string? }`.\n */\nexport default function extractNationalNumber(number, country, metadata) {\n  // Parsing national prefixes and carrier codes\n  // is only required for local phone numbers\n  // but some people don't understand that\n  // and sometimes write international phone numbers\n  // with national prefixes (or maybe even carrier codes).\n  // http://ucken.blogspot.ru/2016/03/trunk-prefixes-in-skype4b.html\n  // Google's original library forgives such mistakes\n  // and so does this library, because it has been requested:\n  // https://github.com/catamphetamine/libphonenumber-js/issues/127\n  var _extractNationalNumbe = extractNationalNumberFromPossiblyIncompleteNumber(number, metadata),\n    carrierCode = _extractNationalNumbe.carrierCode,\n    nationalNumber = _extractNationalNumbe.nationalNumber;\n  if (nationalNumber !== number) {\n    if (!shouldHaveExtractedNationalPrefix(number, nationalNumber, metadata)) {\n      // Don't strip the national prefix.\n      return {\n        nationalNumber: number\n      };\n    }\n    // Check the national (significant) number length after extracting national prefix and carrier code.\n    // Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature,\n    // so this `if` will only be executed with newer metadata.\n    if (metadata.numberingPlan.possibleLengths()) {\n      // If an exact `country` is not specified, attempt to detect it from the assumed national number.\n      if (!country) {\n        country = getCountryByCallingCode(metadata.numberingPlan.callingCode(), {\n          nationalNumber: nationalNumber,\n          metadata: metadata\n        });\n      }\n\n      // The number remaining after stripping the national prefix and carrier code\n      // should be long enough to have a possible length for the country.\n      // Otherwise, don't strip the national prefix and carrier code,\n      // since the original number could be a valid number.\n      // This check has been copy-pasted \"as is\" from Google's original library:\n      // https://github.com/google/libphonenumber/blob/876268eb1ad6cdc1b7b5bef17fc5e43052702d57/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L3236-L3250\n      // It doesn't check for the \"possibility\" of the original `number`.\n      // I guess it's fine not checking that one. It works as is anyway.\n      if (!isPossibleIncompleteNationalNumber(nationalNumber, country, metadata)) {\n        // Don't strip the national prefix.\n        return {\n          nationalNumber: number\n        };\n      }\n    }\n  }\n  return {\n    nationalNumber: nationalNumber,\n    carrierCode: carrierCode\n  };\n}\n\n// In some countries, the same digit could be a national prefix\n// or a leading digit of a valid phone number.\n// For example, in Russia, national prefix is `8`,\n// and also `800 555 35 35` is a valid number\n// in which `8` is not a national prefix, but the first digit\n// of a national (significant) number.\n// Same's with Belarus:\n// `82004910060` is a valid national (significant) number,\n// but `2004910060` is not.\n// To support such cases (to prevent the code from always stripping\n// national prefix), a condition is imposed: a national prefix\n// is not extracted when the original number is \"viable\" and the\n// resultant number is not, a \"viable\" national number being the one\n// that matches `national_number_pattern`.\nfunction shouldHaveExtractedNationalPrefix(nationalNumberBefore, nationalNumberAfter, metadata) {\n  // The equivalent in Google's code is:\n  // https://github.com/google/libphonenumber/blob/e326fa1fc4283bb05eb35cb3c15c18f98a31af33/java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java#L2969-L3004\n  if (matchesEntirely(nationalNumberBefore, metadata.nationalNumberPattern()) && !matchesEntirely(nationalNumberAfter, metadata.nationalNumberPattern())) {\n    return false;\n  }\n  // This \"is possible\" national number (length) check has been commented out\n  // because it's superceded by the (effectively) same check done in the\n  // `extractNationalNumber()` function after it calls `shouldHaveExtractedNationalPrefix()`.\n  // In other words, why run the same check twice if it could only be run once.\n  // // Check the national (significant) number length after extracting national prefix and carrier code.\n  // // Fixes a minor \"weird behavior\" bug: https://gitlab.com/catamphetamine/libphonenumber-js/-/issues/57\n  // // (Legacy generated metadata (before `1.0.18`) didn't support the \"possible lengths\" feature).\n  // if (metadata.possibleLengths()) {\n  // \tif (isPossibleIncompleteNationalNumber(nationalNumberBefore, metadata) &&\n  // \t\t!isPossibleIncompleteNationalNumber(nationalNumberAfter, metadata)) {\n  // \t\treturn false\n  // \t}\n  // }\n  return true;\n}\n\n/**\n * Tells if a given incomplete national number is possible or not.\n * @param {string} nationalNumber\n * @param {string?} country — Specific country rather than the one that is pre-selected in the metadata instance.\n * @param {Metadata} metadata — Metadata instance with a selected numbering plan.\n * @returns {boolean}\n */\nfunction isPossibleIncompleteNationalNumber(nationalNumber, country, metadata) {\n  switch (checkNumberLength(nationalNumber, country, metadata)) {\n    case 'TOO_SHORT':\n    case 'INVALID_LENGTH':\n      // This library ignores \"local-only\" phone numbers (for simplicity).\n      // See the readme for more info on what are \"local-only\" phone numbers.\n      // case 'IS_POSSIBLE_LOCAL_ONLY':\n      return false;\n    default:\n      return true;\n  }\n}\n//# sourceMappingURL=extractNationalNumber.js.map"],"ignoreList":[0],"mappings":";;;;;AAeA,SAAwBI,EAAsB,GAAQ,GAAS,GAAU;CAUvE,IAAIC,IAAwBH,EAAkDI,GAAQC,CAAQ,GAC5FC,IAAcH,EAAsB,aACpCI,IAAiBJ,EAAsB;CAoCzC,OAnCII,MAAmBH,MACjB,CAACI,EAAkCJ,GAAQG,GAAgBF,CAAQ,KASnEA,EAAS,cAAc,gBAAgB,MAEzC,AACEI,MAAUR,EAAwBI,EAAS,cAAc,YAAY,GAAG;EACtD;EACN;CACZ,CAAC,GAWC,CAACK,EAAmCH,GAAgBE,GAASJ,CAAQ,MAEhE,EACL,gBAAgBD,EAClB,IAIC;EACW;EACH;CACf;AACF;AAgBA,SAASI,EAAkC,GAAsB,GAAqB,GAAU;CAmB9F,OAhBA,EAAIT,EAAgBY,GAAsBN,EAAS,sBAAsB,CAAC,KAAK,CAACN,EAAgBa,GAAqBP,EAAS,sBAAsB,CAAC;AAiBvJ;AASA,SAASK,EAAmC,GAAgB,GAAS,GAAU;CAC7E,QAAQZ,EAAkBS,GAAgBE,GAASJ,CAAQ,GAA3D;EACE,KAAK;EACL,KAAK,kBAIH,OAAO;EACT,SACE,OAAO;CACX;AACF"}

package/dist/index328.js

@@ -1,13 +1,23 @@
-import { VALID_DIGITS as e } from "./index317.js";
-//#region ../../node_modules/libphonenumber-js/es6/helpers/extension/createExtensionPattern.js
-var t = ";ext=", n = function(t) {
-	return `([${e}]{1,${t}})`;
-};
-function r(e) {
-	var r = "20", i = "15", a = "9", o = "6", s = "[ \xA0\\t,]*", c = "[:\\.．]?[ \xA0\\t,-]*", l = "#?", u = "(?:e?xt(?:ensi(?:ó?|ó))?n?|ｅ?ｘｔｎ?|доб|anexo)", d = "(?:[xｘ#＃~～]|int|ｉｎｔ)", f = "[- ]+", p = "[ \xA0\\t]*", m = "(?:,{2}|;)", h = t + n(r), g = s + u + c + n(r) + l, _ = s + d + c + n(a) + l, v = f + n(o) + "#", y = p + m + c + n(i) + l, b = p + "(?:,)+" + c + n(a) + l;
-	return h + "|" + g + "|" + _ + "|" + v + "|" + y + "|" + b;
+import e, { getCountryCallingCode as t } from "./index312.js";
+import n from "./index314.js";
+import r from "./index316.js";
+import i from "./index327.js";
+//#region ../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js
+function a(a, o, s, c, l) {
+	if (!(o || s || c)) return { number: a };
+	var u = o || s ? t(o || s, l) : c;
+	if (a.indexOf(u) === 0) {
+		var d = new e(l);
+		d.selectNumberingPlan(o || s || c);
+		var f = a.slice(u.length), p = i(f, void 0, d).nationalNumber, m = i(a, void 0, d).nationalNumber;
+		if (!r(m, d.nationalNumberPattern()) && r(p, d.nationalNumberPattern()) || n(m, void 0, d) === "TOO_LONG") return {
+			countryCallingCode: u,
+			number: f
+		};
+	}
+	return { number: a };
 }
 //#endregion
-export { r as default };
+export { a as default };
 
 //# sourceMappingURL=index328.js.map

package/dist/index328.js.map

@@ -1 +1 @@
-{"version":3,"file":"index328.js","names":[],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/extension/createExtensionPattern.js"],"sourcesContent":["import { VALID_DIGITS } from '../../constants.js';\n\n// The RFC 3966 format for extensions.\nvar RFC3966_EXTN_PREFIX = ';ext=';\n\n/**\n * Helper method for constructing regular expressions for parsing. Creates\n * an expression that captures up to max_length digits.\n * @return {string} RegEx pattern to capture extension digits.\n */\nvar getExtensionDigitsPattern = function getExtensionDigitsPattern(maxLength) {\n  return \"([\".concat(VALID_DIGITS, \"]{1,\").concat(maxLength, \"})\");\n};\n\n/**\n * Helper initialiser method to create the regular-expression pattern to match\n * extensions.\n * Copy-pasted from Google's `libphonenumber`:\n * https://github.com/google/libphonenumber/blob/55b2646ec9393f4d3d6661b9c82ef9e258e8b829/javascript/i18n/phonenumbers/phonenumberutil.js#L759-L766\n * @return {string} RegEx pattern to capture extensions.\n */\nexport default function createExtensionPattern(purpose) {\n  // We cap the maximum length of an extension based on the ambiguity of the way\n  // the extension is prefixed. As per ITU, the officially allowed length for\n  // extensions is actually 40, but we don't support this since we haven't seen real\n  // examples and this introduces many false interpretations as the extension labels\n  // are not standardized.\n  /** @type {string} */\n  var extLimitAfterExplicitLabel = '20';\n  /** @type {string} */\n  var extLimitAfterLikelyLabel = '15';\n  /** @type {string} */\n  var extLimitAfterAmbiguousChar = '9';\n  /** @type {string} */\n  var extLimitWhenNotSure = '6';\n\n  /** @type {string} */\n  var possibleSeparatorsBetweenNumberAndExtLabel = \"[ \\xA0\\\\t,]*\";\n  // Optional full stop (.) or colon, followed by zero or more spaces/tabs/commas.\n  /** @type {string} */\n  var possibleCharsAfterExtLabel = \"[:\\\\.\\uFF0E]?[ \\xA0\\\\t,-]*\";\n  /** @type {string} */\n  var optionalExtnSuffix = \"#?\";\n\n  // Here the extension is called out in more explicit way, i.e mentioning it obvious\n  // patterns like \"ext.\".\n  /** @type {string} */\n  var explicitExtLabels = \"(?:e?xt(?:ensi(?:o\\u0301?|\\xF3))?n?|\\uFF45?\\uFF58\\uFF54\\uFF4E?|\\u0434\\u043E\\u0431|anexo)\";\n  // One-character symbols that can be used to indicate an extension, and less\n  // commonly used or more ambiguous extension labels.\n  /** @type {string} */\n  var ambiguousExtLabels = \"(?:[x\\uFF58#\\uFF03~\\uFF5E]|int|\\uFF49\\uFF4E\\uFF54)\";\n  // When extension is not separated clearly.\n  /** @type {string} */\n  var ambiguousSeparator = \"[- ]+\";\n  // This is the same as possibleSeparatorsBetweenNumberAndExtLabel, but not matching\n  // comma as extension label may have it.\n  /** @type {string} */\n  var possibleSeparatorsNumberExtLabelNoComma = \"[ \\xA0\\\\t]*\";\n  // \",,\" is commonly used for auto dialling the extension when connected. First\n  // comma is matched through possibleSeparatorsBetweenNumberAndExtLabel, so we do\n  // not repeat it here. Semi-colon works in Iphone and Android also to pop up a\n  // button with the extension number following.\n  /** @type {string} */\n  var autoDiallingAndExtLabelsFound = \"(?:,{2}|;)\";\n\n  /** @type {string} */\n  var rfcExtn = RFC3966_EXTN_PREFIX + getExtensionDigitsPattern(extLimitAfterExplicitLabel);\n  /** @type {string} */\n  var explicitExtn = possibleSeparatorsBetweenNumberAndExtLabel + explicitExtLabels + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterExplicitLabel) + optionalExtnSuffix;\n  /** @type {string} */\n  var ambiguousExtn = possibleSeparatorsBetweenNumberAndExtLabel + ambiguousExtLabels + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterAmbiguousChar) + optionalExtnSuffix;\n  /** @type {string} */\n  var americanStyleExtnWithSuffix = ambiguousSeparator + getExtensionDigitsPattern(extLimitWhenNotSure) + \"#\";\n\n  /** @type {string} */\n  var autoDiallingExtn = possibleSeparatorsNumberExtLabelNoComma + autoDiallingAndExtLabelsFound + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterLikelyLabel) + optionalExtnSuffix;\n  /** @type {string} */\n  var onlyCommasExtn = possibleSeparatorsNumberExtLabelNoComma + \"(?:,)+\" + possibleCharsAfterExtLabel + getExtensionDigitsPattern(extLimitAfterAmbiguousChar) + optionalExtnSuffix;\n\n  // The first regular expression covers RFC 3966 format, where the extension is added\n  // using \";ext=\". The second more generic where extension is mentioned with explicit\n  // labels like \"ext:\". In both the above cases we allow more numbers in extension than\n  // any other extension labels. The third one captures when single character extension\n  // labels or less commonly used labels are used. In such cases we capture fewer\n  // extension digits in order to reduce the chance of falsely interpreting two\n  // numbers beside each other as a number + extension. The fourth one covers the\n  // special case of American numbers where the extension is written with a hash\n  // at the end, such as \"- 503#\". The fifth one is exclusively for extension\n  // autodialling formats which are used when dialling and in this case we accept longer\n  // extensions. The last one is more liberal on the number of commas that acts as\n  // extension labels, so we have a strict cap on the number of digits in such extensions.\n  return rfcExtn + \"|\" + explicitExtn + \"|\" + ambiguousExtn + \"|\" + americanStyleExtnWithSuffix + \"|\" + autoDiallingExtn + \"|\" + onlyCommasExtn;\n}\n//# sourceMappingURL=createExtensionPattern.js.map"],"x_google_ignoreList":[0],"mappings":";;AAGA,IAAI,IAAsB,SAOtB,IAA4B,SAAmC,GAAW;CAC5E,OAAO,KAAY,QAA6B;AAClD;AASA,SAAwB,EAAuB,GAAS;CAOtD,IAAI,IAA6B,MAE7B,IAA2B,MAE3B,IAA6B,KAE7B,IAAsB,KAGtB,IAA6C,gBAG7C,IAA6B,yBAE7B,IAAqB,MAKrB,IAAoB,iDAIpB,IAAqB,wBAGrB,IAAqB,SAIrB,IAA0C,eAM1C,IAAgC,cAGhC,IAAU,IAAsB,EAA0B,CAA0B,GAEpF,IAAe,IAA6C,IAAoB,IAA6B,EAA0B,CAA0B,IAAI,GAErK,IAAgB,IAA6C,IAAqB,IAA6B,EAA0B,CAA0B,IAAI,GAEvK,IAA8B,IAAqB,EAA0B,CAAmB,IAAI,KAGpG,IAAmB,IAA0C,IAAgC,IAA6B,EAA0B,CAAwB,IAAI,GAEhL,IAAiB,IAA0C,WAAW,IAA6B,EAA0B,CAA0B,IAAI;CAc/J,OAAO,IAAU,MAAM,IAAe,MAAM,IAAgB,MAAM,IAA8B,MAAM,IAAmB,MAAM;AACjI"}
+{"version":3,"file":"index328.js","names":["Metadata","checkNumberLength","matchesEntirely","extractNationalNumber","extractCountryCallingCodeFromInternationalNumberWithoutPlusSign","country","defaultCountry","defaultCallingCode","countryCallingCode","getCountryCallingCode","metadataJson","number","metadata","possibleShorterNumber","possibleShorterNationalNumber","nationalNumber"],"sources":["../../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js"],"sourcesContent":["import Metadata from '../metadata.js';\nimport matchesEntirely from './matchesEntirely.js';\nimport extractNationalNumber from './extractNationalNumber.js';\nimport checkNumberLength from './checkNumberLength.js';\nimport getCountryCallingCode from '../getCountryCallingCode.js';\n\n/**\n * Sometimes some people incorrectly input international phone numbers\n * without the leading `+`. This function corrects such input.\n * @param  {string} number — Phone number digits (only digits, no `+`).\n * @param  {string} [country] — Exact country of the phone number.\n * @param  {string} [defaultCountry]\n * @param  {string} [defaultCallingCode]\n * @param  {object} metadataJson\n * @return {object} `{ countryCallingCode: string?, number: string }`, where `countryCallingCode` is the calling code that was extracted from the input `number` string, and `number` is the originally passed `number` without the extracted calling code.\n */\nexport default function extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(number, country, defaultCountry, defaultCallingCode, metadataJson) {\n  // Validate arguments.\n  // The `number` is known to be in a non-international form\n  // because there's no leading \"+\" character.\n  // Therefore, there must be either `country` or `defaultCountry` or `defaultCallingCode`.\n  // Otherwise, there'd be no source for the calling code to search for in the `number`.\n  if (!(country || defaultCountry || defaultCallingCode)) {\n    // There's no source for the calling code to search for in the `number`.\n    return {\n      number: number\n    };\n  }\n  var countryCallingCode = country || defaultCountry ? getCountryCallingCode(country || defaultCountry, metadataJson) : defaultCallingCode;\n  if (number.indexOf(countryCallingCode) === 0) {\n    var metadata = new Metadata(metadataJson);\n    metadata.selectNumberingPlan(country || defaultCountry || defaultCallingCode);\n    var possibleShorterNumber = number.slice(countryCallingCode.length);\n    var _extractNationalNumbe = extractNationalNumber(possibleShorterNumber, undefined, metadata),\n      possibleShorterNationalNumber = _extractNationalNumbe.nationalNumber;\n    var _extractNationalNumbe2 = extractNationalNumber(number, undefined, metadata),\n      nationalNumber = _extractNationalNumbe2.nationalNumber;\n\n    // If the number was not valid before but is valid now,\n    // or if it was too long before, we consider the number\n    // with the country calling code stripped to be a better result\n    // and keep that instead.\n    // For example, in Germany (+49), `49` is a valid area code,\n    // so if a number starts with `49`, it could be both a valid\n    // national German number or an international number without\n    // a leading `+`.\n    if (!matchesEntirely(nationalNumber, metadata.nationalNumberPattern()) && matchesEntirely(possibleShorterNationalNumber, metadata.nationalNumberPattern()) || checkNumberLength(nationalNumber, undefined, metadata) === 'TOO_LONG') {\n      return {\n        countryCallingCode: countryCallingCode,\n        number: possibleShorterNumber\n      };\n    }\n  }\n  return {\n    number: number\n  };\n}\n//# sourceMappingURL=extractCountryCallingCodeFromInternationalNumberWithoutPlusSign.js.map"],"ignoreList":[0],"mappings":";;;;;AAgBA,SAAwBI,EAAgE,GAAQ,GAAS,GAAgB,GAAoB,GAAc;CAMzJ,IAAI,EAAEC,KAAWC,KAAkBC,IAEjC,OAAO,EACG,UACV;CAEF,IAAIC,IAAqBH,KAAWC,IAAiBG,EAAsBJ,KAAWC,GAAgBI,CAAY,IAAIH;CACtH,IAAII,EAAO,QAAQH,CAAkB,MAAM,GAAG;EAC5C,IAAII,IAAW,IAAIZ,EAASU,CAAY;EACxC,EAAS,oBAAoBL,KAAWC,KAAkBC,CAAkB;EAC5E,IAAIM,IAAwBF,EAAO,MAAMH,EAAmB,MAAM,GAEhEM,IAD0BX,EAAsBU,GAAuB,KAAA,GAAWD,CAC9B,CAAC,CAAC,gBAEtDG,IAD2BZ,EAAsBQ,GAAQ,KAAA,GAAWC,CAC9B,CAAC,CAAC;EAU1C,IAAI,CAACV,EAAgBa,GAAgBH,EAAS,sBAAsB,CAAC,KAAKV,EAAgBY,GAA+BF,EAAS,sBAAsB,CAAC,KAAKX,EAAkBc,GAAgB,KAAA,GAAWH,CAAQ,MAAM,YACvN,OAAO;GACe;GACpB,QAAQC;EACV;CAEJ;CACA,OAAO,EACG,UACV;AACF"}

package/dist/index329.js

@@ -1,14 +1,38 @@
-import { PLUS_CHARS as e, VALID_DIGITS as t, VALID_PUNCTUATION as n } from "./index317.js";
-import r from "./index328.js";
-//#region ../../node_modules/libphonenumber-js/es6/helpers/isViablePhoneNumber.js
-var i = "[" + t + "]{2}", a = "[" + e + "]{0,1}(?:[" + n + "]*[" + t + "]){3,}[" + n + t + "]*", o = RegExp("^[" + e + "]{0,1}(?:[" + n + "]*[" + t + "]){1,2}$", "i"), s = a + "(?:" + r() + ")?", c = RegExp("^" + i + "$|^" + s + "$", "i");
-function l(e) {
-	return e.length >= 2 && c.test(e);
-}
-function u(e) {
-	return o.test(e);
+import e from "./index312.js";
+import t from "./index323.js";
+import n from "./index328.js";
+//#region ../../node_modules/libphonenumber-js/es6/helpers/extractCountryCallingCode.js
+function r(r, i, a, o, s) {
+	if (!r) return {};
+	var c;
+	if (r[0] !== "+") {
+		var l = t(r, i || a, o, s);
+		if (l && l !== r) c = !0, r = "+" + l;
+		else {
+			if (i || a || o) {
+				var u = n(r, i, a, o, s), d = u.countryCallingCode, f = u.number;
+				if (d) return {
+					countryCallingCodeSource: "FROM_NUMBER_WITHOUT_PLUS_SIGN",
+					countryCallingCode: d,
+					number: f
+				};
+			}
+			return { number: r };
+		}
+	}
+	if (r[1] === "0") return {};
+	for (var p = new e(s), m = 2; m - 1 <= 3 && m <= r.length;) {
+		var h = r.slice(1, m);
+		if (p.hasCallingCode(h)) return p.selectNumberingPlan(h), {
+			countryCallingCodeSource: c ? "FROM_NUMBER_WITH_IDD" : "FROM_NUMBER_WITH_PLUS_SIGN",
+			countryCallingCode: h,
+			number: r.slice(m)
+		};
+		m++;
+	}
+	return {};
 }
 //#endregion
-export { a as VALID_PHONE_NUMBER, s as VALID_PHONE_NUMBER_WITH_EXTENSION, l as default, u as isViablePhoneNumberStart };
+export { r as default };
 
 //# sourceMappingURL=index329.js.map