https://0hh.ru/assets/js/imask.js

1(function (global, factory) {
2	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
3	typeof define === 'function' && define.amd ? define(['exports'], factory) :
4	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.IMask = {}));
5})(this, (function (exports) { 'use strict';
6
7	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
8
9	var check = function (it) {
10	  return it && it.Math == Math && it;
11	}; // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
12
13
14	var global$p = // eslint-disable-next-line es/no-global-this -- safe
15	check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) || // eslint-disable-next-line no-restricted-globals -- safe
16	check(typeof self == 'object' && self) || check(typeof commonjsGlobal == 'object' && commonjsGlobal) || // eslint-disable-next-line no-new-func -- fallback
17	function () {
18	  return this;
19	}() || Function('return this')();
20
21	var objectGetOwnPropertyDescriptor = {};
22
23	var fails$8 = function (exec) {
24	  try {
25	    return !!exec();
26	  } catch (error) {
27	    return true;
28	  }
29	};
30
31	var fails$7 = fails$8; // Detect IE8's incomplete defineProperty implementation
32
33
34	var descriptors = !fails$7(function () {
35	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
36	  return Object.defineProperty({}, 1, {
37	    get: function () {
38	      return 7;
39	    }
40	  })[1] != 7;
41	});
42
43	var fails$6 = fails$8;
44
45	var functionBindNative = !fails$6(function () {
46	  var test = function () {
47	    /* empty */
48	  }.bind(); // eslint-disable-next-line no-prototype-builtins -- safe
49
50
51	  return typeof test != 'function' || test.hasOwnProperty('prototype');
52	});
53
54	var NATIVE_BIND$1 = functionBindNative;
55
56	var call$5 = Function.prototype.call;
57	var functionCall = NATIVE_BIND$1 ? call$5.bind(call$5) : function () {
58	  return call$5.apply(call$5, arguments);
59	};
60
61	var objectPropertyIsEnumerable = {};
62
63	var $propertyIsEnumerable = {}.propertyIsEnumerable; // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
64
65	var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; // Nashorn ~ JDK8 bug
66
67	var NASHORN_BUG = getOwnPropertyDescriptor$1 && !$propertyIsEnumerable.call({
68	  1: 2
69	}, 1); // `Object.prototype.propertyIsEnumerable` method implementation
70	// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
71
72	objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
73	  var descriptor = getOwnPropertyDescriptor$1(this, V);
74	  return !!descriptor && descriptor.enumerable;
75	} : $propertyIsEnumerable;
76
77	var createPropertyDescriptor$2 = function (bitmap, value) {
78	  return {
79	    enumerable: !(bitmap & 1),
80	    configurable: !(bitmap & 2),
81	    writable: !(bitmap & 4),
82	    value: value
83	  };
84	};
85
86	var NATIVE_BIND = functionBindNative;
87
88	var FunctionPrototype$1 = Function.prototype;
89	var bind = FunctionPrototype$1.bind;
90	var call$4 = FunctionPrototype$1.call;
91	var uncurryThis$b = NATIVE_BIND && bind.bind(call$4, call$4);
92	var functionUncurryThis = NATIVE_BIND ? function (fn) {
93	  return fn && uncurryThis$b(fn);
94	} : function (fn) {
95	  return fn && function () {
96	    return call$4.apply(fn, arguments);
97	  };
98	};
99
100	var uncurryThis$a = functionUncurryThis;
101
102	var toString$4 = uncurryThis$a({}.toString);
103	var stringSlice$1 = uncurryThis$a(''.slice);
104
105	var classofRaw$1 = function (it) {
106	  return stringSlice$1(toString$4(it), 8, -1);
107	};
108
109	var global$o = global$p;
110
111	var uncurryThis$9 = functionUncurryThis;
112
113	var fails$5 = fails$8;
114
115	var classof$2 = classofRaw$1;
116
117	var Object$4 = global$o.Object;
118	var split = uncurryThis$9(''.split); // fallback for non-array-like ES3 and non-enumerable old V8 strings
119
120	var indexedObject = fails$5(function () {
121	  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
122	  // eslint-disable-next-line no-prototype-builtins -- safe
123	  return !Object$4('z').propertyIsEnumerable(0);
124	}) ? function (it) {
125	  return classof$2(it) == 'String' ? split(it, '') : Object$4(it);
126	} : Object$4;

127
128	var global$n = global$p;
129
130	var TypeError$7 = global$n.TypeError; // `RequireObjectCoercible` abstract operation
131	// https://tc39.es/ecma262/#sec-requireobjectcoercible
132
133	var requireObjectCoercible$4 = function (it) {
134	  if (it == undefined) throw TypeError$7("Can't call method on " + it);
135	  return it;
136	};
137
138	// toObject with fallback for non-array-like ES3 strings
139	var IndexedObject$1 = indexedObject;
140
141	var requireObjectCoercible$3 = requireObjectCoercible$4;
142
143	var toIndexedObject$3 = function (it) {
144	  return IndexedObject$1(requireObjectCoercible$3(it));
145	};
146
147	// `IsCallable` abstract operation
148	// https://tc39.es/ecma262/#sec-iscallable
149	var isCallable$a = function (argument) {
150	  return typeof argument == 'function';
151	};
152
153	var isCallable$9 = isCallable$a;
154
155	var isObject$5 = function (it) {
156	  return typeof it == 'object' ? it !== null : isCallable$9(it);
157	};
158
159	var global$m = global$p;
160
161	var isCallable$8 = isCallable$a;
162
163	var aFunction = function (argument) {
164	  return isCallable$8(argument) ? argument : undefined;
165	};
166
167	var getBuiltIn$3 = function (namespace, method) {
168	  return arguments.length < 2 ? aFunction(global$m[namespace]) : global$m[namespace] && global$m[namespace][method];
169	};
170
171	var uncurryThis$8 = functionUncurryThis;
172
173	var objectIsPrototypeOf = uncurryThis$8({}.isPrototypeOf);
174
175	var getBuiltIn$2 = getBuiltIn$3;
176
177	var engineUserAgent = getBuiltIn$2('navigator', 'userAgent') || '';
178
179	var global$l = global$p;
180
181	var userAgent$1 = engineUserAgent;
182
183	var process = global$l.process;
184	var Deno = global$l.Deno;
185	var versions = process && process.versions || Deno && Deno.version;
186	var v8 = versions && versions.v8;
187	var match, version;
188
189	if (v8) {
190	  match = v8.split('.'); // in old Chrome, versions of V8 isn't V8 = Chrome / 10
191	  // but their correct versions are not interesting for us
192
193	  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
194	} // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
195	// so check `userAgent` even if `.v8` exists, but 0
196
197
198	if (!version && userAgent$1) {
199	  match = userAgent$1.match(/Edge\/(\d+)/);
200
201	  if (!match || match[1] >= 74) {
202	    match = userAgent$1.match(/Chrome\/(\d+)/);
203	    if (match) version = +match[1];
204	  }
205	}
206
207	var engineV8Version = version;
208
209	/* eslint-disable es/no-symbol -- required for testing */
210
211	var V8_VERSION = engineV8Version;
212
213	var fails$4 = fails$8; // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
214
215
216	var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$4(function () {
217	  var symbol = Symbol(); // Chrome 38 Symbol has incorrect toString conversion
218	  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
219
220	  return !String(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
221	  !Symbol.sham && V8_VERSION && V8_VERSION < 41;
222	});
223
224	/* eslint-disable es/no-symbol -- required for testing */
225
226	var NATIVE_SYMBOL$1 = nativeSymbol;
227
228	var useSymbolAsUid = NATIVE_SYMBOL$1 && !Symbol.sham && typeof Symbol.iterator == 'symbol';
229
230	var global$k = global$p;
231
232	var getBuiltIn$1 = getBuiltIn$3;
233
234	var isCallable$7 = isCallable$a;
235
236	var isPrototypeOf = objectIsPrototypeOf;
237
238	var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
239
240	var Object$3 = global$k.Object;
241	var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
242	  return typeof it == 'symbol';
243	} : function (it) {
244	  var $Symbol = getBuiltIn$1('Symbol');
245	  return isCallable$7($Symbol) && isPrototypeOf($Symbol.prototype, Object$3(it));
246	};
247
248	var global$j = global$p;
249
250	var String$3 = global$j.String;
251
252	var tryToString$1 = function (argument) {
253	  try {
254	    return String$3(argument);
255	  } catch (error) {
256	    return 'Object';
257	  }
258	};
259
260	var global$i = global$p;
261
262	var isCallable$6 = isCallable$a;
263
264	var tryToString = tryToString$1;
265
266	var TypeError$6 = global$i.TypeError; // `Assert: IsCallable(argument) is true`
267
268	var aCallable$1 = function (argument) {
269	  if (isCallable$6(argument)) return argument;
270	  throw TypeError$6(tryToString(argument) + ' is not a function');
271	};
272
273	var aCallable = aCallable$1; // `GetMethod` abstract operation
274	// https://tc39.es/ecma262/#sec-getmethod
275
276
277	var getMethod$1 = function (V, P) {
278	  var func = V[P];
279	  return func == null ? undefined : aCallable(func);
280	};
281
282	var global$h = global$p;
283
284	var call$3 = functionCall;
285
286	var isCallable$5 = isCallable$a;
287
288	var isObject$4 = isObject$5;
289
290	var TypeError$5 = global$h.TypeError; // `OrdinaryToPrimitive` abstract operation
291	// https://tc39.es/ecma262/#sec-ordinarytoprimitive
292
293	var ordinaryToPrimitive$1 = function (input, pref) {
294	  var fn, val;
295	  if (pref === 'string' && isCallable$5(fn = input.toString) && !isObject$4(val = call$3(fn, input))) return val;
296	  if (isCallable$5(fn = input.valueOf) && !isObject$4(val = call$3(fn, input))) return val;
297	  if (pref !== 'string' && isCallable$5(fn = input.toString) && !isObject$4(val = call$3(fn, input))) return val;
298	  throw TypeError$5("Can't convert object to primitive value");
299	};
300
301	var shared$3 = {exports: {}};
302
303	var global$g = global$p; // eslint-disable-next-line es/no-object-defineproperty -- safe
304
305
306	var defineProperty$1 = Object.defineProperty;
307
308	var setGlobal$3 = function (key, value) {
309	  try {
310	    defineProperty$1(global$g, key, {
311	      value: value,
312	      configurable: true,
313	      writable: true
314	    });
315	  } catch (error) {
316	    global$g[key] = value;
317	  }
318
319	  return value;
320	};
321
322	var global$f = global$p;
323
324	var setGlobal$2 = setGlobal$3;
325
326	var SHARED = '__core-js_shared__';
327	var store$3 = global$f[SHARED] || setGlobal$2(SHARED, {});
328	var sharedStore = store$3;
329
330	var store$2 = sharedStore;
331
332	(shared$3.exports = function (key, value) {
333	  return store$2[key] || (store$2[key] = value !== undefined ? value : {});
334	})('versions', []).push({
335	  version: '3.21.0',
336	  mode: 'global',
337	  copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)',
338	  license: 'https://github.com/zloirock/core-js/blob/v3.21.0/LICENSE',
339	  source: 'https://github.com/zloirock/core-js'
340	});
341
342	var global$e = global$p;
343
344	var requireObjectCoercible$2 = requireObjectCoercible$4;
345
346	var Object$2 = global$e.Object; // `ToObject` abstract operation
347	// https://tc39.es/ecma262/#sec-toobject
348
349	var toObject$2 = function (argument) {
350	  return Object$2(requireObjectCoercible$2(argument));
351	};
352
353	var uncurryThis$7 = functionUncurryThis;
354
355	var toObject$1 = toObject$2;
356
357	var hasOwnProperty = uncurryThis$7({}.hasOwnProperty); // `HasOwnProperty` abstract operation
358	// https://tc39.es/ecma262/#sec-hasownproperty
359
360	var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
361	  return hasOwnProperty(toObject$1(it), key);
362	};
363
364	var uncurryThis$6 = functionUncurryThis;
365
366	var id = 0;
367	var postfix = Math.random();
368	var toString$3 = uncurryThis$6(1.0.toString);
369
370	var uid$2 = function (key) {
371	  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$3(++id + postfix, 36);
372	};
373
374	var global$d = global$p;
375
376	var shared$2 = shared$3.exports;
377
378	var hasOwn$6 = hasOwnProperty_1;
379
380	var uid$1 = uid$2;
381
382	var NATIVE_SYMBOL = nativeSymbol;
383
384	var USE_SYMBOL_AS_UID = useSymbolAsUid;
385
386	var WellKnownSymbolsStore = shared$2('wks');
387	var Symbol$1 = global$d.Symbol;
388	var symbolFor = Symbol$1 && Symbol$1['for'];
389	var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
390
391	var wellKnownSymbol$3 = function (name) {
392	  if (!hasOwn$6(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
393	    var description = 'Symbol.' + name;
394
395	    if (NATIVE_SYMBOL && hasOwn$6(Symbol$1, name)) {
396	      WellKnownSymbolsStore[name] = Symbol$1[name];
397	    } else if (USE_SYMBOL_AS_UID && symbolFor) {
398	      WellKnownSymbolsStore[name] = symbolFor(description);
399	    } else {
400	      WellKnownSymbolsStore[name] = createWellKnownSymbol(description);
401	    }
402	  }
403
404	  return WellKnownSymbolsStore[name];
405	};
406
407	var global$c = global$p;
408
409	var call$2 = functionCall;
410
411	var isObject$3 = isObject$5;
412
413	var isSymbol$1 = isSymbol$2;
414
415	var getMethod = getMethod$1;
416
417	var ordinaryToPrimitive = ordinaryToPrimitive$1;
418
419	var wellKnownSymbol$2 = wellKnownSymbol$3;
420
421	var TypeError$4 = global$c.TypeError;
422	var TO_PRIMITIVE = wellKnownSymbol$2('toPrimitive'); // `ToPrimitive` abstract operation
423	// https://tc39.es/ecma262/#sec-toprimitive
424
425	var toPrimitive$1 = function (input, pref) {
426	  if (!isObject$3(input) || isSymbol$1(input)) return input;
427	  var exoticToPrim = getMethod(input, TO_PRIMITIVE);
428	  var result;
429
430	  if (exoticToPrim) {
431	    if (pref === undefined) pref = 'default';
432	    result = call$2(exoticToPrim, input, pref);
433	    if (!isObject$3(result) || isSymbol$1(result)) return result;
434	    throw TypeError$4("Can't convert object to primitive value");
435	  }
436
437	  if (pref === undefined) pref = 'number';
438	  return ordinaryToPrimitive(input, pref);
439	};
440
441	var toPrimitive = toPrimitive$1;
442
443	var isSymbol = isSymbol$2; // `ToPropertyKey` abstract operation
444	// https://tc39.es/ecma262/#sec-topropertykey
445
446
447	var toPropertyKey$2 = function (argument) {
448	  var key = toPrimitive(argument, 'string');
449	  return isSymbol(key) ? key : key + '';
450	};
451
452	var global$b = global$p;
453
454	var isObject$2 = isObject$5;
455
456	var document$1 = global$b.document; // typeof document.createElement is 'object' in old IE
457
458	var EXISTS$1 = isObject$2(document$1) && isObject$2(document$1.createElement);
459
460	var documentCreateElement = function (it) {
461	  return EXISTS$1 ? document$1.createElement(it) : {};
462	};
463
464	var DESCRIPTORS$6 = descriptors;
465
466	var fails$3 = fails$8;
467
468	var createElement = documentCreateElement; // Thanks to IE8 for its funny defineProperty
469
470
471	var ie8DomDefine = !DESCRIPTORS$6 && !fails$3(function () {
472	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
473	  return Object.defineProperty(createElement('div'), 'a', {
474	    get: function () {
475	      return 7;
476	    }
477	  }).a != 7;
478	});
479
480	var DESCRIPTORS$5 = descriptors;
481
482	var call$1 = functionCall;
483
484	var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
485
486	var createPropertyDescriptor$1 = createPropertyDescriptor$2;
487
488	var toIndexedObject$2 = toIndexedObject$3;
489
490	var toPropertyKey$1 = toPropertyKey$2;
491
492	var hasOwn$5 = hasOwnProperty_1;
493
494	var IE8_DOM_DEFINE$1 = ie8DomDefine; // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
495
496
497	var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; // `Object.getOwnPropertyDescriptor` method
498	// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
499
500	objectGetOwnPropertyDescriptor.f = DESCRIPTORS$5 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
501	  O = toIndexedObject$2(O);
502	  P = toPropertyKey$1(P);
503	  if (IE8_DOM_DEFINE$1) try {
504	    return $getOwnPropertyDescriptor$1(O, P);
505	  } catch (error) {
506	    /* empty */
507	  }
508	  if (hasOwn$5(O, P)) return createPropertyDescriptor$1(!call$1(propertyIsEnumerableModule$1.f, O, P), O[P]);
509	};
510
511	var objectDefineProperty = {};
512
513	var DESCRIPTORS$4 = descriptors;
514
515	var fails$2 = fails$8; // V8 ~ Chrome 36-
516	// https://bugs.chromium.org/p/v8/issues/detail?id=3334
517
518
519	var v8PrototypeDefineBug = DESCRIPTORS$4 && fails$2(function () {
520	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
521	  return Object.defineProperty(function () {
522	    /* empty */
523	  }, 'prototype', {
524	    value: 42,
525	    writable: false
526	  }).prototype != 42;
527	});
528
529	var global$a = global$p;
530
531	var isObject$1 = isObject$5;
532
533	var String$2 = global$a.String;
534	var TypeError$3 = global$a.TypeError; // `Assert: Type(argument) is Object`
535
536	var anObject$2 = function (argument) {
537	  if (isObject$1(argument)) return argument;
538	  throw TypeError$3(String$2(argument) + ' is not an object');
539	};
540
541	var global$9 = global$p;
542
543	var DESCRIPTORS$3 = descriptors;
544
545	var IE8_DOM_DEFINE = ie8DomDefine;
546
547	var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
548
549	var anObject$1 = anObject$2;
550
551	var toPropertyKey = toPropertyKey$2;
552
553	var TypeError$2 = global$9.TypeError; // eslint-disable-next-line es/no-object-defineproperty -- safe
554
555	var $defineProperty = Object.defineProperty; // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
556
557	var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;

