@incodetech/core 2.3.2-rc.4 → 2.4.0-rc.0

package/dist/phone-number.esm.js

@@ -0,0 +1,1922 @@
+import { C as metadata_min_json_default, S as withMetadataArgument, _ as VALID_PUNCTUATION, a as PhoneNumber, b as getCountryCallingCode$1, c as applyInternationalSeparatorStyle, d as getCountryByCallingCode, f as getCountryByNationalNumber, g as VALID_DIGITS, h as PLUS_CHARS, i as parseDigits, l as extractCountryCallingCode, m as stripIddPrefix, o as FIRST_GROUP_PATTERN, p as extractNationalNumberFromPossiblyIncompleteNumber, r as parsePhoneNumber$1, s as formatNationalNumberUsingFormat, t as PhoneValidationProvider, u as extractCountryCallingCodeFromInternationalNumberWithoutPlusSign, v as checkNumberLength, x as isObject, y as Metadata } from "./PhoneValidationProvider-SZiOS0jB.esm.js";
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/es6/AsYouTypeState.js
+function _typeof$5(o) {
+	"@babel/helpers - typeof";
+	return _typeof$5 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof$5(o);
+}
+function _classCallCheck$5(a, n) {
+	if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties$5(e, r) {
+	for (var t = 0; t < r.length; t++) {
+		var o = r[t];
+		o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey$5(o.key), o);
+	}
+}
+function _createClass$5(e, r, t) {
+	return r && _defineProperties$5(e.prototype, r), t && _defineProperties$5(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+}
+function _toPropertyKey$5(t) {
+	var i = _toPrimitive$5(t, "string");
+	return "symbol" == _typeof$5(i) ? i : i + "";
+}
+function _toPrimitive$5(t, r) {
+	if ("object" != _typeof$5(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof$5(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+var AsYouTypeState = /*#__PURE__*/ function() {
+	function AsYouTypeState(_ref) {
+		var onCountryChange = _ref.onCountryChange, onCallingCodeChange = _ref.onCallingCodeChange;
+		_classCallCheck$5(this, AsYouTypeState);
+		this.onCountryChange = onCountryChange;
+		this.onCallingCodeChange = onCallingCodeChange;
+	}
+	return _createClass$5(AsYouTypeState, [
+		{
+			key: "reset",
+			value: function reset(_ref2) {
+				var country = _ref2.country, callingCode = _ref2.callingCode;
+				this.international = false;
+				this.missingPlus = false;
+				this.IDDPrefix = void 0;
+				this.callingCode = void 0;
+				this.digits = "";
+				this.resetNationalSignificantNumber();
+				this.initCountryAndCallingCode(country, callingCode);
+			}
+		},
+		{
+			key: "resetNationalSignificantNumber",
+			value: function resetNationalSignificantNumber() {
+				this.nationalSignificantNumber = this.getNationalDigits();
+				this.nationalSignificantNumberIsModified = false;
+				this.nationalPrefix = void 0;
+				this.carrierCode = void 0;
+				this.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix = void 0;
+			}
+		},
+		{
+			key: "update",
+			value: function update(properties) {
+				for (var _i = 0, _Object$keys = Object.keys(properties); _i < _Object$keys.length; _i++) {
+					var key = _Object$keys[_i];
+					this[key] = properties[key];
+				}
+			}
+		},
+		{
+			key: "initCountryAndCallingCode",
+			value: function initCountryAndCallingCode(country, callingCode) {
+				this.setCountry(country);
+				this.setCallingCode(callingCode);
+			}
+		},
+		{
+			key: "setCountry",
+			value: function setCountry(country) {
+				this.country = country;
+				this.onCountryChange(country);
+			}
+		},
+		{
+			key: "setCallingCode",
+			value: function setCallingCode(callingCode) {
+				this.callingCode = callingCode;
+				this.onCallingCodeChange(callingCode, this.country);
+			}
+		},
+		{
+			key: "startInternationalNumber",
+			value: function startInternationalNumber(country, callingCode) {
+				this.international = true;
+				this.initCountryAndCallingCode(country, callingCode);
+			}
+		},
+		{
+			key: "appendDigits",
+			value: function appendDigits(nextDigits) {
+				this.digits += nextDigits;
+			}
+		},
+		{
+			key: "appendNationalSignificantNumberDigits",
+			value: function appendNationalSignificantNumberDigits(nextDigits) {
+				this.nationalSignificantNumber += nextDigits;
+			}
+		},
+		{
+			key: "getNationalDigits",
+			value: function getNationalDigits() {
+				if (this.international) return this.digits.slice((this.IDDPrefix ? this.IDDPrefix.length : 0) + (this.callingCode ? this.callingCode.length : 0));
+				return this.digits;
+			}
+		},
+		{
+			key: "getDigitsWithoutInternationalPrefix",
+			value: function getDigitsWithoutInternationalPrefix() {
+				if (this.international) {
+					if (this.IDDPrefix) return this.digits.slice(this.IDDPrefix.length);
+				}
+				return this.digits;
+			}
+		}
+	]);
+}();
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/es6/AsYouTypeFormatter.util.js
+function _createForOfIteratorHelperLoose$2(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$4(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.");
+}
+function _unsupportedIterableToArray$4(r, a) {
+	if (r) {
+		if ("string" == typeof r) return _arrayLikeToArray$4(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$4(r, a) : void 0;
+	}
+}
+function _arrayLikeToArray$4(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;
+}
+var DIGIT_PLACEHOLDER_MATCHER = /* @__PURE__ */ new RegExp("x");
+function repeat(string, times) {
+	if (times < 1) return "";
+	var result = "";
+	while (times > 1) {
+		if (times & 1) result += string;
+		times >>= 1;
+		string += string;
+	}
+	return result + string;
+}
+function cutAndStripNonPairedParens(string, cutBeforeIndex) {
+	if (string[cutBeforeIndex] === ")") cutBeforeIndex++;
+	return stripNonPairedParens(string.slice(0, cutBeforeIndex));
+}
+function stripNonPairedParens(string) {
+	var dangling_braces = [];
+	var i = 0;
+	while (i < string.length) {
+		if (string[i] === "(") dangling_braces.push(i);
+		else if (string[i] === ")") dangling_braces.pop();
+		i++;
+	}
+	var start = 0;
+	var cleared_string = "";
+	dangling_braces.push(string.length);
+	for (var _i = 0, _dangling_braces = dangling_braces; _i < _dangling_braces.length; _i++) {
+		var index = _dangling_braces[_i];
+		cleared_string += string.slice(start, index);
+		start = index + 1;
+	}
+	return cleared_string;
+}
+function populateTemplateWithDigits(template, position, digits) {
+	for (var _iterator2 = _createForOfIteratorHelperLoose$2(digits.split("")), _step2; !(_step2 = _iterator2()).done;) {
+		var digit = _step2.value;
+		if (template.slice(position + 1).search(DIGIT_PLACEHOLDER_MATCHER) < 0) return;
+		position = template.search(DIGIT_PLACEHOLDER_MATCHER);
+		template = template.replace(DIGIT_PLACEHOLDER_MATCHER, digit);
+	}
+	return [template, position];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/es6/AsYouTypeFormatter.complete.js
+function formatCompleteNumber(state, format, _ref) {
+	var metadata = _ref.metadata, shouldTryNationalPrefixFormattingRule = _ref.shouldTryNationalPrefixFormattingRule, getSeparatorAfterNationalPrefix = _ref.getSeparatorAfterNationalPrefix;
+	if (new RegExp("^(?:".concat(format.pattern(), ")$")).test(state.nationalSignificantNumber)) return formatNationalNumberWithAndWithoutNationalPrefixFormattingRule(state, format, {
+		metadata,
+		shouldTryNationalPrefixFormattingRule,
+		getSeparatorAfterNationalPrefix
+	});
+}
+function canFormatCompleteNumber(nationalSignificantNumber, country, metadata) {
+	return checkNumberLength(nationalSignificantNumber, country, metadata) === "IS_POSSIBLE";
+}
+function formatNationalNumberWithAndWithoutNationalPrefixFormattingRule(state, format, _ref2) {
+	var metadata = _ref2.metadata, shouldTryNationalPrefixFormattingRule = _ref2.shouldTryNationalPrefixFormattingRule, getSeparatorAfterNationalPrefix = _ref2.getSeparatorAfterNationalPrefix;
+	state.nationalSignificantNumber;
+	state.international;
+	state.nationalPrefix;
+	state.carrierCode;
+	if (shouldTryNationalPrefixFormattingRule(format)) {
+		var formattedNumber = formatNationalNumber(state, format, {
+			useNationalPrefixFormattingRule: true,
+			getSeparatorAfterNationalPrefix,
+			metadata
+		});
+		if (formattedNumber) return formattedNumber;
+	}
+	return formatNationalNumber(state, format, {
+		useNationalPrefixFormattingRule: false,
+		getSeparatorAfterNationalPrefix,
+		metadata
+	});
+}
+function formatNationalNumber(state, format, _ref3) {
+	var metadata = _ref3.metadata, useNationalPrefixFormattingRule = _ref3.useNationalPrefixFormattingRule, getSeparatorAfterNationalPrefix = _ref3.getSeparatorAfterNationalPrefix;
+	var formattedNationalNumber = formatNationalNumberUsingFormat(state.nationalSignificantNumber, format, {
+		carrierCode: state.carrierCode,
+		useInternationalFormat: state.international,
+		withNationalPrefix: useNationalPrefixFormattingRule,
+		metadata
+	});
+	if (!useNationalPrefixFormattingRule) {
+		if (state.nationalPrefix) formattedNationalNumber = state.nationalPrefix + getSeparatorAfterNationalPrefix(format) + formattedNationalNumber;
+		else if (state.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix) formattedNationalNumber = state.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix + " " + formattedNationalNumber;
+	}
+	if (isValidFormattedNationalNumber(formattedNationalNumber, state)) return formattedNationalNumber;
+}
+function isValidFormattedNationalNumber(formattedNationalNumber, state) {
+	return parseDigits(formattedNationalNumber) === state.getNationalDigits();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/es6/AsYouTypeFormatter.PatternParser.js
+function _typeof$4(o) {
+	"@babel/helpers - typeof";
+	return _typeof$4 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof$4(o);
+}
+function _classCallCheck$4(a, n) {
+	if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties$4(e, r) {
+	for (var t = 0; t < r.length; t++) {
+		var o = r[t];
+		o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey$4(o.key), o);
+	}
+}
+function _createClass$4(e, r, t) {
+	return r && _defineProperties$4(e.prototype, r), t && _defineProperties$4(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+}
+function _toPropertyKey$4(t) {
+	var i = _toPrimitive$4(t, "string");
+	return "symbol" == _typeof$4(i) ? i : i + "";
+}
+function _toPrimitive$4(t, r) {
+	if ("object" != _typeof$4(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof$4(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+var PatternParser = /*#__PURE__*/ function() {
+	function PatternParser() {
+		_classCallCheck$4(this, PatternParser);
+	}
+	return _createClass$4(PatternParser, [
+		{
+			key: "parse",
+			value: function parse(pattern) {
+				this.context = [{
+					or: true,
+					instructions: []
+				}];
+				this.parsePattern(pattern);
+				if (this.context.length !== 1) throw new Error("Non-finalized contexts left when pattern parse ended");
+				var _this$context$ = this.context[0], branches = _this$context$.branches, instructions = _this$context$.instructions;
+				if (branches) return {
+					op: "|",
+					args: branches.concat([expandSingleElementArray(instructions)])
+				};
+				/* istanbul ignore if */
+				if (instructions.length === 0) throw new Error("Pattern is required");
+				if (instructions.length === 1) return instructions[0];
+				return instructions;
+			}
+		},
+		{
+			key: "startContext",
+			value: function startContext(context) {
+				this.context.push(context);
+			}
+		},
+		{
+			key: "endContext",
+			value: function endContext() {
+				this.context.pop();
+			}
+		},
+		{
+			key: "getContext",
+			value: function getContext() {
+				return this.context[this.context.length - 1];
+			}
+		},
+		{
+			key: "parsePattern",
+			value: function parsePattern(pattern) {
+				if (!pattern) throw new Error("Pattern is required");
+				var match = pattern.match(OPERATOR);
+				if (!match) {
+					if (ILLEGAL_CHARACTER_REGEXP.test(pattern)) throw new Error("Illegal characters found in a pattern: ".concat(pattern));
+					this.getContext().instructions = this.getContext().instructions.concat(pattern.split(""));
+					return;
+				}
+				var operator = match[1];
+				var before = pattern.slice(0, match.index);
+				var rightPart = pattern.slice(match.index + operator.length);
+				switch (operator) {
+					case "(?:":
+						if (before) this.parsePattern(before);
+						this.startContext({
+							or: true,
+							instructions: [],
+							branches: []
+						});
+						break;
+					case ")":
+						if (!this.getContext().or) throw new Error("\")\" operator must be preceded by \"(?:\" operator");
+						if (before) this.parsePattern(before);
+						if (this.getContext().instructions.length === 0) throw new Error("No instructions found after \"|\" operator in an \"or\" group");
+						var branches = this.getContext().branches;
+						branches.push(expandSingleElementArray(this.getContext().instructions));
+						this.endContext();
+						this.getContext().instructions.push({
+							op: "|",
+							args: branches
+						});
+						break;
+					case "|":
+						if (!this.getContext().or) throw new Error("\"|\" operator can only be used inside \"or\" groups");
+						if (before) this.parsePattern(before);
+						if (!this.getContext().branches)
+ /* istanbul ignore else */
+						if (this.context.length === 1) this.getContext().branches = [];
+						else throw new Error("\"branches\" not found in an \"or\" group context");
+						this.getContext().branches.push(expandSingleElementArray(this.getContext().instructions));
+						this.getContext().instructions = [];
+						break;
+					case "[":
+						if (before) this.parsePattern(before);
+						this.startContext({ oneOfSet: true });
+						break;
+					case "]":
+						if (!this.getContext().oneOfSet) throw new Error("\"]\" operator must be preceded by \"[\" operator");
+						this.endContext();
+						this.getContext().instructions.push({
+							op: "[]",
+							args: parseOneOfSet(before)
+						});
+						break;
+					/* istanbul ignore next */
+					default: throw new Error("Unknown operator: ".concat(operator));
+				}
+				if (rightPart) this.parsePattern(rightPart);
+			}
+		}
+	]);
+}();
+function parseOneOfSet(pattern) {
+	var values = [];
+	var i = 0;
+	while (i < pattern.length) {
+		if (pattern[i] === "-") {
+			if (i === 0 || i === pattern.length - 1) throw new Error("Couldn't parse a one-of set pattern: ".concat(pattern));
+			var prevValue = pattern[i - 1].charCodeAt(0) + 1;
+			var nextValue = pattern[i + 1].charCodeAt(0) - 1;
+			var value = prevValue;
+			while (value <= nextValue) {
+				values.push(String.fromCharCode(value));
+				value++;
+			}
+		} else values.push(pattern[i]);
+		i++;
+	}
+	return values;
+}
+var ILLEGAL_CHARACTER_REGEXP = /[\(\)\[\]\?\:\|]/;
+var OPERATOR = /* @__PURE__ */ new RegExp("(\\||\\(\\?\\:|\\)|\\[|\\])");
+function expandSingleElementArray(array) {
+	if (array.length === 1) return array[0];
+	return array;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/es6/AsYouTypeFormatter.PatternMatcher.js
+function _createForOfIteratorHelperLoose$1(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$3(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.");
+}
+function _unsupportedIterableToArray$3(r, a) {
+	if (r) {
+		if ("string" == typeof r) return _arrayLikeToArray$3(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$3(r, a) : void 0;
+	}
+}
+function _arrayLikeToArray$3(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;
+}
+function _typeof$3(o) {
+	"@babel/helpers - typeof";
+	return _typeof$3 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof$3(o);
+}
+function _classCallCheck$3(a, n) {
+	if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties$3(e, r) {
+	for (var t = 0; t < r.length; t++) {
+		var o = r[t];
+		o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey$3(o.key), o);
+	}
+}
+function _createClass$3(e, r, t) {
+	return r && _defineProperties$3(e.prototype, r), t && _defineProperties$3(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+}
+function _toPropertyKey$3(t) {
+	var i = _toPrimitive$3(t, "string");
+	return "symbol" == _typeof$3(i) ? i : i + "";
+}
+function _toPrimitive$3(t, r) {
+	if ("object" != _typeof$3(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof$3(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+var PatternMatcher = /*#__PURE__*/ function() {
+	function PatternMatcher(pattern) {
+		_classCallCheck$3(this, PatternMatcher);
+		this.matchTree = new PatternParser().parse(pattern);
+	}
+	return _createClass$3(PatternMatcher, [{
+		key: "match",
+		value: function match(string) {
+			var allowOverflow = (arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}).allowOverflow;
+			if (!string) throw new Error("String is required");
+			var result = _match(string.split(""), this.matchTree, true);
+			if (result && result.match) delete result.matchedChars;
+			if (result && result.overflow) {
+				if (!allowOverflow) return;
+			}
+			return result;
+		}
+	}]);
+}();
+function _match(characters, tree, last) {
+	if (typeof tree === "string") {
+		var characterString = characters.join("");
+		if (tree.indexOf(characterString) === 0) {
+			/* istanbul ignore else */
+			if (characters.length === tree.length) return {
+				match: true,
+				matchedChars: characters
+			};
+			/* istanbul ignore next */
+			return { partialMatch: true };
+		}
+		if (characterString.indexOf(tree) === 0) {
+			if (last) {
+				/* istanbul ignore else */
+				if (characters.length > tree.length) return { overflow: true };
+			}
+			return {
+				match: true,
+				matchedChars: characters.slice(0, tree.length)
+			};
+		}
+		return;
+	}
+	if (Array.isArray(tree)) {
+		var restCharacters = characters.slice();
+		var i = 0;
+		while (i < tree.length) {
+			var subtree = tree[i];
+			var result = _match(restCharacters, subtree, last && i === tree.length - 1);
+			if (!result) return;
+			else if (result.overflow) return result;
+			else if (result.match) {
+				restCharacters = restCharacters.slice(result.matchedChars.length);
+				if (restCharacters.length === 0) if (i === tree.length - 1) return {
+					match: true,
+					matchedChars: characters
+				};
+				else return { partialMatch: true };
+			} else if (result.partialMatch) return { partialMatch: true };
+			else throw new Error("Unsupported match result:\n".concat(JSON.stringify(result, null, 2)));
+			i++;
+		}
+		/* istanbul ignore if */
+		if (last) return { overflow: true };
+		return {
+			match: true,
+			matchedChars: characters.slice(0, characters.length - restCharacters.length)
+		};
+	}
+	switch (tree.op) {
+		case "|":
+			var partialMatch;
+			for (var _iterator = _createForOfIteratorHelperLoose$1(tree.args), _step; !(_step = _iterator()).done;) {
+				var branch = _step.value;
+				var _result = _match(characters, branch, last);
+				if (_result) if (_result.overflow) return _result;
+				else if (_result.match) return {
+					match: true,
+					matchedChars: _result.matchedChars
+				};
+				else if (_result.partialMatch) partialMatch = true;
+				else throw new Error("Unsupported match result:\n".concat(JSON.stringify(_result, null, 2)));
+			}
+			if (partialMatch) return { partialMatch: true };
+			return;
+		case "[]":
+			for (var _iterator2 = _createForOfIteratorHelperLoose$1(tree.args), _step2; !(_step2 = _iterator2()).done;) {
+				var _char = _step2.value;
+				if (characters[0] === _char) {
+					if (characters.length === 1) return {
+						match: true,
+						matchedChars: characters
+					};
+					if (last) return { overflow: true };
+					return {
+						match: true,
+						matchedChars: [_char]
+					};
+				}
+			}
+			return;
+		/* istanbul ignore next */
+		default: throw new Error("Unsupported instruction tree: ".concat(tree));
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/es6/AsYouTypeFormatter.js
+function _typeof$2(o) {
+	"@babel/helpers - typeof";
+	return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof$2(o);
+}
+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$2(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.");
+}
+function _unsupportedIterableToArray$2(r, a) {
+	if (r) {
+		if ("string" == typeof r) return _arrayLikeToArray$2(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$2(r, a) : void 0;
+	}
+}
+function _arrayLikeToArray$2(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;
+}
+function _classCallCheck$2(a, n) {
+	if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties$2(e, r) {
+	for (var t = 0; t < r.length; t++) {
+		var o = r[t];
+		o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey$2(o.key), o);
+	}
+}
+function _createClass$2(e, r, t) {
+	return r && _defineProperties$2(e.prototype, r), t && _defineProperties$2(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+}
+function _toPropertyKey$2(t) {
+	var i = _toPrimitive$2(t, "string");
+	return "symbol" == _typeof$2(i) ? i : i + "";
+}
+function _toPrimitive$2(t, r) {
+	if ("object" != _typeof$2(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof$2(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+var DUMMY_DIGIT = "9";
+var LONGEST_DUMMY_PHONE_NUMBER = repeat(DUMMY_DIGIT, 15);
+var NATIONAL_PREFIX_SEPARATORS_PATTERN = /[- ]/;
+var SUPPORT_LEGACY_FORMATTING_PATTERNS = true;
+var CREATE_CHARACTER_CLASS_PATTERN = SUPPORT_LEGACY_FORMATTING_PATTERNS && function() {
+	return /\[([^\[\]])*\]/g;
+};
+var CREATE_STANDALONE_DIGIT_PATTERN = SUPPORT_LEGACY_FORMATTING_PATTERNS && function() {
+	return /\d(?=[^,}][^,}])/g;
+};
+var NON_ALTERING_FORMAT_REG_EXP = new RegExp("[" + VALID_PUNCTUATION + "]*\\$1[" + VALID_PUNCTUATION + "]*(\\$\\d[" + VALID_PUNCTUATION + "]*)*$");
+var MIN_LEADING_DIGITS_LENGTH = 3;
+var AsYouTypeFormatter = /*#__PURE__*/ function() {
+	function AsYouTypeFormatter(_ref) {
+		_ref.state;
+		var metadata = _ref.metadata;
+		_classCallCheck$2(this, AsYouTypeFormatter);
+		this.metadata = metadata;
+		this.resetFormat();
+	}
+	return _createClass$2(AsYouTypeFormatter, [
+		{
+			key: "resetFormat",
+			value: function resetFormat() {
+				this.chosenFormat = void 0;
+				this.template = void 0;
+				this.nationalNumberTemplate = void 0;
+				this.populatedNationalNumberTemplate = void 0;
+				this.populatedNationalNumberTemplatePosition = -1;
+			}
+		},
+		{
+			key: "reset",
+			value: function reset(numberingPlan, state) {
+				this.resetFormat();
+				if (numberingPlan) {
+					this.isNANP = numberingPlan.callingCode() === "1";
+					this.matchingFormats = numberingPlan.formats();
+					if (state.nationalSignificantNumber) this.narrowDownMatchingFormats(state);
+				} else {
+					this.isNANP = void 0;
+					this.matchingFormats = [];
+				}
+			}
+		},
+		{
+			key: "format",
+			value: function format(nextDigits, state) {
+				var _this = this;
+				if (canFormatCompleteNumber(state.nationalSignificantNumber, state.country, this.metadata)) for (var _iterator = _createForOfIteratorHelperLoose(this.matchingFormats), _step; !(_step = _iterator()).done;) {
+					var _format = _step.value;
+					var formattedCompleteNumber = formatCompleteNumber(state, _format, {
+						metadata: this.metadata,
+						shouldTryNationalPrefixFormattingRule: function shouldTryNationalPrefixFormattingRule(format) {
+							return _this.shouldTryNationalPrefixFormattingRule(format, {
+								international: state.international,
+								nationalPrefix: state.nationalPrefix
+							});
+						},
+						getSeparatorAfterNationalPrefix: function getSeparatorAfterNationalPrefix(format) {
+							return _this.getSeparatorAfterNationalPrefix(format);
+						}
+					});
+					if (formattedCompleteNumber) {
+						this.resetFormat();
+						this.chosenFormat = _format;
+						this.setNationalNumberTemplate(formattedCompleteNumber.replace(/\d/g, "x"), state);
+						this.populatedNationalNumberTemplate = formattedCompleteNumber;
+						this.populatedNationalNumberTemplatePosition = this.template.lastIndexOf("x");
+						return formattedCompleteNumber;
+					}
+				}
+				return this.formatNationalNumberWithNextDigits(nextDigits, state);
+			}
+		},
+		{
+			key: "formatNationalNumberWithNextDigits",
+			value: function formatNationalNumberWithNextDigits(nextDigits, state) {
+				var previouslyChosenFormat = this.chosenFormat;
+				var newlyChosenFormat = this.chooseFormat(state);
+				if (newlyChosenFormat) if (newlyChosenFormat === previouslyChosenFormat) return this.formatNextNationalNumberDigits(nextDigits);
+				else return this.formatNextNationalNumberDigits(state.getNationalDigits());
+			}
+		},
+		{
+			key: "narrowDownMatchingFormats",
+			value: function narrowDownMatchingFormats(_ref2) {
+				var _this2 = this;
+				var nationalSignificantNumber = _ref2.nationalSignificantNumber, nationalPrefix = _ref2.nationalPrefix, international = _ref2.international;
+				var leadingDigits = nationalSignificantNumber;
+				var leadingDigitsPatternIndex = leadingDigits.length - MIN_LEADING_DIGITS_LENGTH;
+				if (leadingDigitsPatternIndex < 0) leadingDigitsPatternIndex = 0;
+				this.matchingFormats = this.matchingFormats.filter(function(format) {
+					return _this2.formatSuits(format, international, nationalPrefix) && _this2.formatMatches(format, leadingDigits, leadingDigitsPatternIndex);
+				});
+				if (this.chosenFormat && this.matchingFormats.indexOf(this.chosenFormat) === -1) this.resetFormat();
+			}
+		},
+		{
+			key: "formatSuits",
+			value: function formatSuits(format, international, nationalPrefix) {
+				if (nationalPrefix && !format.usesNationalPrefix() && !format.nationalPrefixIsOptionalWhenFormattingInNationalFormat()) return false;
+				if (!international && !nationalPrefix && format.nationalPrefixIsMandatoryWhenFormattingInNationalFormat()) return false;
+				return true;
+			}
+		},
+		{
+			key: "formatMatches",
+			value: function formatMatches(format, leadingDigits, leadingDigitsPatternIndex) {
+				var leadingDigitsPatternsCount = format.leadingDigitsPatterns().length;
+				if (leadingDigitsPatternsCount === 0) return true;
+				leadingDigitsPatternIndex = Math.min(leadingDigitsPatternIndex, leadingDigitsPatternsCount - 1);
+				var leadingDigitsPattern = format.leadingDigitsPatterns()[leadingDigitsPatternIndex];
+				if (leadingDigits.length < MIN_LEADING_DIGITS_LENGTH) try {
+					return new PatternMatcher(leadingDigitsPattern).match(leadingDigits, { allowOverflow: true }) !== void 0;
+				} catch (error) 				/* istanbul ignore next */ {
+					console.error(error);
+					return true;
+				}
+				return new RegExp("^(".concat(leadingDigitsPattern, ")")).test(leadingDigits);
+			}
+		},
+		{
+			key: "getFormatFormat",
+			value: function getFormatFormat(format, international) {
+				return international ? format.internationalFormat() : format.format();
+			}
+		},
+		{
+			key: "chooseFormat",
+			value: function chooseFormat(state) {
+				var _this3 = this;
+				var _loop = function _loop() {
+					var format = _step2.value;
+					if (_this3.chosenFormat === format) return 0;
+					/* istanbul ignore if */
+					if (!NON_ALTERING_FORMAT_REG_EXP.test(_this3.getFormatFormat(format, state.international))) return 1;
+					if (!_this3.createTemplateForFormat(format, state)) {
+						_this3.matchingFormats = _this3.matchingFormats.filter(function(_) {
+							return _ !== format;
+						});
+						return 1;
+					}
+					_this3.chosenFormat = format;
+					return 0;
+				}, _ret;
+				/* istanbul ignore next */
+				for (var _iterator2 = _createForOfIteratorHelperLoose(this.matchingFormats.slice()), _step2; !(_step2 = _iterator2()).done;) {
+					_ret = _loop();
+					if (_ret === 0) break;
+					if (_ret === 1) continue;
+				}
+				if (!this.chosenFormat) this.resetFormat();
+				return this.chosenFormat;
+			}
+		},
+		{
+			key: "createTemplateForFormat",
+			value: function createTemplateForFormat(format, state) {
+				/* istanbul ignore if */
+				if (SUPPORT_LEGACY_FORMATTING_PATTERNS && format.pattern().indexOf("|") >= 0) return;
+				var template = this.getTemplateForFormat(format, state);
+				if (template) {
+					this.setNationalNumberTemplate(template, state);
+					return true;
+				}
+			}
+		},
+		{
+			key: "getSeparatorAfterNationalPrefix",
+			value: function getSeparatorAfterNationalPrefix(format) {
+				if (this.isNANP) return " ";
+				if (format && format.nationalPrefixFormattingRule() && NATIONAL_PREFIX_SEPARATORS_PATTERN.test(format.nationalPrefixFormattingRule())) return " ";
+				return "";
+			}
+		},
+		{
+			key: "getInternationalPrefixBeforeCountryCallingCode",
+			value: function getInternationalPrefixBeforeCountryCallingCode(_ref3, options) {
+				var IDDPrefix = _ref3.IDDPrefix, missingPlus = _ref3.missingPlus;
+				if (IDDPrefix) return options && options.spacing === false ? IDDPrefix : IDDPrefix + " ";
+				if (missingPlus) return "";
+				return "+";
+			}
+		},
+		{
+			key: "getTemplate",
+			value: function getTemplate(state) {
+				if (!this.template) return;
+				var index = -1;
+				var i = 0;
+				var internationalPrefix = state.international ? this.getInternationalPrefixBeforeCountryCallingCode(state, { spacing: false }) : "";
+				while (i < internationalPrefix.length + state.getDigitsWithoutInternationalPrefix().length) {
+					index = this.template.indexOf("x", index + 1);
+					i++;
+				}
+				return cutAndStripNonPairedParens(this.template, index + 1);
+			}
+		},
+		{
+			key: "setNationalNumberTemplate",
+			value: function setNationalNumberTemplate(template, state) {
+				this.nationalNumberTemplate = template;
+				this.populatedNationalNumberTemplate = template;
+				this.populatedNationalNumberTemplatePosition = -1;
+				if (state.international) this.template = this.getInternationalPrefixBeforeCountryCallingCode(state).replace(/[\d\+]/g, "x") + repeat("x", state.callingCode.length) + " " + template;
+				else this.template = template;
+			}
+		},
+		{
+			key: "getTemplateForFormat",
+			value: function getTemplateForFormat(format, _ref4) {
+				var nationalSignificantNumber = _ref4.nationalSignificantNumber, international = _ref4.international, nationalPrefix = _ref4.nationalPrefix, prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix = _ref4.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix;
+				var pattern = format.pattern();
+				/* istanbul ignore else */
+				if (SUPPORT_LEGACY_FORMATTING_PATTERNS) pattern = pattern.replace(CREATE_CHARACTER_CLASS_PATTERN(), "\\d").replace(CREATE_STANDALONE_DIGIT_PATTERN(), "\\d");
+				var digits = LONGEST_DUMMY_PHONE_NUMBER.match(pattern)[0];
+				if (nationalSignificantNumber.length > digits.length) return;
+				var strictPattern = new RegExp("^" + pattern + "$");
+				var nationalNumberDummyDigits = nationalSignificantNumber.replace(/\d/g, DUMMY_DIGIT);
+				if (strictPattern.test(nationalNumberDummyDigits)) digits = nationalNumberDummyDigits;
+				var numberFormat = this.getFormatFormat(format, international);
+				var nationalPrefixIncludedInTemplate;
+				if (this.shouldTryNationalPrefixFormattingRule(format, {
+					international,
+					nationalPrefix
+				})) {
+					var numberFormatWithNationalPrefix = numberFormat.replace(FIRST_GROUP_PATTERN, format.nationalPrefixFormattingRule());
+					/* istanbul ignore else */
+					if (parseDigits(format.nationalPrefixFormattingRule()) === (nationalPrefix || "") + parseDigits("$1")) {
+						numberFormat = numberFormatWithNationalPrefix;
+						nationalPrefixIncludedInTemplate = true;
+						if (nationalPrefix) {
+							var i = nationalPrefix.length;
+							while (i > 0) {
+								numberFormat = numberFormat.replace(/\d/, "x");
+								i--;
+							}
+						}
+					}
+				}
+				var template = digits.replace(new RegExp(pattern), numberFormat).replace(new RegExp(DUMMY_DIGIT, "g"), "x");
+				if (!nationalPrefixIncludedInTemplate) {
+					if (prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix) template = repeat("x", prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix.length) + " " + template;
+					else if (nationalPrefix) template = repeat("x", nationalPrefix.length) + this.getSeparatorAfterNationalPrefix(format) + template;
+				}
+				if (international) template = applyInternationalSeparatorStyle(template);
+				return template;
+			}
+		},
+		{
+			key: "formatNextNationalNumberDigits",
+			value: function formatNextNationalNumberDigits(digits) {
+				var result = populateTemplateWithDigits(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition, digits);
+				if (!result) {
+					this.resetFormat();
+					return;
+				}
+				this.populatedNationalNumberTemplate = result[0];
+				this.populatedNationalNumberTemplatePosition = result[1];
+				return cutAndStripNonPairedParens(this.populatedNationalNumberTemplate, this.populatedNationalNumberTemplatePosition + 1);
+			}
+		},
+		{
+			key: "shouldTryNationalPrefixFormattingRule",
+			value: function shouldTryNationalPrefixFormattingRule(format, _ref5) {
+				var international = _ref5.international, nationalPrefix = _ref5.nationalPrefix;
+				if (format.nationalPrefixFormattingRule()) {
+					var usesNationalPrefix = format.usesNationalPrefix();
+					if (usesNationalPrefix && nationalPrefix || !usesNationalPrefix && !international) return true;
+				}
+			}
+		}
+	]);
+}();
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/es6/AsYouTypeParser.js
+function _typeof$1(o) {
+	"@babel/helpers - typeof";
+	return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof$1(o);
+}
+function _slicedToArray$1(r, e) {
+	return _arrayWithHoles$1(r) || _iterableToArrayLimit$1(r, e) || _unsupportedIterableToArray$1(r, e) || _nonIterableRest$1();
+}
+function _nonIterableRest$1() {
+	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray$1(r, a) {
+	if (r) {
+		if ("string" == typeof r) return _arrayLikeToArray$1(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$1(r, a) : void 0;
+	}
+}
+function _arrayLikeToArray$1(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;
+}
+function _iterableToArrayLimit$1(r, l) {
+	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+	if (null != t) {
+		var e, n, i, u, a = [], f = !0, o = !1;
+		try {
+			if (i = (t = t.call(r)).next, 0 === l) {
+				if (Object(t) !== t) return;
+				f = !1;
+			} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+		} catch (r) {
+			o = !0, n = r;
+		} finally {
+			try {
+				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+			} finally {
+				if (o) throw n;
+			}
+		}
+		return a;
+	}
+}
+function _arrayWithHoles$1(r) {
+	if (Array.isArray(r)) return r;
+}
+function _classCallCheck$1(a, n) {
+	if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties$1(e, r) {
+	for (var t = 0; t < r.length; t++) {
+		var o = r[t];
+		o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey$1(o.key), o);
+	}
+}
+function _createClass$1(e, r, t) {
+	return r && _defineProperties$1(e.prototype, r), t && _defineProperties$1(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+}
+function _toPropertyKey$1(t) {
+	var i = _toPrimitive$1(t, "string");
+	return "symbol" == _typeof$1(i) ? i : i + "";
+}
+function _toPrimitive$1(t, r) {
+	if ("object" != _typeof$1(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof$1(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+var VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART = "[" + VALID_PUNCTUATION + VALID_DIGITS + "]+";
+var VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART_PATTERN = new RegExp("^" + VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART + "$", "i");
+var VALID_FORMATTED_PHONE_NUMBER_PART = "(?:[" + PLUS_CHARS + "][" + VALID_PUNCTUATION + VALID_DIGITS + "]*|[" + VALID_PUNCTUATION + VALID_DIGITS + "]+)";
+var AFTER_PHONE_NUMBER_DIGITS_END_PATTERN = new RegExp("[^" + VALID_PUNCTUATION + VALID_DIGITS + "]+.*$");
+var COMPLEX_NATIONAL_PREFIX = /[^\d\[\]]/;
+var AsYouTypeParser = /*#__PURE__*/ function() {
+	function AsYouTypeParser(_ref) {
+		var defaultCountry = _ref.defaultCountry, defaultCallingCode = _ref.defaultCallingCode, metadata = _ref.metadata, onNationalSignificantNumberChange = _ref.onNationalSignificantNumberChange;
+		_classCallCheck$1(this, AsYouTypeParser);
+		this.defaultCountry = defaultCountry;
+		this.defaultCallingCode = defaultCallingCode;
+		this.metadata = metadata;
+		this.onNationalSignificantNumberChange = onNationalSignificantNumberChange;
+	}
+	return _createClass$1(AsYouTypeParser, [
+		{
+			key: "input",
+			value: function input(text, state) {
+				var _extractFormattedDigi2 = _slicedToArray$1(extractFormattedDigitsAndPlus(text), 2), formattedDigits = _extractFormattedDigi2[0], hasPlus = _extractFormattedDigi2[1];
+				var digits = parseDigits(formattedDigits);
+				var justLeadingPlus;
+				if (hasPlus) {
+					if (!state.digits) {
+						state.startInternationalNumber(void 0, void 0);
+						if (!digits) justLeadingPlus = true;
+					}
+				}
+				if (digits) this.inputDigits(digits, state);
+				return {
+					digits,
+					justLeadingPlus
+				};
+			}
+		},
+		{
+			key: "inputDigits",
+			value: function inputDigits(nextDigits, state) {
+				var digits = state.digits;
+				var hasReceivedThreeLeadingDigits = digits.length < 3 && digits.length + nextDigits.length >= 3;
+				state.appendDigits(nextDigits);
+				if (hasReceivedThreeLeadingDigits) this.extractIddPrefix(state);
+				if (this.isWaitingForCountryCallingCode(state)) {
+					if (!this.extractCountryCallingCode(state)) return;
+				} else state.appendNationalSignificantNumberDigits(nextDigits);
+				if (!state.international) {
+					if (!this.hasExtractedNationalSignificantNumber) this.extractNationalSignificantNumber(state.getNationalDigits(), function(stateUpdate) {
+						return state.update(stateUpdate);
+					});
+				}
+			}
+		},
+		{
+			key: "isWaitingForCountryCallingCode",
+			value: function isWaitingForCountryCallingCode(_ref2) {
+				var international = _ref2.international, callingCode = _ref2.callingCode;
+				return international && !callingCode;
+			}
+		},
+		{
+			key: "extractCountryCallingCode",
+			value: function extractCountryCallingCode$1(state) {
+				var _extractCountryCallin = extractCountryCallingCode("+" + state.getDigitsWithoutInternationalPrefix(), state.country, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata), countryCallingCode = _extractCountryCallin.countryCallingCode, number = _extractCountryCallin.number;
+				if (countryCallingCode) {
+					state.setCallingCode(countryCallingCode);
+					state.update({ nationalSignificantNumber: number });
+					return true;
+				}
+			}
+		},
+		{
+			key: "reset",
+			value: function reset(numberingPlan) {
+				if (numberingPlan) {
+					this.hasSelectedNumberingPlan = true;
+					var nationalPrefixForParsing = numberingPlan._nationalPrefixForParsing();
+					this.couldPossiblyExtractAnotherNationalSignificantNumber = nationalPrefixForParsing && COMPLEX_NATIONAL_PREFIX.test(nationalPrefixForParsing);
+				} else {
+					this.hasSelectedNumberingPlan = void 0;
+					this.couldPossiblyExtractAnotherNationalSignificantNumber = void 0;
+				}
+			}
+		},
+		{
+			key: "extractNationalSignificantNumber",
+			value: function extractNationalSignificantNumber(nationalDigits, setState) {
+				if (!this.hasSelectedNumberingPlan) return;
+				var _extractNationalNumbe = extractNationalNumberFromPossiblyIncompleteNumber(nationalDigits, this.metadata), nationalPrefix = _extractNationalNumbe.nationalPrefix, nationalNumber = _extractNationalNumbe.nationalNumber, carrierCode = _extractNationalNumbe.carrierCode;
+				if (nationalNumber === nationalDigits) return;
+				this.onExtractedNationalNumber(nationalPrefix, carrierCode, nationalNumber, nationalDigits, setState);
+				return true;
+			}
+		},
+		{
+			key: "extractAnotherNationalSignificantNumber",
+			value: function extractAnotherNationalSignificantNumber(nationalDigits, prevNationalSignificantNumber, setState) {
+				if (!this.hasExtractedNationalSignificantNumber) return this.extractNationalSignificantNumber(nationalDigits, setState);
+				if (!this.couldPossiblyExtractAnotherNationalSignificantNumber) return;
+				var _extractNationalNumbe2 = extractNationalNumberFromPossiblyIncompleteNumber(nationalDigits, this.metadata), nationalPrefix = _extractNationalNumbe2.nationalPrefix, nationalNumber = _extractNationalNumbe2.nationalNumber, carrierCode = _extractNationalNumbe2.carrierCode;
+				/* istanbul ignore if */
+				if (nationalNumber === prevNationalSignificantNumber) return;
+				this.onExtractedNationalNumber(nationalPrefix, carrierCode, nationalNumber, nationalDigits, setState);
+				return true;
+			}
+		},
+		{
+			key: "onExtractedNationalNumber",
+			value: function onExtractedNationalNumber(nationalPrefix, carrierCode, nationalSignificantNumber, nationalDigits, setState) {
+				var nationalSignificantNumberIsModified = false;
+				var prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix;
+				var nationalSignificantNumberIndex = nationalDigits.lastIndexOf(nationalSignificantNumber);
+				if (nationalSignificantNumberIndex < 0 || nationalSignificantNumberIndex !== nationalDigits.length - nationalSignificantNumber.length) nationalSignificantNumberIsModified = true;
+				else {
+					var prefixBeforeNationalNumber = nationalDigits.slice(0, nationalSignificantNumberIndex);
+					/* istanbul ignore if */
+					if (prefixBeforeNationalNumber) {
+						if (prefixBeforeNationalNumber !== nationalPrefix) prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix = prefixBeforeNationalNumber;
+					}
+				}
+				setState({
+					nationalPrefix,
+					carrierCode,
+					nationalSignificantNumber,
+					nationalSignificantNumberIsModified,
+					prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix
+				});
+				this.hasExtractedNationalSignificantNumber = true;
+				this.onNationalSignificantNumberChange();
+			}
+		},
+		{
+			key: "reExtractNationalSignificantNumber",
+			value: function reExtractNationalSignificantNumber(state) {
+				if (this.extractAnotherNationalSignificantNumber(state.getNationalDigits(), state.nationalSignificantNumber, function(stateUpdate) {
+					return state.update(stateUpdate);
+				})) return true;
+				if (this.extractIddPrefix(state)) {
+					this.extractCallingCodeAndNationalSignificantNumber(state);
+					return true;
+				}
+				if (this.fixMissingPlus(state)) {
+					this.extractCallingCodeAndNationalSignificantNumber(state);
+					return true;
+				}
+			}
+		},
+		{
+			key: "extractIddPrefix",
+			value: function extractIddPrefix(state) {
+				var international = state.international, IDDPrefix = state.IDDPrefix, digits = state.digits;
+				state.nationalSignificantNumber;
+				if (international || IDDPrefix) return;
+				var numberWithoutIDD = stripIddPrefix(digits, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata);
+				if (numberWithoutIDD !== void 0 && numberWithoutIDD !== digits) {
+					state.update({ IDDPrefix: digits.slice(0, digits.length - numberWithoutIDD.length) });
+					this.startInternationalNumber(state, {
+						country: void 0,
+						callingCode: void 0
+					});
+					return true;
+				}
+			}
+		},
+		{
+			key: "fixMissingPlus",
+			value: function fixMissingPlus(state) {
+				if (!state.international) {
+					var newCallingCode = extractCountryCallingCodeFromInternationalNumberWithoutPlusSign(state.digits, state.country, this.defaultCountry, this.defaultCallingCode, this.metadata.metadata).countryCallingCode;
+					if (newCallingCode) {
+						state.update({ missingPlus: true });
+						this.startInternationalNumber(state, {
+							country: state.country,
+							callingCode: newCallingCode
+						});
+						return true;
+					}
+				}
+			}
+		},
+		{
+			key: "startInternationalNumber",
+			value: function startInternationalNumber(state, _ref3) {
+				var country = _ref3.country, callingCode = _ref3.callingCode;
+				state.startInternationalNumber(country, callingCode);
+				if (state.nationalSignificantNumber) {
+					state.resetNationalSignificantNumber();
+					this.onNationalSignificantNumberChange();
+					this.hasExtractedNationalSignificantNumber = void 0;
+				}
+			}
+		},
+		{
+			key: "extractCallingCodeAndNationalSignificantNumber",
+			value: function extractCallingCodeAndNationalSignificantNumber(state) {
+				if (this.extractCountryCallingCode(state)) this.extractNationalSignificantNumber(state.getNationalDigits(), function(stateUpdate) {
+					return state.update(stateUpdate);
+				});
+			}
+		}
+	]);
+}();
+function extractFormattedPhoneNumber(text) {
+	var startsAt = text.search(VALID_FORMATTED_PHONE_NUMBER_PART);
+	if (startsAt < 0) return;
+	text = text.slice(startsAt);
+	var hasPlus;
+	if (text[0] === "+") {
+		hasPlus = true;
+		text = text.slice(1);
+	}
+	text = text.replace(AFTER_PHONE_NUMBER_DIGITS_END_PATTERN, "");
+	if (hasPlus) text = "+" + text;
+	return text;
+}
+/**
+* Extracts formatted phone number digits (and a `+`) from text (if there're any).
+* @param  {string} text
+* @return {any[]}
+*/
+function _extractFormattedDigitsAndPlus(text) {
+	var extractedNumber = extractFormattedPhoneNumber(text) || "";
+	if (extractedNumber[0] === "+") return [extractedNumber.slice(1), true];
+	return [extractedNumber];
+}
+/**
+* Extracts formatted phone number digits (and a `+`) from text (if there're any).
+* @param  {string} text
+* @return {any[]}
+*/
+function extractFormattedDigitsAndPlus(text) {
+	var _extractFormattedDigi4 = _slicedToArray$1(_extractFormattedDigitsAndPlus(text), 2), formattedDigits = _extractFormattedDigi4[0], hasPlus = _extractFormattedDigi4[1];
+	if (!VALID_FORMATTED_PHONE_NUMBER_DIGITS_PART_PATTERN.test(formattedDigits)) formattedDigits = "";
+	return [formattedDigits, hasPlus];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/es6/AsYouType.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+function _slicedToArray(r, e) {
+	return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _nonIterableRest() {
+	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _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;
+	}
+}
+function _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;
+}
+function _iterableToArrayLimit(r, l) {
+	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+	if (null != t) {
+		var e, n, i, u, a = [], f = !0, o = !1;
+		try {
+			if (i = (t = t.call(r)).next, 0 === l) {
+				if (Object(t) !== t) return;
+				f = !1;
+			} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+		} catch (r) {
+			o = !0, n = r;
+		} finally {
+			try {
+				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+			} finally {
+				if (o) throw n;
+			}
+		}
+		return a;
+	}
+}
+function _arrayWithHoles(r) {
+	if (Array.isArray(r)) return r;
+}
+function _classCallCheck(a, n) {
+	if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(e, r) {
+	for (var t = 0; t < r.length; t++) {
+		var o = r[t];
+		o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+	}
+}
+function _createClass(e, r, t) {
+	return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+}
+function _toPropertyKey(t) {
+	var i = _toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+function _toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+var USE_NON_GEOGRAPHIC_COUNTRY_CODE = false;
+var AsYouType$1 = /*#__PURE__*/ function() {
+	/**
+	* @param {(string|object)?} [optionsOrDefaultCountry] - The default country used for parsing non-international phone numbers. Can also be an `options` object.
+	* @param {Object} metadata
+	*/
+	function AsYouType(optionsOrDefaultCountry, metadata) {
+		_classCallCheck(this, AsYouType);
+		this.metadata = new Metadata(metadata);
+		var _this$getCountryAndCa2 = _slicedToArray(this.getCountryAndCallingCode(optionsOrDefaultCountry), 2), defaultCountry = _this$getCountryAndCa2[0], defaultCallingCode = _this$getCountryAndCa2[1];
+		this.defaultCountry = defaultCountry;
+		this.defaultCallingCode = defaultCallingCode;
+		this.reset();
+	}
+	return _createClass(AsYouType, [
+		{
+			key: "getCountryAndCallingCode",
+			value: function getCountryAndCallingCode(optionsOrDefaultCountry) {
+				var defaultCountry;
+				var defaultCallingCode;
+				if (optionsOrDefaultCountry) if (isObject(optionsOrDefaultCountry)) {
+					defaultCountry = optionsOrDefaultCountry.defaultCountry;
+					defaultCallingCode = optionsOrDefaultCountry.defaultCallingCode;
+				} else defaultCountry = optionsOrDefaultCountry;
+				if (defaultCountry && !this.metadata.hasCountry(defaultCountry)) defaultCountry = void 0;
+				if (defaultCallingCode) {
+					/* istanbul ignore if */
+					if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {
+						if (this.metadata.isNonGeographicCallingCode(defaultCallingCode)) defaultCountry = "001";
+					}
+				}
+				return [defaultCountry, defaultCallingCode];
+			}
+		},
+		{
+			key: "input",
+			value: function input(text) {
+				var _this$parser$input = this.parser.input(text, this.state), digits = _this$parser$input.digits;
+				if (_this$parser$input.justLeadingPlus) this.formattedOutput = "+";
+				else if (digits) {
+					this.determineTheCountryIfNeeded();
+					if (this.state.nationalSignificantNumber) this.formatter.narrowDownMatchingFormats(this.state);
+					var formattedNationalNumber;
+					if (this.metadata.hasSelectedNumberingPlan()) formattedNationalNumber = this.formatter.format(digits, this.state);
+					if (formattedNationalNumber === void 0) {
+						if (this.parser.reExtractNationalSignificantNumber(this.state)) {
+							this.determineTheCountryIfNeeded();
+							var nationalDigits = this.state.getNationalDigits();
+							if (nationalDigits) formattedNationalNumber = this.formatter.format(nationalDigits, this.state);
+						}
+					}
+					this.formattedOutput = formattedNationalNumber ? this.getFullNumber(formattedNationalNumber) : this.getNonFormattedNumber();
+				}
+				return this.formattedOutput;
+			}
+		},
+		{
+			key: "reset",
+			value: function reset() {
+				var _this = this;
+				this.state = new AsYouTypeState({
+					onCountryChange: function onCountryChange(country) {
+						_this.country = country;
+					},
+					onCallingCodeChange: function onCallingCodeChange(callingCode, country) {
+						_this.metadata.selectNumberingPlan(country, callingCode);
+						_this.formatter.reset(_this.metadata.numberingPlan, _this.state);
+						_this.parser.reset(_this.metadata.numberingPlan);
+					}
+				});
+				this.formatter = new AsYouTypeFormatter({
+					state: this.state,
+					metadata: this.metadata
+				});
+				this.parser = new AsYouTypeParser({
+					defaultCountry: this.defaultCountry,
+					defaultCallingCode: this.defaultCallingCode,
+					metadata: this.metadata,
+					state: this.state,
+					onNationalSignificantNumberChange: function onNationalSignificantNumberChange() {
+						_this.determineTheCountryIfNeeded();
+						_this.formatter.reset(_this.metadata.numberingPlan, _this.state);
+					}
+				});
+				this.state.reset({
+					country: this.defaultCountry,
+					callingCode: this.defaultCallingCode
+				});
+				this.formattedOutput = "";
+				return this;
+			}
+		},
+		{
+			key: "isInternational",
+			value: function isInternational() {
+				return this.state.international;
+			}
+		},
+		{
+			key: "getCallingCode",
+			value: function getCallingCode() {
+				if (this.isInternational()) return this.state.callingCode;
+			}
+		},
+		{
+			key: "getCountryCallingCode",
+			value: function getCountryCallingCode() {
+				return this.getCallingCode();
+			}
+		},
+		{
+			key: "getCountry",
+			value: function getCountry() {
+				if (this.state.digits) return this._getCountry();
+			}
+		},
+		{
+			key: "_getCountry",
+			value: function _getCountry() {
+				var country = this.state.country;
+				/* istanbul ignore if */
+				if (USE_NON_GEOGRAPHIC_COUNTRY_CODE) {
+					if (country === "001") return;
+				}
+				return country;
+			}
+		},
+		{
+			key: "determineTheCountryIfNeeded",
+			value: function determineTheCountryIfNeeded() {
+				if (!this.state.country || this.isCountryCallingCodeAmbiguous()) this.determineTheCountry();
+			}
+		},
+		{
+			key: "getFullNumber",
+			value: function getFullNumber(formattedNationalNumber) {
+				var _this2 = this;
+				if (this.isInternational()) {
+					var prefix = function prefix(text) {
+						return _this2.formatter.getInternationalPrefixBeforeCountryCallingCode(_this2.state, { spacing: text ? true : false }) + text;
+					};
+					var callingCode = this.state.callingCode;
+					if (!callingCode) return prefix("".concat(this.state.getDigitsWithoutInternationalPrefix()));
+					if (!formattedNationalNumber) return prefix(callingCode);
+					return prefix("".concat(callingCode, " ").concat(formattedNationalNumber));
+				}
+				return formattedNationalNumber;
+			}
+		},
+		{
+			key: "getNonFormattedNationalNumberWithPrefix",
+			value: function getNonFormattedNationalNumberWithPrefix() {
+				var _this$state = this.state, nationalSignificantNumber = _this$state.nationalSignificantNumber, prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix = _this$state.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix, nationalPrefix = _this$state.nationalPrefix;
+				var number = nationalSignificantNumber;
+				var prefix = prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix || nationalPrefix;
+				if (prefix) number = prefix + number;
+				return number;
+			}
+		},
+		{
+			key: "getNonFormattedNumber",
+			value: function getNonFormattedNumber() {
+				var nationalSignificantNumberIsModified = this.state.nationalSignificantNumberIsModified;
+				return this.getFullNumber(nationalSignificantNumberIsModified ? this.state.getNationalDigits() : this.getNonFormattedNationalNumberWithPrefix());
+			}
+		},
+		{
+			key: "getNonFormattedTemplate",
+			value: function getNonFormattedTemplate() {
+				var number = this.getNonFormattedNumber();
+				if (number) return number.replace(/[\+\d]/g, "x");
+			}
+		},
+		{
+			key: "isCountryCallingCodeAmbiguous",
+			value: function isCountryCallingCodeAmbiguous() {
+				var callingCode = this.state.callingCode;
+				var countryCodes = this.metadata.getCountryCodesForCallingCode(callingCode);
+				return countryCodes && countryCodes.length > 1;
+			}
+		},
+		{
+			key: "determineTheCountry",
+			value: function determineTheCountry() {
+				this.state.setCountry(getCountryByCallingCode(this.isInternational() ? this.state.callingCode : this.defaultCallingCode, {
+					nationalNumber: this.state.nationalSignificantNumber,
+					metadata: this.metadata
+				}));
+			}
+		},
+		{
+			key: "getNumberValue",
+			value: function getNumberValue() {
+				var _this$state2 = this.state, digits = _this$state2.digits, callingCode = _this$state2.callingCode, country = _this$state2.country, nationalSignificantNumber = _this$state2.nationalSignificantNumber;
+				if (!digits) return;
+				if (this.isInternational()) if (callingCode) return "+" + callingCode + nationalSignificantNumber;
+				else return "+" + digits;
+				else if (country || callingCode) return "+" + (country ? this.metadata.countryCallingCode() : callingCode) + nationalSignificantNumber;
+			}
+		},
+		{
+			key: "getNumber",
+			value: function getNumber() {
+				var _this$state3 = this.state, nationalSignificantNumber = _this$state3.nationalSignificantNumber, carrierCode = _this$state3.carrierCode, callingCode = _this$state3.callingCode;
+				var country = this._getCountry();
+				if (!nationalSignificantNumber) return;
+				if (!country && !callingCode) return;
+				if (country) {
+					if (country === this.defaultCountry) {
+						var metadata = new Metadata(this.metadata.metadata);
+						metadata.selectNumberingPlan(country);
+						var _callingCode = metadata.numberingPlan.callingCode();
+						var ambiguousCountries = this.metadata.getCountryCodesForCallingCode(_callingCode);
+						if (ambiguousCountries.length > 1) {
+							var exactCountry = getCountryByNationalNumber(nationalSignificantNumber, {
+								countries: ambiguousCountries,
+								metadata: this.metadata.metadata
+							});
+							if (exactCountry) country = exactCountry;
+						}
+					}
+				}
+				var phoneNumber = new PhoneNumber(country || callingCode, nationalSignificantNumber, this.metadata.metadata);
+				if (carrierCode) phoneNumber.carrierCode = carrierCode;
+				return phoneNumber;
+			}
+		},
+		{
+			key: "isPossible",
+			value: function isPossible() {
+				var phoneNumber = this.getNumber();
+				if (!phoneNumber) return false;
+				return phoneNumber.isPossible();
+			}
+		},
+		{
+			key: "isValid",
+			value: function isValid() {
+				var phoneNumber = this.getNumber();
+				if (!phoneNumber) return false;
+				return phoneNumber.isValid();
+			}
+		},
+		{
+			key: "getNationalNumber",
+			value: function getNationalNumber() {
+				return this.state.nationalSignificantNumber;
+			}
+		},
+		{
+			key: "getChars",
+			value: function getChars() {
+				return (this.state.international ? "+" : "") + this.state.digits;
+			}
+		},
+		{
+			key: "getTemplate",
+			value: function getTemplate() {
+				return this.formatter.getTemplate(this.state) || this.getNonFormattedTemplate() || "";
+			}
+		}
+	]);
+}();
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/es6/getExampleNumber.js
+function getExampleNumber$1(country, examples, metadata) {
+	if (examples[country]) return new PhoneNumber(country, examples[country], metadata);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/min/exports/AsYouType.js
+function AsYouType(country) {
+	return AsYouType$1.call(this, country, metadata_min_json_default);
+}
+AsYouType.prototype = Object.create(AsYouType$1.prototype, {});
+AsYouType.prototype.constructor = AsYouType;
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/min/exports/getCountryCallingCode.js
+function getCountryCallingCode() {
+	return withMetadataArgument(getCountryCallingCode$1, arguments);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/min/exports/getExampleNumber.js
+function getExampleNumber() {
+	return withMetadataArgument(getExampleNumber$1, arguments);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/libphonenumber-js@1.12.31/node_modules/libphonenumber-js/examples.mobile.json.js
+var examples_mobile_json_default = {
+	"AC": "40123",
+	"AD": "312345",
+	"AE": "501234567",
+	"AF": "701234567",
+	"AG": "2684641234",
+	"AI": "2642351234",
+	"AL": "672123456",
+	"AM": "77123456",
+	"AO": "923123456",
+	"AR": "91123456789",
+	"AS": "6847331234",
+	"AT": "664123456",
+	"AU": "412345678",
+	"AW": "5601234",
+	"AX": "412345678",
+	"AZ": "401234567",
+	"BA": "61123456",
+	"BB": "2462501234",
+	"BD": "1812345678",
+	"BE": "470123456",
+	"BF": "70123456",
+	"BG": "43012345",
+	"BH": "36001234",
+	"BI": "79561234",
+	"BJ": "0195123456",
+	"BL": "690001234",
+	"BM": "4413701234",
+	"BN": "7123456",
+	"BO": "71234567",
+	"BQ": "3181234",
+	"BR": "11961234567",
+	"BS": "2423591234",
+	"BT": "17123456",
+	"BW": "71123456",
+	"BY": "294911911",
+	"BZ": "6221234",
+	"CA": "5062345678",
+	"CC": "412345678",
+	"CD": "991234567",
+	"CF": "70012345",
+	"CG": "061234567",
+	"CH": "781234567",
+	"CI": "0123456789",
+	"CK": "71234",
+	"CL": "221234567",
+	"CM": "671234567",
+	"CN": "13123456789",
+	"CO": "3211234567",
+	"CR": "83123456",
+	"CU": "51234567",
+	"CV": "9911234",
+	"CW": "95181234",
+	"CX": "412345678",
+	"CY": "96123456",
+	"CZ": "601123456",
+	"DE": "15123456789",
+	"DJ": "77831001",
+	"DK": "34412345",
+	"DM": "7672251234",
+	"DO": "8092345678",
+	"DZ": "551234567",
+	"EC": "991234567",
+	"EE": "51234567",
+	"EG": "1001234567",
+	"EH": "650123456",
+	"ER": "7123456",
+	"ES": "612345678",
+	"ET": "911234567",
+	"FI": "412345678",
+	"FJ": "7012345",
+	"FK": "51234",
+	"FM": "3501234",
+	"FO": "211234",
+	"FR": "612345678",
+	"GA": "06031234",
+	"GB": "7400123456",
+	"GD": "4734031234",
+	"GE": "555123456",
+	"GF": "694201234",
+	"GG": "7781123456",
+	"GH": "231234567",
+	"GI": "57123456",
+	"GL": "221234",
+	"GM": "3012345",
+	"GN": "601123456",
+	"GP": "690001234",
+	"GQ": "222123456",
+	"GR": "6912345678",
+	"GT": "51234567",
+	"GU": "6713001234",
+	"GW": "955012345",
+	"GY": "6091234",
+	"HK": "51234567",
+	"HN": "91234567",
+	"HR": "921234567",
+	"HT": "34101234",
+	"HU": "201234567",
+	"ID": "812345678",
+	"IE": "850123456",
+	"IL": "502345678",
+	"IM": "7924123456",
+	"IN": "8123456789",
+	"IO": "3801234",
+	"IQ": "7912345678",
+	"IR": "9123456789",
+	"IS": "6111234",
+	"IT": "3123456789",
+	"JE": "7797712345",
+	"JM": "8762101234",
+	"JO": "790123456",
+	"JP": "9012345678",
+	"KE": "712123456",
+	"KG": "700123456",
+	"KH": "91234567",
+	"KI": "72001234",
+	"KM": "3212345",
+	"KN": "8697652917",
+	"KP": "1921234567",
+	"KR": "1020000000",
+	"KW": "50012345",
+	"KY": "3453231234",
+	"KZ": "7710009998",
+	"LA": "2023123456",
+	"LB": "71123456",
+	"LC": "7582845678",
+	"LI": "660234567",
+	"LK": "712345678",
+	"LR": "770123456",
+	"LS": "50123456",
+	"LT": "61234567",
+	"LU": "628123456",
+	"LV": "21234567",
+	"LY": "912345678",
+	"MA": "650123456",
+	"MC": "612345678",
+	"MD": "62112345",
+	"ME": "60123456",
+	"MF": "690001234",
+	"MG": "321234567",
+	"MH": "2351234",
+	"MK": "72345678",
+	"ML": "65012345",
+	"MM": "92123456",
+	"MN": "88123456",
+	"MO": "66123456",
+	"MP": "6702345678",
+	"MQ": "696201234",
+	"MR": "22123456",
+	"MS": "6644923456",
+	"MT": "96961234",
+	"MU": "52512345",
+	"MV": "7712345",
+	"MW": "991234567",
+	"MX": "2221234567",
+	"MY": "123456789",
+	"MZ": "821234567",
+	"NA": "811234567",
+	"NC": "751234",
+	"NE": "93123456",
+	"NF": "381234",
+	"NG": "8021234567",
+	"NI": "81234567",
+	"NL": "612345678",
+	"NO": "40612345",
+	"NP": "9841234567",
+	"NR": "5551234",
+	"NU": "8884012",
+	"NZ": "211234567",
+	"OM": "92123456",
+	"PA": "61234567",
+	"PE": "912345678",
+	"PF": "87123456",
+	"PG": "70123456",
+	"PH": "9051234567",
+	"PK": "3012345678",
+	"PL": "512345678",
+	"PM": "551234",
+	"PR": "7872345678",
+	"PS": "599123456",
+	"PT": "912345678",
+	"PW": "6201234",
+	"PY": "961456789",
+	"QA": "33123456",
+	"RE": "692123456",
+	"RO": "712034567",
+	"RS": "601234567",
+	"RU": "9123456789",
+	"RW": "720123456",
+	"SA": "512345678",
+	"SB": "7421234",
+	"SC": "2510123",
+	"SD": "911231234",
+	"SE": "701234567",
+	"SG": "81234567",
+	"SH": "51234",
+	"SI": "31234567",
+	"SJ": "41234567",
+	"SK": "912123456",
+	"SL": "25123456",
+	"SM": "66661212",
+	"SN": "701234567",
+	"SO": "71123456",
+	"SR": "7412345",
+	"SS": "977123456",
+	"ST": "9812345",
+	"SV": "70123456",
+	"SX": "7215205678",
+	"SY": "944567890",
+	"SZ": "76123456",
+	"TA": "8999",
+	"TC": "6492311234",
+	"TD": "63012345",
+	"TG": "90112345",
+	"TH": "812345678",
+	"TJ": "917123456",
+	"TK": "7290",
+	"TL": "77212345",
+	"TM": "66123456",
+	"TN": "20123456",
+	"TO": "7715123",
+	"TR": "5012345678",
+	"TT": "8682911234",
+	"TV": "901234",
+	"TW": "912345678",
+	"TZ": "621234567",
+	"UA": "501234567",
+	"UG": "712345678",
+	"US": "2015550123",
+	"UY": "94231234",
+	"UZ": "912345678",
+	"VA": "3123456789",
+	"VC": "7844301234",
+	"VE": "4121234567",
+	"VG": "2843001234",
+	"VI": "3406421234",
+	"VN": "912345678",
+	"VU": "5912345",
+	"WF": "821234",
+	"WS": "7212345",
+	"XK": "43201234",
+	"YE": "712345678",
+	"YT": "639012345",
+	"ZA": "711234567",
+	"ZM": "955123456",
+	"ZW": "712345678"
+};
+//#endregion
+//#region ../infra/src/providers/browser/PhoneFormattingProvider.ts
+function stripTrunkPrefix(formatted, nationalNumber) {
+	const formattedDigits = formatted.replace(/\D/g, "");
+	if (formattedDigits === nationalNumber) return formatted;
+	if (!formattedDigits.endsWith(nationalNumber)) return null;
+	const trunkLen = formattedDigits.length - nationalNumber.length;
+	if (trunkLen <= 0) return formatted;
+	const bare = formatted.replace(/[()]/g, "");
+	let digitsSeen = 0;
+	for (let i = 0; i < bare.length; i++) if (/\d/.test(bare[i])) {
+		digitsSeen++;
+		if (digitsSeen === trunkLen) return bare.slice(i + 1).replace(/^\D+/, "");
+	}
+	return formatted;
+}
+var PhoneFormattingProvider = class {
+	getCallingCode(country) {
+		try {
+			return `+${getCountryCallingCode(country)}`;
+		} catch {
+			return "";
+		}
+	}
+	formatAsYouType(nationalDigits, country) {
+		const callingCode = this.getCallingCode(country);
+		return new AsYouType(country).input(`${callingCode}${nationalDigits}`).replace(callingCode, "").trimStart();
+	}
+	formatExampleNumber(country) {
+		const example = getExampleNumber(country, examples_mobile_json_default);
+		if (!example) return "";
+		return stripTrunkPrefix(example.formatNational(), example.nationalNumber) || this.formatAsYouType(example.nationalNumber, country);
+	}
+	parse(phone) {
+		const parsed = parsePhoneNumber$1(phone);
+		if (!parsed?.isValid() || !parsed.country) return null;
+		return {
+			country: parsed.country,
+			national: new AsYouType(parsed.country).input(parsed.nationalNumber)
+		};
+	}
+};
+//#endregion
+//#region src/modules/phone-number/phoneNumber.ts
+const formatting = new PhoneFormattingProvider();
+const validation = new PhoneValidationProvider();
+/** Returns `+52` for `MX`, or an empty string for a country with no phone metadata. */
+function getCallingCode(country) {
+	return formatting.getCallingCode(country);
+}
+/** Formats national digits while the user types them, without the calling code. */
+function formatPhoneAsYouType(nationalDigits, country) {
+	return formatting.formatAsYouType(nationalDigits, country);
+}
+/** Returns an example mobile number in national format, without a trunk prefix. */
+function formatExamplePhoneNumber(country) {
+	return formatting.formatExampleNumber(country);
+}
+/**
+* Finds the country of a valid international number (`+12025550123`) and
+* formats its national part. Returns `null` when the number is not valid.
+*/
+function parsePhoneNumber(phone) {
+	return formatting.parse(phone);
+}
+/** Checks a full international number against the rules of `country`. */
+function isValidPhoneNumber(phone, country) {
+	return validation.isValid(phone, country);
+}
+//#endregion
+export { formatExamplePhoneNumber, formatPhoneAsYouType, getCallingCode, isValidPhoneNumber, parsePhoneNumber };