1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
| "use strict";
|
| Object.defineProperty(exports, "__esModule", {
| value: true
| });
| exports.DIGITS = void 0;
| exports["default"] = parseDigits;
| exports.parseDigit = parseDigit;
|
| function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } 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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
| function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
| // These mappings map a character (key) to a specific digit that should
| // replace it for normalization purposes. Non-European digits that
| // may be used in phone numbers are mapped to a European equivalent.
| //
| // E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.
| //
| var DIGITS = {
| '0': '0',
| '1': '1',
| '2': '2',
| '3': '3',
| '4': '4',
| '5': '5',
| '6': '6',
| '7': '7',
| '8': '8',
| '9': '9',
| "\uFF10": '0',
| // Fullwidth digit 0
| "\uFF11": '1',
| // Fullwidth digit 1
| "\uFF12": '2',
| // Fullwidth digit 2
| "\uFF13": '3',
| // Fullwidth digit 3
| "\uFF14": '4',
| // Fullwidth digit 4
| "\uFF15": '5',
| // Fullwidth digit 5
| "\uFF16": '6',
| // Fullwidth digit 6
| "\uFF17": '7',
| // Fullwidth digit 7
| "\uFF18": '8',
| // Fullwidth digit 8
| "\uFF19": '9',
| // Fullwidth digit 9
| "\u0660": '0',
| // Arabic-indic digit 0
| "\u0661": '1',
| // Arabic-indic digit 1
| "\u0662": '2',
| // Arabic-indic digit 2
| "\u0663": '3',
| // Arabic-indic digit 3
| "\u0664": '4',
| // Arabic-indic digit 4
| "\u0665": '5',
| // Arabic-indic digit 5
| "\u0666": '6',
| // Arabic-indic digit 6
| "\u0667": '7',
| // Arabic-indic digit 7
| "\u0668": '8',
| // Arabic-indic digit 8
| "\u0669": '9',
| // Arabic-indic digit 9
| "\u06F0": '0',
| // Eastern-Arabic digit 0
| "\u06F1": '1',
| // Eastern-Arabic digit 1
| "\u06F2": '2',
| // Eastern-Arabic digit 2
| "\u06F3": '3',
| // Eastern-Arabic digit 3
| "\u06F4": '4',
| // Eastern-Arabic digit 4
| "\u06F5": '5',
| // Eastern-Arabic digit 5
| "\u06F6": '6',
| // Eastern-Arabic digit 6
| "\u06F7": '7',
| // Eastern-Arabic digit 7
| "\u06F8": '8',
| // Eastern-Arabic digit 8
| "\u06F9": '9' // Eastern-Arabic digit 9
|
| };
| exports.DIGITS = DIGITS;
|
| function parseDigit(character) {
| return DIGITS[character];
| }
| /**
| * Parses phone number digits from a string.
| * Drops all punctuation leaving only digits.
| * Also converts wide-ascii and arabic-indic numerals to conventional numerals.
| * E.g. in Iraq they don't write `+442323234` but rather `+٤٤٢٣٢٣٢٣٤`.
| * @param {string} string
| * @return {string}
| * @example
| * ```js
| * parseDigits('8 (800) 555')
| * // Outputs '8800555'.
| * ```
| */
|
|
| function parseDigits(string) {
| var result = ''; // Using `.split('')` here instead of normal `for ... of`
| // because the importing application doesn't neccessarily include an ES6 polyfill.
| // The `.split('')` approach discards "exotic" UTF-8 characters
| // (the ones consisting of four bytes) but digits
| // (including non-European ones) don't fall into that range
| // so such "exotic" characters would be discarded anyway.
|
| for (var _iterator = _createForOfIteratorHelperLoose(string.split('')), _step; !(_step = _iterator()).done;) {
| var character = _step.value;
| var digit = parseDigit(character);
|
| if (digit) {
| result += digit;
| }
| }
|
| return result;
| }
| //# sourceMappingURL=parseDigits.js.map
|
|