558	var ENUMERABLE = 'enumerable';
559	var CONFIGURABLE$1 = 'configurable';
560	var WRITABLE = 'writable'; // `Object.defineProperty` method
561	// https://tc39.es/ecma262/#sec-object.defineproperty
562
563	objectDefineProperty.f = DESCRIPTORS$3 ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
564	  anObject$1(O);
565	  P = toPropertyKey(P);
566	  anObject$1(Attributes);
567
568	  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
569	    var current = $getOwnPropertyDescriptor(O, P);
570
571	    if (current && current[WRITABLE]) {
572	      O[P] = Attributes.value;
573	      Attributes = {
574	        configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
575	        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
576	        writable: false
577	      };
578	    }
579	  }
580
581	  return $defineProperty(O, P, Attributes);
582	} : $defineProperty : function defineProperty(O, P, Attributes) {
583	  anObject$1(O);
584	  P = toPropertyKey(P);
585	  anObject$1(Attributes);
586	  if (IE8_DOM_DEFINE) try {
587	    return $defineProperty(O, P, Attributes);
588	  } catch (error) {
589	    /* empty */
590	  }
591	  if ('get' in Attributes || 'set' in Attributes) throw TypeError$2('Accessors not supported');
592	  if ('value' in Attributes) O[P] = Attributes.value;
593	  return O;
594	};
595
596	var DESCRIPTORS$2 = descriptors;
597
598	var definePropertyModule$1 = objectDefineProperty;
599
600	var createPropertyDescriptor = createPropertyDescriptor$2;
601
602	var createNonEnumerableProperty$3 = DESCRIPTORS$2 ? function (object, key, value) {
603	  return definePropertyModule$1.f(object, key, createPropertyDescriptor(1, value));
604	} : function (object, key, value) {
605	  object[key] = value;
606	  return object;
607	};
608
609	var redefine$1 = {exports: {}};
610
611	var uncurryThis$5 = functionUncurryThis;
612
613	var isCallable$4 = isCallable$a;
614
615	var store$1 = sharedStore;
616
617	var functionToString = uncurryThis$5(Function.toString); // this helper broken in `[email protected]`, so we can't use `shared` helper
618
619	if (!isCallable$4(store$1.inspectSource)) {
620	  store$1.inspectSource = function (it) {
621	    return functionToString(it);
622	  };
623	}
624
625	var inspectSource$2 = store$1.inspectSource;
626
627	var global$8 = global$p;
628
629	var isCallable$3 = isCallable$a;
630
631	var inspectSource$1 = inspectSource$2;
632
633	var WeakMap$1 = global$8.WeakMap;
634	var nativeWeakMap = isCallable$3(WeakMap$1) && /native code/.test(inspectSource$1(WeakMap$1));
635
636	var shared$1 = shared$3.exports;
637
638	var uid = uid$2;
639
640	var keys = shared$1('keys');
641
642	var sharedKey$1 = function (key) {
643	  return keys[key] || (keys[key] = uid(key));
644	};
645
646	var hiddenKeys$3 = {};
647
648	var NATIVE_WEAK_MAP = nativeWeakMap;
649
650	var global$7 = global$p;
651
652	var uncurryThis$4 = functionUncurryThis;
653
654	var isObject = isObject$5;
655
656	var createNonEnumerableProperty$2 = createNonEnumerableProperty$3;
657
658	var hasOwn$4 = hasOwnProperty_1;
659
660	var shared = sharedStore;
661
662	var sharedKey = sharedKey$1;
663
664	var hiddenKeys$2 = hiddenKeys$3;
665
666	var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
667	var TypeError$1 = global$7.TypeError;
668	var WeakMap = global$7.WeakMap;
669	var set$1, get, has;
670
671	var enforce = function (it) {
672	  return has(it) ? get(it) : set$1(it, {});
673	};
674
675	var getterFor = function (TYPE) {
676	  return function (it) {
677	    var state;
678
679	    if (!isObject(it) || (state = get(it)).type !== TYPE) {
680	      throw TypeError$1('Incompatible receiver, ' + TYPE + ' required');
681	    }
682
683	    return state;
684	  };
685	};
686
687	if (NATIVE_WEAK_MAP || shared.state) {
688	  var store = shared.state || (shared.state = new WeakMap());
689	  var wmget = uncurryThis$4(store.get);
690	  var wmhas = uncurryThis$4(store.has);
691	  var wmset = uncurryThis$4(store.set);
692
693	  set$1 = function (it, metadata) {
694	    if (wmhas(store, it)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
695	    metadata.facade = it;
696	    wmset(store, it, metadata);
697	    return metadata;
698	  };
699
700	  get = function (it) {
701	    return wmget(store, it) || {};
702	  };
703
704	  has = function (it) {
705	    return wmhas(store, it);
706	  };
707	} else {
708	  var STATE = sharedKey('state');
709	  hiddenKeys$2[STATE] = true;
710
711	  set$1 = function (it, metadata) {
712	    if (hasOwn$4(it, STATE)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
713	    metadata.facade = it;
714	    createNonEnumerableProperty$2(it, STATE, metadata);
715	    return metadata;
716	  };
717
718	  get = function (it) {
719	    return hasOwn$4(it, STATE) ? it[STATE] : {};
720	  };
721
722	  has = function (it) {
723	    return hasOwn$4(it, STATE);
724	  };
725	}
726
727	var internalState = {
728	  set: set$1,
729	  get: get,
730	  has: has,
731	  enforce: enforce,
732	  getterFor: getterFor
733	};
734
735	var DESCRIPTORS$1 = descriptors;
736
737	var hasOwn$3 = hasOwnProperty_1;
738
739	var FunctionPrototype = Function.prototype; // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
740
741	var getDescriptor = DESCRIPTORS$1 && Object.getOwnPropertyDescriptor;
742	var EXISTS = hasOwn$3(FunctionPrototype, 'name'); // additional protection from minified / mangled / dropped function names
743
744	var PROPER = EXISTS && function something() {
745	  /* empty */
746	}.name === 'something';
747
748	var CONFIGURABLE = EXISTS && (!DESCRIPTORS$1 || DESCRIPTORS$1 && getDescriptor(FunctionPrototype, 'name').configurable);
749	var functionName = {
750	  EXISTS: EXISTS,
751	  PROPER: PROPER,
752	  CONFIGURABLE: CONFIGURABLE
753	};
754
755	var global$6 = global$p;
756
757	var isCallable$2 = isCallable$a;
758
759	var hasOwn$2 = hasOwnProperty_1;
760
761	var createNonEnumerableProperty$1 = createNonEnumerableProperty$3;
762
763	var setGlobal$1 = setGlobal$3;
764
765	var inspectSource = inspectSource$2;
766
767	var InternalStateModule = internalState;
768
769	var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
770
771	var getInternalState = InternalStateModule.get;
772	var enforceInternalState = InternalStateModule.enforce;

773	var TEMPLATE = String(String).split('String');
774	(redefine$1.exports = function (O, key, value, options) {
775	  var unsafe = options ? !!options.unsafe : false;
776	  var simple = options ? !!options.enumerable : false;
777	  var noTargetGet = options ? !!options.noTargetGet : false;
778	  var name = options && options.name !== undefined ? options.name : key;
779	  var state;
780
781	  if (isCallable$2(value)) {
782	    if (String(name).slice(0, 7) === 'Symbol(') {
783	      name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']';
784	    }
785
786	    if (!hasOwn$2(value, 'name') || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
787	      createNonEnumerableProperty$1(value, 'name', name);
788	    }
789
790	    state = enforceInternalState(value);
791
792	    if (!state.source) {
793	      state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
794	    }
795	  }
796
797	  if (O === global$6) {
798	    if (simple) O[key] = value;else setGlobal$1(key, value);
799	    return;
800	  } else if (!unsafe) {
801	    delete O[key];
802	  } else if (!noTargetGet && O[key]) {
803	    simple = true;
804	  }
805
806	  if (simple) O[key] = value;else createNonEnumerableProperty$1(O, key, value); // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
807	})(Function.prototype, 'toString', function toString() {
808	  return isCallable$2(this) && getInternalState(this).source || inspectSource(this);
809	});
810
811	var objectGetOwnPropertyNames = {};
812
813	var ceil$1 = Math.ceil;
814	var floor = Math.floor; // `ToIntegerOrInfinity` abstract operation
815	// https://tc39.es/ecma262/#sec-tointegerorinfinity
816
817	var toIntegerOrInfinity$3 = function (argument) {
818	  var number = +argument; // eslint-disable-next-line no-self-compare -- safe
819
820	  return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil$1)(number);
821	};
822
823	var toIntegerOrInfinity$2 = toIntegerOrInfinity$3;
824
825	var max = Math.max;
826	var min$1 = Math.min; // Helper for a popular repeating case of the spec:
827	// Let integer be ? ToInteger(index).
828	// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
829
830	var toAbsoluteIndex$1 = function (index, length) {
831	  var integer = toIntegerOrInfinity$2(index);
832	  return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
833	};
834
835	var toIntegerOrInfinity$1 = toIntegerOrInfinity$3;
836
837	var min = Math.min; // `ToLength` abstract operation
838	// https://tc39.es/ecma262/#sec-tolength
839
840	var toLength$2 = function (argument) {
841	  return argument > 0 ? min(toIntegerOrInfinity$1(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
842	};
843
844	var toLength$1 = toLength$2; // `LengthOfArrayLike` abstract operation
845	// https://tc39.es/ecma262/#sec-lengthofarraylike
846
847
848	var lengthOfArrayLike$1 = function (obj) {
849	  return toLength$1(obj.length);
850	};
851
852	var toIndexedObject$1 = toIndexedObject$3;
853
854	var toAbsoluteIndex = toAbsoluteIndex$1;
855
856	var lengthOfArrayLike = lengthOfArrayLike$1; // `Array.prototype.{ indexOf, includes }` methods implementation
857
858
859	var createMethod$1 = function (IS_INCLUDES) {
860	  return function ($this, el, fromIndex) {
861	    var O = toIndexedObject$1($this);
862	    var length = lengthOfArrayLike(O);
863	    var index = toAbsoluteIndex(fromIndex, length);
864	    var value; // Array#includes uses SameValueZero equality algorithm
865	    // eslint-disable-next-line no-self-compare -- NaN check
866
867	    if (IS_INCLUDES && el != el) while (length > index) {
868	      value = O[index++]; // eslint-disable-next-line no-self-compare -- NaN check
869
870	      if (value != value) return true; // Array#indexOf ignores holes, Array#includes - not
871	    } else for (; length > index; index++) {
872	      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
873	    }
874	    return !IS_INCLUDES && -1;
875	  };
876	};
877
878	var arrayIncludes = {
879	  // `Array.prototype.includes` method
880	  // https://tc39.es/ecma262/#sec-array.prototype.includes
881	  includes: createMethod$1(true),
882	  // `Array.prototype.indexOf` method
883	  // https://tc39.es/ecma262/#sec-array.prototype.indexof
884	  indexOf: createMethod$1(false)
885	};
886
887	var uncurryThis$3 = functionUncurryThis;
888
889	var hasOwn$1 = hasOwnProperty_1;
890
891	var toIndexedObject = toIndexedObject$3;
892
893	var indexOf = arrayIncludes.indexOf;
894
895	var hiddenKeys$1 = hiddenKeys$3;
896
897	var push = uncurryThis$3([].push);
898
899	var objectKeysInternal = function (object, names) {
900	  var O = toIndexedObject(object);
901	  var i = 0;
902	  var result = [];
903	  var key;
904
905	  for (key in O) !hasOwn$1(hiddenKeys$1, key) && hasOwn$1(O, key) && push(result, key); // Don't enum bug & hidden keys
906
907
908	  while (names.length > i) if (hasOwn$1(O, key = names[i++])) {
909	    ~indexOf(result, key) || push(result, key);
910	  }
911
912	  return result;
913	};
914
915	// IE8- don't enum bug keys
916	var enumBugKeys$2 = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleStr

916ing', 'toString', 'valueOf'];
917
918	var internalObjectKeys$1 = objectKeysInternal;
919
920	var enumBugKeys$1 = enumBugKeys$2;
921
922	var hiddenKeys = enumBugKeys$1.concat('length', 'prototype'); // `Object.getOwnPropertyNames` method
923	// https://tc39.es/ecma262/#sec-object.getownpropertynames
924	// eslint-disable-next-line es/no-object-getownpropertynames -- safe
925
926	objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
927	  return internalObjectKeys$1(O, hiddenKeys);
928	};
929
930	var objectGetOwnPropertySymbols = {};
931
932	// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
933	objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
934
935	var getBuiltIn = getBuiltIn$3;
936
937	var uncurryThis$2 = functionUncurryThis;
938
939	var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
940
941	var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
942
943	var anObject = anObject$2;
944
945	var concat$1 = uncurryThis$2([].concat); // all object keys, includes non-enumerable and symbols
946
947	var ownKeys$1 = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
948	  var keys = getOwnPropertyNamesModule.f(anObject(it));
949	  var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
950	  return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys;
951	};
952
953	var hasOwn = hasOwnProperty_1;
954
955	var ownKeys = ownKeys$1;
956
957	var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
958
959	var definePropertyModule = objectDefineProperty;
960
961	var copyConstructorProperties$1 = function (target, source, exceptions) {
962	  var keys = ownKeys(source);
963	  var defineProperty = definePropertyModule.f;
964	  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
965
966	  for (var i = 0; i < keys.length; i++) {
967	    var key = keys[i];
968
969	    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
970	      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
971	    }
972	  }
973	};
974
975	var fails$1 = fails$8;
976
977	var isCallable$1 = isCallable$a;
978
979	var replacement = /#|\.prototype\./;
980
981	var isForced$1 = function (feature, detection) {
982	  var value = data[normalize(feature)];
983	  return value == POLYFILL ? true : value == NATIVE ? false : isCallable$1(detection) ? fails$1(detection) : !!detection;
984	};
985
986	var normalize = isForced$1.normalize = function (string) {
987	  return String(string).replace(replacement, '.').toLowerCase();
988	};
989
990	var data = isForced$1.data = {};
991	var NATIVE = isForced$1.NATIVE = 'N';
992	var POLYFILL = isForced$1.POLYFILL = 'P';
993	var isForced_1 = isForced$1;
994
995	var global$5 = global$p;
996
997	var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
998
999	var createNonEnumerableProperty = createNonEnumerableProperty$3;
1000
1001	var redefine = redefine$1.exports;
1002
1003	var setGlobal = setGlobal$3;
1004
1005	var copyConstructorProperties = copyConstructorProperties$1;
1006
1007	var isForced = isForced_1;
1008	/*
1009	  options.target      - name of the target object
1010	  options.global      - target is the global object
1011	  options.stat        - export as static methods of target
1012	  options.proto       - export as prototype methods of target
1013	  options.real        - real prototype method for the `pure` version
1014	  options.forced      - export even if the native feature is available
1015	  options.bind        - bind methods to the target, required for the `pure` version
1016	  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
1017	  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
1018	  options.sham        - add a flag to not completely full polyfills
1019	  options.enumerable  - export as enumerable property
1020	  options.noTargetGet - prevent calling a getter on target
1021	  options.name        - the .name of the function if it does not match the key
1022	*/
1023
1024
1025	var _export = function (options, source) {
1026	  var TARGET = options.target;
1027	  var GLOBAL = options.global;
1028	  var STATIC = options.stat;
1029	  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
1030
1031	  if (GLOBAL) {
1032	    target = global$5;
1033	  } else if (STATIC) {
1034	    target = global$5[TARGET] || setGlobal(TARGET, {});
1035	  } else {
1036	    target = (global$5[TARGET] || {}).prototype;
1037	  }
1038
1039	  if (target) for (key in source) {
1040	    sourceProperty = source[key];
1041
1042	    if (options.noTargetGet) {
1043	      descriptor = getOwnPropertyDescriptor(target, key);
1044	      targetProperty = descriptor && descriptor.value;
1045	    } else targetProperty = target[key];
1046
1047	    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); // contained in target
1048
1049	    if (!FORCED && targetProperty !== undefined) {
1050	      if (typeof sourceProperty == typeof targetProperty) continue;
1051	      copyConstructorProperties(sourceProperty, targetProperty);
1052	    }

1052 // add a flag to not completely full polyfills
1053
1054
1055	    if (options.sham || targetProperty && targetProperty.sham) {
1056	      createNonEnumerableProperty(sourceProperty, 'sham', true);
1057	    } // extend global
1058
1059
1060	    redefine(target, key, sourceProperty, options);
1061	  }
1062	};
1063
1064	var internalObjectKeys = objectKeysInternal;
1065
1066	var enumBugKeys = enumBugKeys$2; // `Object.keys` method
1067	// https://tc39.es/ecma262/#sec-object.keys
1068	// eslint-disable-next-line es/no-object-keys -- safe
1069
1070
1071	var objectKeys$1 = Object.keys || function keys(O) {
1072	  return internalObjectKeys(O, enumBugKeys);
1073	};
1074
1075	var DESCRIPTORS = descriptors;
1076
1077	var uncurryThis$1 = functionUncurryThis;
1078
1079	var call = functionCall;
1080
1081	var fails = fails$8;
1082
1083	var objectKeys = objectKeys$1;
1084
1085	var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
1086
1087	var propertyIsEnumerableModule = objectPropertyIsEnumerable;
1088
1089	var toObject = toObject$2;
1090
1091	var IndexedObject = indexedObject; // eslint-disable-next-line es/no-object-assign -- safe
1092
1093
1094	var $assign = Object.assign; // eslint-disable-next-line es/no-object-defineproperty -- required for testing
1095
1096	var defineProperty = Object.defineProperty;
1097	var concat = uncurryThis$1([].concat); // `Object.assign` method
1098	// https://tc39.es/ecma262/#sec-object.assign
1099
1100	var objectAssign = !$assign || fails(function () {
1101	  // should have correct order of operations (Edge bug)
1102	  if (DESCRIPTORS && $assign({
1103	    b: 1
1104	  }, $assign(defineProperty({}, 'a', {
1105	    enumerable: true,
1106	    get: function () {
1107	      defineProperty(this, 'b', {
1108	        value: 3,
1109	        enumerable: false
1110	      });
1111	    }
1112	  }), {
1113	    b: 2
1114	  })).b !== 1) return true; // should work with symbols and should have deterministic property order (V8 bug)
1115
1116	  var A = {};
1117	  var B = {}; // eslint-disable-next-line es/no-symbol -- safe
1118
1119	  var symbol = Symbol();
1120	  var alphabet = 'abcdefghijklmnopqrst';
1121	  A[symbol] = 7;
1122	  alphabet.split('').forEach(function (chr) {
1123	    B[chr] = chr;
1124	  });
1125	  return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;
1126	}) ? function assign(target, source) {
1127	  // eslint-disable-line no-unused-vars -- required for `.length`
1128	  var T = toObject(target);
1129	  var argumentsLength = arguments.length;
1130	  var index = 1;
1131	  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1132	  var propertyIsEnumerable = propertyIsEnumerableModule.f;
1133
1134	  while (argumentsLength > index) {
1135	    var S = IndexedObject(arguments[index++]);
1136	    var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
1137	    var length = keys.length;
1138	    var j = 0;
1139	    var key;
1140
1141	    while (length > j) {
1142	      key = keys[j++];
1143	      if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];
1144	    }
1145	  }
1146
1147	  return T;
1148	} : $assign;
1149
1150	var $$4 = _export;
1151
1152	var assign = objectAssign; // `Object.assign` method
1153	// https://tc39.es/ecma262/#sec-object.assign
1154	// eslint-disable-next-line es/no-object-assign -- required for testing
1155
1156
1157	$$4({
1158	  target: 'Object',
1159	  stat: true,
1160	  forced: Object.assign !== assign
1161	}, {
1162	  assign: assign
1163	});
1164
1165	var wellKnownSymbol$1 = wellKnownSymbol$3;
1166
1167	var TO_STRING_TAG$1 = wellKnownSymbol$1('toStringTag');
1168	var test = {};
1169	test[TO_STRING_TAG$1] = 'z';
1170	var toStringTagSupport = String(test) === '[object z]';
1171
1172	var global$4 = global$p;
1173
1174	var TO_STRING_TAG_SUPPORT = toStringTagSupport;
1175
1176	var isCallable = isCallable$a;
1177
1178	var classofRaw = classofRaw$1;
1179
1180	var wellKnownSymbol = wellKnownSymbol$3;
1181
1182	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1183	var Object$1 = global$4.Object; // ES3 wrong here
1184
1185	var CORRECT_ARGUMENTS = classofRaw(function () {
1186	  return arguments;
1187	}()) == 'Arguments'; // fallback for IE11 Script Access Denied error
1188
1189	var tryGet = function (it, key) {
1190	  try {
1191	    return it[key];
1192	  } catch (error) {
1193	    /* empty */
1194	  }
1195	}; // getting tag from ES6+ `Object.prototype.toString`
1196
1197
1198	var classof$1 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
1199	  var O, tag, result;
1200	  return it === undefined ? 'Undefined' : it === null ? 'Null' // @@toStringTag case
1201	  : typeof (tag = tryGet(O = Object$1(it), TO_STRING_TAG)) == 'string' ? tag // builtinTag case
1202	  : CORRECT_ARGUMENTS ? classofRaw(O) // ES3 arguments fallback
1203	  : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
1204	};
1205
1206	var global$3 = global$p;
1207
1208	var classof = classof$1;
1209
1210	var String$1 = global$3.String;
1211
1212	var toString$2 = function (argument) {
1213	  if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
1214	  return String$1(argument);
1215	};
1216
1217	var global$2 = global$p;
1218
1219	var toIntegerOrInfinity = toIntegerOrInfinity$3;
1220
1221	var toString$1 = toString$2;
1222
1223	var requireObjectCoercible$1 = requireObjectCoercible$4;
1224
1225	var RangeError = global$2.RangeError; // `String.prototype.repeat` method implementation
1226	// https://tc39.es/ecma262/#sec-string.prototype.repeat
1227
1228	var stringRepeat = function repeat(count) {
1229	  var str = toString$1(requireObjectCoercible$1(this));
1230	  var result = '';
1231	  var n = toIntegerOrInfinity(count);
1232	  if (n < 0 || n == Infinity) throw RangeError('Wrong number of repetitions');
1233
1234	  for (; n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str;
1235
1236	  return result;
1237	};
1238
1239	var $$3 = _export;
1240
1241	var repeat$1 = stringRepeat; // `String.prototype.repeat` method
1242	// https://tc39.es/ecma262/#sec-string.prototype.repeat
1243
1244
1245	$$3({
1246	  target: 'String',
1247	  proto: true
1248	}, {
1249	  repeat: repeat$1
1250	});
1251
1252	// https://github.com/tc39/proposal-string-pad-start-end
1253	var uncurryThis = functionUncurryThis;
1254
1255	var toLength = toLength$2;
1256
1257	var toString = toString$2;
1258
1259	var $repeat = stringRepeat;
1260
1261	var requireObjectCoercible = requireObjectCoercible$4;
1262
1263	var repeat = uncurryThis($repeat);
1264	var stringSlice = uncurryThis(''.slice);

1265	var ceil = Math.ceil; // `String.prototype.{ padStart, padEnd }` methods implementation
1266
1267	var createMethod = function (IS_END) {
1268	  return function ($this, maxLength, fillString) {
1269	    var S = toString(requireObjectCoercible($this));
1270	    var intMaxLength = toLength(maxLength);
1271	    var stringLength = S.length;
1272	    var fillStr = fillString === undefined ? ' ' : toString(fillString);
1273	    var fillLen, stringFiller;
1274	    if (intMaxLength <= stringLength || fillStr == '') return S;
1275	    fillLen = intMaxLength - stringLength;
1276	    stringFiller = repeat(fillStr, ceil(fillLen / fillStr.length));
1277	    if (stringFiller.length > fillLen) stringFiller = stringSlice(stringFiller, 0, fillLen);
1278	    return IS_END ? S + stringFiller : stringFiller + S;
1279	  };
1280	};
1281
1282	var stringPad = {
1283	  // `String.prototype.padStart` method
1284	  // https://tc39.es/ecma262/#sec-string.prototype.padstart
1285	  start: createMethod(false),
1286	  // `String.prototype.padEnd` method
1287	  // https://tc39.es/ecma262/#sec-string.prototype.padend
1288	  end: createMethod(true)
1289	};
1290
1291	// https://github.com/zloirock/core-js/issues/280
1292	var userAgent = engineUserAgent;
1293
1294	var stringPadWebkitBug = /Version\/10(?:\.\d+){1,2}(?: [\w./]+)?(?: Mobile\/\w+)? Safari\//.test(userAgent);
1295
1296	var $$2 = _export;
1297
1298	var $padStart = stringPad.start;
1299
1300	var WEBKIT_BUG$1 = stringPadWebkitBug; // `String.prototype.padStart` method
1301	// https://tc39.es/ecma262/#sec-string.prototype.padstart
1302
1303
1304	$$2({
1305	  target: 'String',
1306	  proto: true,
1307	  forced: WEBKIT_BUG$1
1308	}, {
1309	  padStart: function padStart(maxLength
1310	  /* , fillString = ' ' */
1311	  ) {
1312	    return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
1313	  }
1314	});
1315
1316	var $$1 = _export;
1317
1318	var $padEnd = stringPad.end;
1319
1320	var WEBKIT_BUG = stringPadWebkitBug; // `String.prototype.padEnd` method
1321	// https://tc39.es/ecma262/#sec-string.prototype.padend
1322
1323
1324	$$1({
1325	  target: 'String',
1326	  proto: true,
1327	  forced: WEBKIT_BUG
1328	}, {
1329	  padEnd: function padEnd(maxLength
1330	  /* , fillString = ' ' */
1331	  ) {
1332	    return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
1333	  }
1334	});
1335
1336	var $ = _export;
1337
1338	var global$1 = global$p; // `globalThis` object
1339	// https://tc39.es/ecma262/#sec-globalthis
1340
1341
1342	$({
1343	  global: true
1344	}, {
1345	  globalThis: global$1
1346	});
1347
1348	function _typeof(obj) {
1349	  "@babel/helpers - typeof";
1350
1351	  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
1352	    return typeof obj;
1353	  } : function (obj) {
1354	    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
1355	  }, _typeof(obj);
1356	}
1357
1358	function _classCallCheck(instance, Constructor) {
1359	  if (!(instance instanceof Constructor)) {
1360	    throw new TypeError("Cannot call a class as a function");
1361	  }
1362	}
1363
1364	function _defineProperties(target, props) {
1365	  for (var i = 0; i < props.length; i++) {
1366	    var descriptor = props[i];
1367	    descriptor.enumerable = descriptor.enumerable || false;
1368	    descriptor.configurable = true;
1369	    if ("value" in descriptor) descriptor.writable = true;
1370	    Object.defineProperty(target, descriptor.key, descriptor);
1371	  }
1372	}
1373
1374	function _createClass(Constructor, protoProps, staticProps) {
1375	  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
1376	  if (staticProps) _defineProperties(Constructor, staticProps);
1377	  Object.defineProperty(Constructor, "prototype", {
1378	    writable: false
1379	  });
1380	  return Constructor;
1381	}
1382
1383	function _defineProperty(obj, key, value) {
1384	  if (key in obj) {
1385	    Object.defineProperty(obj, key, {
1386	      value: value,
1387	      enumerable: true,
1388	      configurable: true,
1389	      writable: true
1390	    });
1391	  } else {
1392	    obj[key] = value;
1393	  }
1394
1395	  return obj;
1396	}
1397
1398	function _inherits(subClass, superClass) {
1399	  if (typeof superClass !== "function" && superClass !== null) {
1400	    throw new TypeError("Super expression must either be null or a function");
1401	  }
1402
1403	  subClass.prototype = Object.create(superClass && superClass.prototype, {
1404	    constructor: {
1405	      value: subClass,
1406	      writable: true,
1407	      configurable: true
1408	    }
1409	  });
1410	  Object.defineProperty(subClass, "prototype", {
1411	    writable: false
1412	  });
1413	  if (superClass) _setPrototypeOf(subClass, superClass);
1414	}
1415

1416	function _getPrototypeOf(o) {
1417	  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
1418	    return o.__proto__ || Object.getPrototypeOf(o);
1419	  };
1420	  return _getPrototypeOf(o);
1421	}
1422
1423	function _setPrototypeOf(o, p) {
1424	  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
1425	    o.__proto__ = p;
1426	    return o;
1427	  };
1428
1429	  return _setPrototypeOf(o, p);
1430	}
1431
1432	function _isNativeReflectConstruct() {
1433	  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
1434	  if (Reflect.construct.sham) return false;
1435	  if (typeof Proxy === "function") return true;
1436
1437	  try {
1438	    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
1439	    return true;
1440	  } catch (e) {
1441	    return false;
1442	  }
1443	}
1444
1445	function _objectWithoutPropertiesLoose(source, excluded) {
1446	  if (source == null) return {};
1447	  var target = {};
1448	  var sourceKeys = Object.keys(source);
1449	  var key, i;
1450
1451	  for (i = 0; i < sourceKeys.length; i++) {
1452	    key = sourceKeys[i];
1453	    if (excluded.indexOf(key) >= 0) continue;
1454	    target[key] = source[key];
1455	  }
1456
1457	  return target;
1458	}
1459
1460	function _objectWithoutProperties(source, excluded) {
1461	  if (source == null) return {};
1462
1463	  var target = _objectWithoutPropertiesLoose(source, excluded);
1464
1465	  var key, i;
1466
1467	  if (Object.getOwnPropertySymbols) {
1468	    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
1469
1470	    for (i = 0; i < sourceSymbolKeys.length; i++) {
1471	      key = sourceSymbolKeys[i];
1472	      if (excluded.indexOf(key) >= 0) continue;
1473	      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
1474	      target[key] = source[key];
1475	    }
1476	  }
1477
1478	  return target;
1479	}
1480
1481	function _assertThisInitialized(self) {
1482	  if (self === void 0) {
1483	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
1484	  }
1485
1486	  return self;
1487	}
1488
1489	function _possibleConstructorReturn(self, call) {
1490	  if (call && (typeof call === "object" || typeof call === "function")) {
1491	    return call;
1492	  } else if (call !== void 0) {
1493	    throw new TypeError("Derived constructors may only return object or undefined");
1494	  }
1495
1496	  return _assertThisInitialized(self);
1497	}
1498
1499	function _createSuper(Derived) {
1500	  var hasNativeReflectConstruct = _isNativeReflectConstruct();
1501
1502	  return function _createSuperInternal() {
1503	    var Super = _getPrototypeOf(Derived),
1504	        result;
1505
1506	    if (hasNativeReflectConstruct) {
1507	      var NewTarget = _getPrototypeOf(this).constructor;
1508
1509	      result = Reflect.construct(Super, arguments, NewTarget);
1510	    } else {
1511	      result = Super.apply(this, arguments);
1512	    }
1513
1514	    return _possibleConstructorReturn(this, result);
1515	  };
1516	}
1517
1518	function _superPropBase(object, property) {
1519	  while (!Object.prototype.hasOwnProperty.call(object, property)) {
1520	    object = _getPrototypeOf(object);
1521	    if (object === null) break;
1522	  }
1523
1524	  return object;
1525	}
1526
1527	function _get() {
1528	  if (typeof Reflect !== "undefined" && Reflect.get) {
1529	    _get = Reflect.get;
1530	  } else {
1531	    _get = function _get(target, property, receiver) {
1532	      var base = _superPropBase(target, property);
1533
1534	      if (!base) return;
1535	      var desc = Object.getOwnPropertyDescriptor(base, property);
1536
1537	      if (desc.get) {
1538	        return desc.get.call(arguments.length < 3 ? target : receiver);
1539	      }
1540
1541	      return desc.value;
1542	    };
1543	  }
1544
1545	  return _get.apply(this, arguments);
1546	}
1547
1548	function set(target, property, value, receiver) {
1549	  if (typeof Reflect !== "undefined" && Reflect.set) {
1550	    set = Reflect.set;
1551	  } else {
1552	    set = function set(target, property, value, receiver) {
1553	      var base = _superPropBase(target, property);
1554
1555	      var desc;
1556
1557	      if (base) {
1558	        desc = Object.getOwnPropertyDescriptor(base, property);
1559
1560	        if (desc.set) {
1561	          desc.set.call(receiver, value);
1562	          return true;
1563	        } else if (!desc.writable) {
1564	          return false;
1565	        }
1566	      }
1567
1568	      desc = Object.getOwnPropertyDescriptor(receiver, property);
1569
1570	      if (desc) {
1571	        if (!desc.writable) {
1572	          return false;
1573	        }
1574
1575	        desc.value = value;
1576	        Object.defineProperty(receiver, property, desc);
1577	      } else {
1578	        _defineProperty(receiver, property, value);
1579	      }
1580
1581	      return true;
1582	    };
1583	  }
1584
1585	  return set(target, property, value, receiver);
1586	}
1587
1588	function _set(target, property, value, receiver, isStrict) {
1589	  var s = set(target, property, value, receiver || target);
1590
1591	  if (!s && isStrict) {
1592	    throw new Error('failed to set property');
1593	  }
1594
1595	  return value;
1596	}
1597
1598	function _slicedToArray(arr, i) {
1599	  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
1600	}
1601
1602	function _arrayWithHoles(arr) {
1603	  if (Array.isArray(arr)) return arr;
1604	}
1605
1606	function _iterableToArrayLimit(arr, i) {
1607	  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
1608
1609	  if (_i == null) return;
1610	  var _arr = [];
1611	  var _n = true;
1612	  var _d = false;

1613
1614	  var _s, _e;
1615
1616	  try {
1617	    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
1618	      _arr.push(_s.value);
1619
1620	      if (i && _arr.length === i) break;
1621	    }
1622	  } catch (err) {
1623	    _d = true;
1624	    _e = err;
1625	  } finally {
1626	    try {
1627	      if (!_n && _i["return"] != null) _i["return"]();
1628	    } finally {
1629	      if (_d) throw _e;
1630	    }
1631	  }
1632
1633	  return _arr;
1634	}
1635
1636	function _unsupportedIterableToArray(o, minLen) {
1637	  if (!o) return;
1638	  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
1639	  var n = Object.prototype.toString.call(o).slice(8, -1);
1640	  if (n === "Object" && o.constructor) n = o.constructor.name;
1641	  if (n === "Map" || n === "Set") return Array.from(o);
1642	  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
1643	}
1644
1645	function _arrayLikeToArray(arr, len) {
1646	  if (len == null || len > arr.length) len = arr.length;
1647
1648	  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
1649
1650	  return arr2;
1651	}
1652
1653	function _nonIterableRest() {
1654	  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
1655	}
1656
1657	/**
1658	  Provides details of changing model value
1659	  @param {Object} [details]
1660	  @param {string} [details.inserted] - Inserted symbols
1661	  @param {boolean} [details.skip] - Can skip chars
1662	  @param {number} [details.removeCount] - Removed symbols count
1663	  @param {number} [details.tailShift] - Additional offset if any changes occurred before tail
1664	*/
1665	var ChangeDetails = /*#__PURE__*/function () {
1666	  /** Inserted symbols */
1667
1668	  /** Can skip chars */
1669
1670	  /** Additional offset if any changes occurred before tail */
1671
1672	  /** Raw inserted is used by dynamic mask */
1673	  function ChangeDetails(details) {
1674	    _classCallCheck(this, ChangeDetails);
1675
1676	    Object.assign(this, {
1677	      inserted: '',
1678	      rawInserted: '',
1679	      skip: false,
1680	      tailShift: 0
1681	    }, details);
1682	  }
1683	  /**
1684	    Aggregate changes
1685	    @returns {ChangeDetails} `this`
1686	  */
1687
1688
1689	  _createClass(ChangeDetails, [{
1690	    key: "aggregate",
1691	    value: function aggregate(details) {
1692	      this.rawInserted += details.rawInserted;
1693	      this.skip = this.skip || details.skip;
1694	      this.inserted += details.inserted;
1695	      this.tailShift += details.tailShift;
1696	      return this;
1697	    }
1698	    /** Total offset considering all changes */
1699
1700	  }, {
1701	    key: "offset",
1702	    get: function get() {
1703	      return this.tailShift + this.inserted.length;
1704	    }
1705	  }]);
1706
1707	  return ChangeDetails;
1708	}();
1709
1710	/** Checks if value is string */
1711
1712	function isString(str) {
1713	  return typeof str === 'string' || str instanceof String;
1714	}
1715	/**
1716	  Direction
1717	  @prop {string} NONE
1718	  @prop {string} LEFT
1719	  @prop {string} FORCE_LEFT
1720	  @prop {string} RIGHT
1721	  @prop {string} FORCE_RIGHT
1722	*/
1723
1724	var DIRECTION = {
1725	  NONE: 'NONE',
1726	  LEFT: 'LEFT',
1727	  FORCE_LEFT: 'FORCE_LEFT',
1728	  RIGHT: 'RIGHT',
1729	  FORCE_RIGHT: 'FORCE_RIGHT'
1730	};
1731	/** */
1732
1733	function forceDirection(direction) {
1734	  switch (direction) {
1735	    case DIRECTION.LEFT:
1736	      return DIRECTION.FORCE_LEFT;
1737
1738	    case DIRECTION.RIGHT:
1739	      return DIRECTION.FORCE_RIGHT;
1740
1741	    default:
1742	      return direction;
1743	  }
1744	}
1745	/** Escapes regular expression control chars */
1746
1747	function escapeRegExp(str) {
1748	  return str.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
1749	}
1750	function normalizePrepare(prep) {
1751	  return Array.isArray(prep) ? prep : [prep, new ChangeDetails()];
1752	} // cloned from https://github.com/epoberezkin/fast-deep-equal with small changes
1753
1754	function objectIncludes(b, a) {
1755	  if (a === b) return true;
1756	  var arrA = Array.isArray(a),
1757	      arrB = Array.isArray(b),
1758	      i;
1759
1760	  if (arrA && arrB) {
1761	    if (a.length != b.length) return false;
1762
1763	    for (i = 0; i < a.length; i++) {
1764	      if (!objectIncludes(a[i], b[i])) return false;
1765	    }
1766
1767	    return true;
1768	  }
1769
1770	  if (arrA != arrB) return false;
1771
1772	  if (a && b && _typeof(a) === 'object' && _typeof(b) === 'object') {
1773	    var dateA = a instanceof Date,
1774	        dateB = b instanceof Date;
1775	    if (dateA && dateB) return a.getTime() == b.getTime();
1776	    if (dateA != dateB) return false;

1777	    var regexpA = a instanceof RegExp,
1778	        regexpB = b instanceof RegExp;
1779	    if (regexpA && regexpB) return a.toString() == b.toString();
1780	    if (regexpA != regexpB) return false;
1781	    var keys = Object.keys(a); // if (keys.length !== Object.keys(b).length) return false;
1782
1783	    for (i = 0; i < keys.length; i++) {
1784	      // $FlowFixMe ... ???
1785	      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
1786	    }
1787
1788	    for (i = 0; i < keys.length; i++) {
1789	      if (!objectIncludes(b[keys[i]], a[keys[i]])) return false;
1790	    }
1791
1792	    return true;
1793	  } else if (a && b && typeof a === 'function' && typeof b === 'function') {
1794	    return a.toString() === b.toString();
1795	  }
1796
1797	  return false;
1798	}
1799	/** Selection range */
1800
1801	/** Provides details of changing input */
1802
1803	var ActionDetails = /*#__PURE__*/function () {
1804	  /** Current input value */
1805
1806	  /** Current cursor position */
1807
1808	  /** Old input value */
1809
1810	  /** Old selection */
1811	  function ActionDetails(value, cursorPos, oldValue, oldSelection) {
1812	    _classCallCheck(this, ActionDetails);
1813
1814	    this.value = value;

1815	    this.cursorPos = cursorPos;
1816	    this.oldValue = oldValue;
1817	    this.oldSelection = oldSelection; // double check if left part was changed (autofilling, other non-standard input triggers)
1818
1819	    while (this.value.slice(0, this.startChangePos) !== this.oldValue.slice(0, this.startChangePos)) {
1820	      --this.oldSelection.start;
1821	    }
1822	  }
1823	  /**
1824	    Start changing position
1825	    @readonly
1826	  */
1827
1828
1829	  _createClass(ActionDetails, [{
1830	    key: "startChangePos",
1831	    get: function get() {
1832	      return Math.min(this.cursorPos, this.oldSelection.start);
1833	    }
1834	    /**
1835	      Inserted symbols count
1836	      @readonly
1837	    */
1838
1839	  }, {
1840	    key: "insertedCount",
1841	    get: function get() {
1842	      return this.cursorPos - this.startChangePos;
1843	    }
1844	    /**
1845	      Inserted symbols
1846	      @readonly
1847	    */
1848
1849	  }, {
1850	    key: "inserted",
1851	    get: function get() {
1852	      return this.value.substr(this.startChangePos, this.insertedCount);
1853	    }
1854	    /**
1855	      Removed symbols count
1856	      @readonly
1857	    */
1858
1859	  }, {
1860	    key: "removedCount",
1861	    get: function get() {
1862	      // Math.max for opposite operation
1863	      return Math.max(this.oldSelection.end - this.startChangePos || // for Delete
1864	      this.oldValue.length - this.value.length, 0);
1865	    }
1866	    /**
1867	      Removed symbols
1868	      @readonly
1869	    */
1870
1871	  }, {
1872	    key: "removed",
1873	    get: function get() {
1874	      return this.oldValue.substr(this.startChangePos, this.removedCount);
1875	    }
1876	    /**
1877	      Unchanged head symbols
1878	      @readonly
1879	    */
1880
1881	  }, {
1882	    key: "head",
1883	    get: function get() {
1884	      return this.value.substring(0, this.startChangePos);
1885	    }
1886	    /**
1887	      Unchanged tail symbols
1888	      @readonly
1889	    */
1890
1891	  }, {
1892	    key: "tail",
1893	    get: function get() {
1894	      return this.value.substring(this.startChangePos + this.insertedCount);
1895	    }
1896	    /**
1897	      Remove direction
1898	      @readonly
1899	    */
1900
1901	  }, {
1902	    key: "removeDirection",
1903	    get: function get() {
1904	      if (!this.removedCount || this.insertedCount) return DIRECTION.NONE; // align right if delete at right
1905
1906	      return (this.oldSelection.end === this.cursorPos || this.oldSelection.start === this.cursorPos) && // if not range removed (event with backspace)
1907	      this.oldSelection.end === this.oldSelection.start ? DIRECTION.RIGHT : DIRECTION.LEFT;
1908	    }
1909	  }]);
1910
1911	  return ActionDetails;
1912	}();
1913
1914	/** Provides details of continuous extracted tail */
1915	var ContinuousTailDetails = /*#__PURE__*/function () {
1916	  /** Tail value as string */
1917
1918	  /** Tail start position */
1919
1920	  /** Start position */
1921	  function ContinuousTailDetails() {
1922	    var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
1923	    var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
1924	    var stop = arguments.length > 2 ? arguments[2] : undefined;
1925
1926	    _classCallCheck(this, ContinuousTailDetails);
1927
1928	    this.value = value;
1929	    this.from = from;
1930	    this.stop = stop;
1931	  }
1932
1933	  _createClass(ContinuousTailDetails, [{
1934	    key: "toString",
1935	    value: function toString() {
1936	      return this.value;
1937	    }
1938	  }, {
1939	    key: "extend",
1940	    value: function extend(tail) {
1941	      this.value += String(tail);
1942	    }
1943	  }, {
1944	    key: "appendTo",
1945	    value: function appendTo(masked) {
1946	      return masked.append(this.toString(), {
1947	        tail: true
1948	      }).aggregate(masked._appendPlaceholder());
1949	    }
1950	  }, {
1951	    key: "state",
1952	    get: function get() {
1953	      return {
1954	        value: this.value,
1955	        from: this.from,
1956	        stop: this.stop
1957	      };
1958	    },
1959	    set: function set(state) {
1960	      Object.assign(this, state);
1961	    }
1962	  }, {
1963	    key: "unshift",
1964	    value: function unshift(beforePos) {
1965	      if (!this.value.length || beforePos != null && this.from >= beforePos) return '';
1966	      var shiftChar = this.value[0];
1967	      this.value = this.value.slice(1);
1968	      return shiftChar;
1969	    }
1970	  }, {
1971	    key: "shift",
1972	    value: function shift() {
1973	      if (!this.value.length) return '';
1974	      var shiftChar = this.value[this.value.length - 1];
1975	      this.value = this.value.slice(0, -1);
1976	      return shiftChar;
1977	    }
1978	  }]);
1979
1980	  return ContinuousTailDetails;
1981	}();
1982
1983	/**
1984	 * Applies mask on element.
1985	 * @constructor
1986	 * @param {HTMLInputElement|HTMLTextAreaElement|MaskElement} el - Element to apply mask
1987	 * @param {Object} opts - Custom mask options
1988	 * @return {InputMask}
1989	 */
1990	function IMask(el) {
1991	  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1992	  // currently available only for input-like elements
1993	  return new IMask.InputMask(el, opts);
1994	}
1995
1996	/** Supported mask type */
1997
1998	/** Provides common masking stuff */
1999	var Masked = /*#__PURE__*/function () {
2000	  // $Shape<MaskedOptions>; TODO after fix https://github.com/facebook/flow/issues/4773
2001
2002	  /** @type {Mask} */
2003
2004	  /** */
2005	  // $FlowFixMe no ideas
2006
2007	  /** Transforms value before mask processing */
2008
2009	  /** Validates if value is acceptable */
2010
2011	  /** Does additional processing in the end of editing */
2012
2013	  /** Format typed value to string */
2014
2015	  /** Parse strgin to get typed value */
2016
2017	  /** Enable characters overwriting */
2018
2019	  /** */
2020
2021	  /** */
2022	  function Masked(opts) {
2023	    _classCallCheck(this, Masked);
2024
2025	    this._value = '';
2026
2027	    this._update(Object.assign({}, Masked.DEFAULTS, opts));
2028
2029	    this.isInitialized = true;
2030	  }
2031	  /** Sets and applies new options */
2032
2033
2034	  _createClass(Masked, [{
2035	    key: "updateOptions",
2036	    value: function updateOptions(opts) {
2037	      if (!Object.keys(opts).length) return; // $FlowFixMe
2038
2039	      this.withValueRefresh(this._update.bind(this, opts));
2040	    }
2041	    /**
2042	      Sets new options
2043	      @protected
2044	    */
2045
2046	  }, {
2047	    key: "_update",
2048	    value: function _update(opts) {
2049	      Object.assign(this, opts);
2050	    }
2051	    /** Mask state */
2052
2053	  }, {
2054	    key: "state",
2055	    get: function get() {
2056	      return {
2057	        _value: this.value
2058	      };
2059	    },
2060	    set: function set(state) {
2061	      this._value = state._value;
2062	    }
2063	    /** Resets value */
2064
2065	  }, {
2066	    key: "reset",
2067	    value: function reset() {
2068	      this._value = '';
2069	    }
2070	    /** */
2071
2072	  }, {
2073	    key: "value",
2074	    get: function get() {
2075	      return this._value;
2076	    },
2077	    set: function set(value) {
2078	      this.resolve(value);
2079	    }
2080	    /** Resolve new value */
2081
2082	  }, {
2083	    key: "resolve",
2084	    value: function resolve(value) {
2085	      this.reset();
2086	      this.append(value, {
2087	        input: true
2088	      }, '');
2089	      this.doCommit();
2090	      return this.value;
2091	    }
2092	    /** */
2093
2094	  }, {
2095	    key: "unmaskedValue",
2096	    get: function get() {
2097	      return this.value;
2098	    },
2099	    set: function set(value) {
2100	      this.reset();
2101	      this.append(value, {}, '');
2102	      this.doCommit();
2103	    }
2104	    /** */
2105
2106	  }, {
2107	    key: "typedValue",
2108	    get: function get() {
2109	      return this.doParse(this.value);
2110	    },
2111	    set: function set(value) {
2112	      this.value = this.doFormat(value);
2113	    }
2114	    /** Value that includes raw user input */
2115
2116	  }, {
2117	    key: "rawInputValue",
2118	    get: function get() {
2119	      return this.extractInput(0, this.value.length, {
2120	        raw: true
2121	      });
2122	    },
2123	    set: function set(value) {
2124	      this.reset();
2125	      this.append(value, {
2126	        raw: true
2127	      }, '');
2128	      this.doCommit();
2129	    }
2130	    /** */
2131
2132	  }, {
2133	    key: "isComplete",
2134	    get: function get() {
2135	      return true;
2136	    }
2137	    /** */
2138
2139	  }, {
2140	    key: "isFilled",
2141	    get: function get() {
2142	      return this.isComplete;
2143	    }
2144	    /** Finds nearest input position in direction */
2145
2146	  }, {
2147	    key: "nearestInputPos",
2148	    value: function nearestInputPos(cursorPos, direction) {
2149	      return cursorPos;
2150	    }
2151	    /** Extracts value in range considering flags */
2152
2153	  }, {
2154	    key: "extractInput",
2155	    value: function extractInput() {
2156	      var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
2157	      var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;
2158	      return this.value.slice(fromPos, toPos);
2159	    }
2160	    /** Extracts tail in range */
2161
2162	  }, {
2163	    key: "extractTail",
2164	    value: function extractTail() {
2165	      var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
2166	      var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;
2167	      return new ContinuousTailDetails(this.extractInput(fromPos, toPos), fromPos);
2168	    }
2169	    /** Appends tail */
2170	    // $FlowFixMe no ideas
2171
2172	  }, {
2173	    key: "appendTail",
2174	    value: function appendTail(tail) {
2175	      if (isString(tail)) tail = new ContinuousTailDetails(String(tail));
2176	      return tail.appendTo(this);
2177	    }
2178	    /** Appends char */
2179
2180	  }, {
2181	    key: "_appendCharRaw",
2182	    value: function _appendCharRaw(ch) {
2183	      if (!ch) return new ChangeDetails();
2184	      this._value += ch;
2185	      return new ChangeDetails({
2186	        inserted: ch,
2187	        rawInserted: ch
2188	      });
2189	    }
2190	    /** Appends char */
2191
2192	  }, {
2193	    key: "_appendChar",
2194	    value: function _appendChar(ch) {
2195	      var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
2196	      var checkTail = arguments.length > 2 ? arguments[2] : undefined;
2197	      var consistentState = this.state;
2198	      var details;
2199
2200	      var _normalizePrepare = normalizePrepare(this.doPrepare(ch, flags));
2201
2202	      var _normalizePrepare2 = _slicedToArray(_normalizePrepare, 2);
2203
2204	      ch = _normalizePrepare2[0];
2205	      details = _normalizePrepare2[1];
2206	      details = details.aggregate(this._appendCharRaw(ch, flags));
2207
2208	      if (details.inserted) {
2209	        var consistentTail;
2210	        var appended = this.doValidate(flags) !== false;
2211
2212	        if (appended && checkTail != null) {
2213	          // validation ok, check tail
2214	          var beforeTailState = this.state;
2215
2216	          if (this.overwrite === true) {
2217	            consistentTail = checkTail.state;
2218	            checkTail.unshift(this.value.length);
2219	          }
2220
2221	          var tailDetails = this.appendTail(checkTail);
2222	          appended = tailDetails.rawInserted === checkTail.toString(); // not ok, try shift
2223
2224	          if (!(appended && tailDetails.inserted) && this.overwrite === 'shift') {
2225	            this.state = beforeTailState;
2226	            consistentTail = checkTail.state;
2227	            checkTail.shift();
2228	            tailDetails = this.appendTail(checkTail);
2229	            appended = tailDetails.rawInserted === checkTail.toString();
2230	          } // if ok, rollback state after tail
2231
2232
2233	          if (appended && tailDetails.inserted) this.state = beforeTailState;
2234	        } // revert all if something went wrong
2235
2236
2237	        if (!appended) {
2238	          details = new ChangeDetails();
2239	          this.state = consistentState;
2240	          if (checkTail && consistentTail) checkTail.state = consistentTail;
2241	        }
2242	      }
2243
2244	      return details;
2245	    }
2246	    /** Appends optional placeholder at end */
2247
2248	  }, {
2249	    key: "_appendPlaceholder",
2250	    value: function _appendPlaceholder() {
2251	      return new ChangeDetails();
2252	    }
2253	    /** Appends optional eager placeholder at end */
2254
2255	  }, {
2256	    key: "_appendEager",
2257	    value: function _appendEager() {
2258	      return new ChangeDetails();
2259	    }
2260	    /** Appends symbols considering flags */
2261	    // $FlowFixMe no ideas
2262
2263	  }, {
2264	    key: "append",
2265	    value: function append(str, flags, tail) {
2266	      if (!isString(str)) throw new Error('value should be string');
2267	      var details = new ChangeDetails();
2268	      var checkTail = isString(tail) ? new ContinuousTailDetails(String(tail)) : tail;
2269	      if (flags && flags.tail) flags._beforeTailState = this.state;
2270
2271	      for (var ci = 0; ci < str.length; ++ci) {
2272	        details.aggregate(this._appendChar(str[ci], flags, checkTail));
2273	      } // append tail but aggregate only tailShift
2274
2275
2276	      if (checkTail != null) {
2277	        details.tailShift += this.appendTail(checkTail).tailShift; // TODO it's a good idea to clear state after appending ends
2278	        // but it causes bugs when one append calls another (when dynamic dispatch set rawInputValue)
2279	        // this._resetBeforeTailState();
2280	      }
2281
2282	      if (this.eager && flags !== null && flags !== void 0 && flags.input && str) {
2283	        details.aggregate(this._appendEager());
2284	      }
2285
2286	      return details;
2287	    }
2288	    /** */
2289
2290	  }, {
2291	    key: "remove",
2292	    value: function remove() {
2293	      var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
2294	      var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;
2295	      this._value = this.value.slice(0, fromPos) + this.value.slice(toPos);
2296	      return new ChangeDetails();
2297	    }
2298	    /** Calls function and reapplies current value */
2299
2300	  }, {
2301	    key: "withValueRefresh",
2302	    value: function withValueRefresh(fn) {
2303	      if (this._refreshing || !this.isInitialized) return fn();
2304	      this._refreshing = true;
2305	      var rawInput = this.rawInputValue;
2306	      var value = this.value;
2307	      var ret = fn();
2308	      this.rawInputValue = rawInput; // append lost trailing chars at end
2309
2310	      if (this.value && this.value !== value && value.indexOf(this.value) === 0) {
2311	        this.append(value.slice(this.value.length), {}, '');
2312	      }
2313
2314	      delete this._refreshing;
2315	      return ret;
2316	    }
2317	    /** */
2318
2319	  }, {
2320	    key: "runIsolated",
2321	    value: function runIsolated(fn) {
2322	      if (this._isolated || !this.isInitialized) return fn(this);
2323	      this._isolated = true;
2324	      var state = this.state;
2325	      var ret = fn(this);
2326	      this.state = state;
2327	      delete this._isolated;
2328	      return ret;
2329	    }
2330	    /**
2331	      Prepares string before mask processing
2332	      @protected
2333	    */
2334
2335	  }, {
2336	    key: "doPrepare",
2337	    value: function doPrepare(str) {
2338	      var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
2339	      return this.prepare ? this.prepare(str, this, flags) : str;
2340	    }
2341	    /**
2342	      Validates if value is acceptable
2343	      @protected
2344	    */
2345
2346	  }, {
2347	    key: "doValidate",
2348	    value: function doValidate(flags) {
2349	      return (!this.validate || this.validate(this.value, this, flags)) && (!this.parent || this.parent.doValidate(flags));
2350	    }
2351	    /**
2352	      Does additional processing in the end of editing
2353	      @protected
2354	    */
2355
2356	  }, {
2357	    key: "doCommit",
2358	    value: function doCommit() {
2359	      if (this.commit) this.commit(this.value, this);
2360	    }
2361	    /** */
2362
2363	  }, {
2364	    key: "doFormat",
2365	    value: function doFormat(value) {
2366	      return this.format ? this.format(value, this) : value;
2367	    }
2368	    /** */
2369
2370	  }, {
2371	    key: "doParse",
2372	    value: function doParse(str) {
2373	      return this.parse ? this.parse(str, this) : str;
2374	    }
2375	    /** */
2376
2377	  }, {
2378	    key: "splice",
2379	    value: function splice(start, deleteCount, inserted, removeDirection) {
2380	      var tailPos = start + deleteCount;
2381	      var tail = this.extractTail(tailPos);
2382	      var oldRawValue;
2383
2384	      if (this.eager) {
2385	        removeDirection = forceDirection(removeDirection);
2386	        oldRawValue = this.extractInput(0, tailPos, {
2387	          raw: true
2388	        });
2389	      }
2390
2391	      var startChangePos = this.nearestInputPos(start, deleteCount > 1 && start !== 0 && !this.eager ? DIRECTION.NONE : removeDirection);
2392	      var details = new ChangeDetails({
2393	        tailShift: startChangePos - start // adjust tailShift if start was aligned
2394
2395	      }).aggregate(this.remove(startChangePos));
2396
2397	      if (this.eager && removeDirection !== DIRECTION.NONE && oldRawValue === this.rawInputValue) {
2398	        if (removeDirection === DIRECTION.FORCE_LEFT) {
2399	          var valLength;
2400
2401	          while (oldRawValue === this.rawInputValue && (valLength = this.value.length)) {
2402	            details.aggregate(new ChangeDetails({
2403	              tailShift: -1
2404	            })).aggregate(this.remove(valLength - 1));
2405	          }
2406	        } else if (removeDirection === DIRECTION.FORCE_RIGHT) {
2407	          tail.unshift();
2408	        }
2409	      }
2410
2411	      return details.aggregate(this.append(inserted, {
2412	        input: true
2413	      }, tail));
2414	    }
2415	  }, {
2416	    key: "maskEquals",
2417	    value: function maskEquals(mask) {
2418	      return this.mask === mask;
2419	    }
2420	  }]);
2421
2422	  return Masked;
2423	}();
2424	Masked.DEFAULTS = {
2425	  format: function format(v) {
2426	    

2426return v;
2427	  },
2428	  parse: function parse(v) {
2429	    return v;
2430	  }
2431	};
2432	IMask.Masked = Masked;
2433
2434	/** Get Masked class by mask type */
2435
2436	function maskedClass(mask) {
2437	  if (mask == null) {
2438	    throw new Error('mask property should be defined');
2439	  } // $FlowFixMe
2440
2441
2442	  if (mask instanceof RegExp) return IMask.MaskedRegExp; // $FlowFixMe
2443
2444	  if (isString(mask)) return IMask.MaskedPattern; // $FlowFixMe
2445
2446	  if (mask instanceof Date || mask === Date) return IMask.MaskedDate; // $FlowFixMe
2447
2448	  if (mask instanceof Number || typeof mask === 'number' || mask === Number) return IMask.MaskedNumber; // $FlowFixMe
2449
2450	  if (Array.isArray(mask) || mask === Array) return IMask.MaskedDynamic; // $FlowFixMe
2451
2452	  if (IMask.Masked && mask.prototype instanceof IMask.Masked) return mask; // $FlowFixMe
2453
2454	  if (mask instanceof IMask.Masked) return mask.constructor; // $FlowFixMe
2455
2456	  if (mask instanceof Function) return IMask.MaskedFunction;
2457	  console.warn('Mask not found for mask', mask); // eslint-disable-line no-console
2458	  // $FlowFixMe
2459
2460	  return IMask.Masked;
2461	}
2462	/** Creates new {@link Masked} depending on mask type */
2463
2464	function createMask(opts) {
2465	  // $FlowFixMe
2466	  if (IMask.Masked && opts instanceof IMask.Masked) return opts;
2467	  opts = Object.assign({}, opts);
2468	  var mask = opts.mask; // $FlowFixMe
2469
2470	  if (IMask.Masked && mask instanceof IMask.Masked) return mask;
2471	  var MaskedClass = maskedClass(mask);
2472	  if (!MaskedClass) throw new Error('Masked class is not found for provided mask, appropriate module needs to be import manually before creating mask.');
2473	  return new MaskedClass(opts);
2474	}
2475	IMask.createMask = createMask;
2476
2477	var _excluded$4 = ["mask"];
2478	var DEFAULT_INPUT_DEFINITIONS = {
2479	  '0': /\d/,
2480	  'a': /[\u0041-\u005A\u0061-\u007A\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFB

2480D3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/,
2481	  // http://stackoverflow.com/a/22075070
2482	  '*': /./
2483	};
2484	/** */
2485
2486	var PatternInputDefinition = /*#__PURE__*/function () {
2487	  /** */
2488
2489	  /** */
2490
2491	  /** */
2492
2493	  /** */
2494
2495	  /** */
2496
2497	  /** */
2498
2499	  /** */
2500	  function PatternInputDefinition(opts) {
2501	    _classCallCheck(this, PatternInputDefinition);
2502
2503	    var mask = opts.mask,
2504	        blockOpts = _objectWithoutProperties(opts, _excluded$4);
2505
2506	    this.masked = createMask({
2507	      mask: mask
2508	    });
2509	    Object.assign(this, blockOpts);
2510	  }
2511
2512	  _createClass(PatternInputDefinition, [{
2513	    key: "reset",
2514	    value: function reset() {
2515	      this.isFilled = false;
2516	      this.masked.reset();
2517	    }
2518	  }, {
2519	    key: "remove",
2520	    value: function remove() {
2521	      var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
2522	      var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;
2523
2524	      if (fromPos === 0 && toPos >= 1) {
2525	        this.isFilled = false;
2526	        return this.masked.remove(fromPos, toPos);
2527	      }
2528
2529	      return new ChangeDetails();
2530	    }
2531	  }, {
2532	    key: "value",
2533	    get: function get() {
2534	      return this.masked.value || (this.isFilled && !this.isOptional ? this.placeholderChar : '');
2535	    }
2536	  }, {
2537	    key: "unmaskedValue",
2538	    get: function get() {
2539	      return this.masked.unmaskedValue;
2540	    }
2541	  }, {
2542	    key: "isComplete",
2543	    get: function get() {
2544	      return Boolean(this.masked.value) || this.isOptional;
2545	    }
2546	  }, {
2547	    key: "_appendChar",
2548	    value: function _appendChar(ch) {
2549	      var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
2550	      if (this.isFilled) return new ChangeDetails();
2551	      var state = this.masked.state; // simulate input
2552
2553	      var details = this.masked._appendChar(ch, flags);
2554
2555	      if (details.inserted && this.doValidate(flags) === false) {
2556	        details.inserted = details.rawInserted = '';
2557	        this.masked.state = state;
2558	      }
2559
2560	      if (!details.inserted && !this.isOptional && !this.lazy && !flags.input) {
2561	        details.inserted = this.placeholderChar;
2562	      }
2563
2564	      details.skip = !details.inserted && !this.isOptional;
2565	      this.isFilled = Boolean(details.inserted);
2566	      return details;
2567	    }
2568	  }, {
2569	    key: "append",
2570	    value: function append() {
2571	      var _this$masked;
2572
2573	      // TODO probably should be done via _appendChar
2574	      return (_this$masked = this.masked).append.apply(_this$masked, arguments);
2575	    }
2576	  }, {
2577	    key: "_appendPlaceholder",
2578	    value: function _appendPlaceholder() {
2579	      var details = new ChangeDetails();
2580	      if (this.isFilled || this.isOptional) return details;
2581	      this.isFilled = true;
2582	      details.inserted = this.placeholderChar;
2583	      return details;
2584	    }
2585	  }, {
2586	    key: "_appendEager",
2587	    value: function _appendEager() {
2588	      return new ChangeDetails();
2589	    }
2590	  }, {
2591	    key: "extractTail",
2592	    value: function extractTail() {
2593	      var _this$masked2;
2594
2595	      return (_this$masked2 = this.masked).extractTail.apply(_this$masked2, arguments);
2596	    }
2597	  }, {
2598	    key: "appendTail",
2599	    value: function appendTail() {
2600	      var _this$masked3;
2601
2602	      return (_this$masked3 = this.masked).appendTail.apply(_this$masked3, arguments);
2603	    }
2604	  }, {
2605	    key: "extractInput",
2606	    value: function extractInput() {
2607	      var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
2608	      var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;
2609	      var flags = arguments.length > 2 ? arguments[2] : undefined;
2610	      return this.masked.extractInput(fromPos, toPos, flags);
2611	    }
2612	  }, {
2613	    key: "nearestInputPos",
2614	    value: function nearestInputPos(cursorPos) {
2615	      var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DIRECTION.NONE;
2616	      var minPos = 0;
2617	      var maxPos = this.value.length;
2618	      var boundPos = Math.min(Math.max(cursorPos, minPos), maxPos);
2619
2620	      switch (direction) {
2621	        case DIRECTION.LEFT:
2622	        case DIRECTION.FORCE_LEFT:
2623	          return this.isComplete ? boundPos : minPos;
2624
2625	        case DIRECTION.RIGHT:
2626	        case DIRECTION.FORCE_RIGHT:
2627	          return this.isComplete ? boundPos : maxPos;
2628
2629	        case DIRECTION.NONE:
2630	        default:
2631	          return boundPos;
2632	      }
2633	    }
2634	  }, {
2635	    key: "doValidate",
2636	    value: function doValidate() {
2637	      var _this$masked4, _this$parent;
2638
2639	      return (_this$masked4 = this.masked).doValidate.apply(_this$masked4, arguments) && (!this.parent || (_this$parent = this.parent).doValidate.apply(_this$parent, arguments));
2640	    }
2641	  }, {
2642	    key: "doCommit",
2643	    value: function doCommit() {
2644	      this.masked.doCommit();
2645	    }
2646	  }, {
2647	    key: "state",
2648	    get: function get() {
2649	      return {
2650	        masked: this.masked.state,
2651	        isFilled: this.isFilled
2652	      };
2653	    },
2654	    set: function set(state) {
2655	      this.masked.state = state.masked;
2656	      this.isFilled = state.isFilled;
2657	    }
2658	  }]);
2659
2660	  return PatternInputDefinition;
2661	}();
2662
2663	var PatternFixedDefinition = /*#__PURE__*/function () {
2664	  /** */
2665
2666	  /** */
2667
2668	  /** */
2669
2670	  /** */
2671
2672	  /** */
2673
2674	  /** */
2675	  function PatternFixedDefinition(opts) {
2676	    _classCallCheck(this, PatternFixedDefinition);
2677
2678	    Object.assign(this, opts);
2679	    this._value = '';
2680	    this.isFixed = true;
2681	  }
2682
2683	  _createClass(PatternFixedDefinition, [{
2684	    key: "value",
2685	    get: function get() {
2686	      return this._value;
2687	    }
2688	  }, {
2689	    key: "unmaskedValue",
2690	    get: function get() {
2691	      return this.isUnmasking ? this.value : '';
2692	    }
2693	  }, {
2694	    key: "reset",
2695	    value: function reset() {
2696	      this._isRawInput = false;