vendor: 6,057 bytes, lines 1-190
1(function webpackUniversalModuleDefinition(root, factory) { 2 if(typeof exports === 'object' && typeof module === 'object') 3 module.exports = factory(); 4 else if(typeof define === 'function' && define.amd) 5 define([], factory); 6 else if(typeof exports === 'object') 7 exports["Cleave"] = factory(); 8 else 9 root["Cleave"] = factory(); 10})(this, function() { 11return /******/ (function(modules) { // webpackBootstrap 12/******/ // The module cache 13/******/ var installedModules = {}; 14 15/******/ // The require function 16/******/ function __webpack_require__(moduleId) { 17 18/******/ // Check if module is in cache 19/******/ if(installedModules[moduleId]) 20/******/ return installedModules[moduleId].exports; 21 22/******/ // Create a new module (and put it into the cache) 23/******/ var module = installedModules[moduleId] = { 24/******/ exports: {}, 25/******/ id: moduleId, 26/******/ loaded: false 27/******/ }; 28 29/******/ // Execute the module function 30/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 31 32/******/ // Flag the module as loaded 33/******/ module.loaded = true; 34 35/******/ // Return the exports of the module 36/******/ return module.exports; 37/******/ } 38 39 40/******/ // expose the modules object (__webpack_modules__) 41/******/ __webpack_require__.m = modules; 42 43/******/ // expose the module cache 44/******/ __webpack_require__.c = installedModules; 45 46/******/ // __webpack_public_path__ 47/******/ __webpack_require__.p = ""; 48 49/******/ // Load entry module and return exports 50/******/ return __webpack_require__(0); 51/******/ }) 52/************************************************************************/ 53/******/ ([ 54/* 0 */ 55/***/ (function(module, exports, __webpack_require__) { 56 57 /* WEBPACK VAR INJECTION */(function(global) {'use strict'; 58 59 /** 60 * Construct a new Cleave instance by passing the configuration object 61 * 62 * @param {String | HTMLElement} element 63 * @param {Object} opts 64 */ 65 var Cleave = function (element, opts) { 66 var owner = this; 67 68 if (typeof element === 'string') { 69 owner.element = document.querySelector(element); 70 } else { 71 owner.element = ((typeof element.length !== 'undefined') && element.length > 0) ? element[0] : element; 72 } 73 74 if (!owner.element) { 75 throw new Error('[cleave.js] Please check the element'); 76 } 77 78 opts.initValue = owner.element.value; 79 80 owner.properties = Cleave.DefaultProperties.assign({}, opts); 81 82 owner.init(); 83 }; 84 85 Cleave.prototype = { 86 init: function () { 87 var owner = this, pps = owner.properties; 88 89 // no need to use this lib 90 if (!pps.numeral && !pps.phone && !pps.creditCard && !pps.time && !pps.date && (pps.blocksLength === 0 && !pps.prefix)) { 91 owner.onInput(pps.initValue); 92 93 return; 94 } 95 96 pps.maxLength = Cleave.Util.getMaxLength(pps.blocks); 97 98 owner.isAndroid = Cleave.Util.isAndroid(); 99 owner.lastInputValue = ''; 100 101 owner.onChangeListener = owner.onChange.bind(owner); 102 owner.onKeyDownListener = owner.onKeyDown.bind(owner); 103 owner.onFocusListener = owner.onFocus.bind(owner); 104 owner.onCutListener = owner.onCut.bind(owner); 105 owner.onCopyListener = owner.onCopy.bind(owner); 106 107 owner.element.addEventListener('input', owner.onChangeListener); 108 owner.element.addEventListener('keydown', owner.onKeyDownListener); 109 owner.element.addEventListener('focus', owner.onFocusListener); 110 owner.element.addEventListener('cut', owner.onCutListener); 111 owner.element.addEventListener('copy', owner.onCopyListener); 112 113 114 owner.initPhoneFormatter(); 115 owner.initDateFormatter(); 116 owner.initTimeFormatter(); 117 owner.initNumeralFormatter(); 118 119 // avoid touch input field if value is null 120 // otherwise Firefox will add red box-shadow for <input required /> 121 if (pps.initValue || (pps.prefix && !pps.noImmediatePrefix)) { 122 owner.onInput(pps.initValue); 123 } 124 }, 125 126 initNumeralFormatter: function () { 127 var owner = this, pps = owner.properties; 128 129 if (!pps.numeral) { 130 return; 131 } 132 133 pps.numeralFormatter = new Cleave.NumeralFormatter( 134 pps.numeralDecimalMark, 135 pps.numeralIntegerScale, 136 pps.numeralDecimalScale, 137 pps.numeralThousandsGroupStyle, 138 pps.numeralPositiveOnly, 139 pps.stripLeadingZeroes, 140 pps.delimiter 141 ); 142 }, 143 144 initTimeFormatter: function() { 145 var owner = this, pps = owner.properties; 146 147 if (!pps.time) { 148 return; 149 } 150 151 pps.timeFormatter = new Cleave.TimeFormatter(pps.timePattern, pps.timeFormat); 152 pps.blocks = pps.timeFormatter.getBlocks(); 153 pps.blocksLength = pps.blocks.length; 154 pps.maxLength = Cleave.Util.getMaxLength(pps.blocks); 155 }, 156 157 initDateFormatter: function () { 158 var owner = this, pps = owner.properties; 159 160 if (!pps.date) { 161 return; 162 } 163 164 pps.dateFormatter = new Cleave.DateFormatter(pps.datePattern); 165 pps.blocks = pps.dateFormatter.getBlocks(); 166 pps.blocksLength = pps.blocks.length; 167 pps.maxLength = Cleave.Util.getMaxLength(pps.blocks); 168 }, 169 170 initPhoneFormatter: function () { 171 var owner = this, pps = owner.properties; 172 173 if (!pps.phone) { 174 return; 175 } 176 177 // Cleave.AsYouTypeFormatter should be provided by 178 // external google closure lib 179 try { 180 pps.phoneFormatter = new Cleave.PhoneFormatter( 181 new pps.root.Cleave.AsYouTypeFormatter(pps.phoneRegionCode), 182 pps.delimiter 183 ); 184 } catch (ex) { 185 throw new Error('[cleave.js] Please include phone-type-formatter.{country}.js lib'); 186 } 187 }, 188 189 onKeyDown: function (event) { 190 var owner = this, pps = owner.properties,
191 charCode = event.which || event.keyCode, 192 Util = Cleave.Util, 193 currentValue = owner.element.value; 194 195 // if we got any charCode === 8, this means, that this device correctly 196 // sends backspace keys in event, so we do not need to apply any hacks 197 owner.hasBackspaceSupport = owner.hasBackspaceSupport || charCode === 8; 198 if (!owner.hasBackspaceSupport 199 && Util.isAndroidBackspaceKeydown(owner.lastInputValue, currentValue) 200 ) { 201 charCode = 8; 202 } 203 204 owner.lastInputValue = currentValue; 205 206 // hit backspace when last character is delimiter 207 var postDelimiter = Util.getPostDelimiter(currentValue, pps.delimiter, pps.delimiters); 208 if (charCode === 8 && postDelimiter) { 209 pps.postDelimiterBackspace = postDelimiter; 210 } else { 211 pps.postDelimiterBackspace = false; 212 } 213 }, 214 215 onChange: function () { 216 this.onInput(this.element.value); 217 }, 218 219 onFocus: function () { 220 var owner = this, 221 pps = owner.properties; 222 223 Cleave.Util.fixPrefixCursor(owner.element, pps.prefix, pps.delimiter, pps.delimiters); 224 }, 225 226 onCut: function (e) { 227 this.copyClipboardData(e); 228 this.onInput(''); 229 }, 230 231 onCopy: function (e) { 232 this.copyClipboardData(e); 233 }, 234 235 copyClipboardData: function (e) { 236 var owner = this, 237 pps = owner.properties, 238 Util = Cleave.Util, 239 inputValue = owner.element.value, 240 textToCopy = ''; 241 242 if (!pps.copyDelimiter) { 243 textToCopy = Util.stripDelimiters(inputValue, pps.delimiter, pps.delimiters); 244 } else { 245 textToCopy = inputValue; 246 } 247 248 try { 249 if (e.clipboardData) { 250 e.clipboardData.setData('Text', textToCopy); 251 } else { 252 window.clipboardData.setData('Text', textToCopy); 253 } 254 255 e.preventDefault(); 256 } catch (ex) { 257 // empty 258 } 259 }, 260 261 onInput: function (value) { 262 var owner = this, pps = owner.properties, 263 Util = Cleave.Util; 264 265 // case 1: delete one more character "4" 266 // 1234*| -> hit backspace -> 123| 267 // case 2: last character is not delimiter which is: 268 // 12|34* -> hit backspace -> 1|34* 269 // note: no need to apply this for numeral mode 270 var postDelimiterAfter = Util.getPostDelimiter(value, pps.delimiter, pps.delimiters); 271 if (!pps.numeral && pps.postDelimiterBackspace && !postDelimiterAfter) { 272 value = Util.headStr(value, value.length - pps.postDelimiterBackspace.length); 273 } 274 275 // phone formatter 276 if (pps.phone) { 277 if (pps.prefix && (!pps.noImmediatePrefix || value.length)) { 278 pps.result = pps.prefix + pps.phoneFormatter.format(value).slice(pps.prefix.length); 279 } else { 280 pps.result = pps.phoneFormatter.format(value); 281 } 282 owner.updateValueState(); 283 284 return; 285 } 286 287 // numeral formatter 288 if (pps.numeral) { 289 if (pps.prefix && (!pps.noImmediatePrefix || value.length)) { 290 pps.result = pps.prefix + pps.numeralFormatter.format(value); 291 } else { 292 pps.result = pps.numeralFormatter.format(value); 293 } 294 owner.updateValueState(); 295 296 return; 297 } 298 299 // date 300 if (pps.date) { 301 value = pps.dateFormatter.getValidatedDate(value); 302 } 303 304 // time 305 if (pps.time) { 306 value = pps.timeFormatter.getValidatedTime(value); 307 } 308 309 // strip delimiters 310 value = Util.stripDelimiters(value, pps.delimiter, pps.delimiters); 311 312 // strip prefix 313 value = Util.getPrefixStrippedValue(value, pps.prefix, pps.prefixLength, pps.result); 314 315 // strip non-numeric characters 316 value = pps.numericOnly ? Util.strip(value, /[^\d]/g) : value; 317 318 // convert case 319 value = pps.uppercase ? value.toUpperCase() : value; 320 value = pps.lowercase ? value.toLowerCase() : value; 321 322 // prefix 323 if (pps.prefix && (!pps.noImmediatePrefix || value.length)) { 324 value = pps.prefix + value; 325 326 // no blocks specified, no need to do formatting 327 if (pps.blocksLength === 0) { 328 pps.result = value; 329 owner.updateValueState(); 330 331 return; 332 } 333 } 334 335 // update credit card props 336 if (pps.creditCard) { 337 owner.updateCreditCardPropsByValue(value); 338 } 339 340 // strip over length characters 341 value = Util.headStr(value, pps.maxLength); 342 343 // apply blocks 344 pps.result = Util.getFormattedValue( 345 value, 346 pps.blocks, pps.blocksLength, 347 pps.delimiter, pps.delimiters, pps.delimiterLazyShow 348 ); 349 350 owner.updateValueState(); 351 }, 352 353 updateCreditCardPropsByValue: function (value) { 354 var owner = this, pps = owner.properties, 355 Util = Cleave.Util, 356 creditCardInfo; 357 358 // At least one of the first 4 characters has changed 359 if (Util.headStr(pps.result, 4) === Util.headStr(value, 4)) { 360 return; 361 } 362 363 creditCardInfo = Cleave.CreditCardDetector.getInfo(value, pps.creditCardStrictMode); 364 365 pps.blocks = creditCardInfo.blocks; 366 pps.blocksLength = pps.blocks.length; 367 pps.maxLength = Util.getMaxLength(pps.blocks); 368 369 // credit card type changed
vendor: 4,247 bytes, lines 370-513
370 if (pps.creditCardType !== creditCardInfo.type) { 371 pps.creditCardType = creditCardInfo.type; 372 373 pps.onCreditCardTypeChanged.call(owner, pps.creditCardType); 374 } 375 }, 376 377 updateValueState: function () { 378 var owner = this, 379 Util = Cleave.Util, 380 pps = owner.properties; 381 382 if (!owner.element) { 383 return; 384 } 385 386 var endPos = owner.element.selectionEnd; 387 var oldValue = owner.element.value; 388 var newValue = pps.result; 389 390 endPos = Util.getNextCursorPosition(endPos, oldValue, newValue, pps.delimiter, pps.delimiters); 391 392 // fix Android browser type="text" input field 393 // cursor not jumping issue 394 if (owner.isAndroid) { 395 window.setTimeout(function () { 396 owner.element.value = newValue; 397 Util.setSelection(owner.element, endPos, pps.document, false); 398 owner.callOnValueChanged(); 399 }, 1); 400 401 return; 402 } 403 404 owner.element.value = newValue; 405 Util.setSelection(owner.element, endPos, pps.document, false); 406 owner.callOnValueChanged(); 407 }, 408 409 callOnValueChanged: function () { 410 var owner = this, 411 pps = owner.properties; 412 413 pps.onValueChanged.call(owner, { 414 target: { 415 value: pps.result, 416 rawValue: owner.getRawValue() 417 } 418 }); 419 }, 420 421 setPhoneRegionCode: function (phoneRegionCode) { 422 var owner = this, pps = owner.properties; 423 424 pps.phoneRegionCode = phoneRegionCode; 425 owner.initPhoneFormatter(); 426 owner.onChange(); 427 }, 428 429 setRawValue: function (value) { 430 var owner = this, pps = owner.properties; 431 432 value = value !== undefined && value !== null ? value.toString() : ''; 433 434 if (pps.numeral) { 435 value = value.replace('.', pps.numeralDecimalMark); 436 } 437 438 pps.postDelimiterBackspace = false; 439 440 owner.element.value = value; 441 owner.onInput(value); 442 }, 443 444 getRawValue: function () { 445 var owner = this, 446 pps = owner.properties, 447 Util = Cleave.Util, 448 rawValue = owner.element.value; 449 450 if (pps.rawValueTrimPrefix) { 451 rawValue = Util.getPrefixStrippedValue(rawValue, pps.prefix, pps.prefixLength, pps.result); 452 } 453 454 if (pps.numeral) { 455 rawValue = pps.numeralFormatter.getRawValue(rawValue); 456 } else { 457 rawValue = Util.stripDelimiters(rawValue, pps.delimiter, pps.delimiters); 458 } 459 460 return rawValue; 461 }, 462 463 getISOFormatDate: function () { 464 var owner = this, 465 pps = owner.properties; 466 467 return pps.date ? pps.dateFormatter.getISOFormatDate() : ''; 468 }, 469 470 getISOFormatTime: function () { 471 var owner = this, 472 pps = owner.properties; 473 474 return pps.time ? pps.timeFormatter.getISOFormatTime() : ''; 475 }, 476 477 getFormattedValue: function () { 478 return this.element.value; 479 }, 480 481 destroy: function () { 482 var owner = this; 483 484 owner.element.removeEventListener('input', owner.onChangeListener); 485 owner.element.removeEventListener('keydown', owner.onKeyDownListener); 486 owner.element.removeEventListener('focus', owner.onFocusListener); 487 owner.element.removeEventListener('cut', owner.onCutListener); 488 owner.element.removeEventListener('copy', owner.onCopyListener); 489 }, 490 491 toString: function () { 492 return '[Cleave Object]'; 493 } 494 }; 495 496 Cleave.NumeralFormatter = __webpack_require__(1); 497 Cleave.DateFormatter = __webpack_require__(2); 498 Cleave.TimeFormatter = __webpack_require__(3); 499 Cleave.PhoneFormatter = __webpack_require__(4); 500 Cleave.CreditCardDetector = __webpack_require__(5); 501 Cleave.Util = __webpack_require__(6); 502 Cleave.DefaultProperties = __webpack_require__(7); 503 504 // for angular directive 505 ((typeof global === 'object' && global) ? global : window)['Cleave'] = Cleave; 506 507 // CommonJS 508 module.exports = Cleave; 509 510 /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) 511 512/***/ }), 513/* 1 */
vendor: 9,076 bytes, lines 514-783
514/***/ (function(module, exports) { 515 516 'use strict'; 517 518 var NumeralFormatter = function (numeralDecimalMark, 519 numeralIntegerScale, 520 numeralDecimalScale, 521 numeralThousandsGroupStyle, 522 numeralPositiveOnly, 523 stripLeadingZeroes, 524 delimiter) { 525 var owner = this; 526 527 owner.numeralDecimalMark = numeralDecimalMark || '.'; 528 owner.numeralIntegerScale = numeralIntegerScale > 0 ? numeralIntegerScale : 0; 529 owner.numeralDecimalScale = numeralDecimalScale >= 0 ? numeralDecimalScale : 2; 530 owner.numeralThousandsGroupStyle = numeralThousandsGroupStyle || NumeralFormatter.groupStyle.thousand; 531 owner.numeralPositiveOnly = !!numeralPositiveOnly; 532 owner.stripLeadingZeroes = stripLeadingZeroes !== false; 533 owner.delimiter = (delimiter || delimiter === '') ? delimiter : ','; 534 owner.delimiterRE = delimiter ? new RegExp('\\' + delimiter, 'g') : ''; 535 }; 536 537 NumeralFormatter.groupStyle = { 538 thousand: 'thousand', 539 lakh: 'lakh', 540 wan: 'wan', 541 none: 'none' 542 }; 543 544 NumeralFormatter.prototype = { 545 getRawValue: function (value) { 546 return value.replace(this.delimiterRE, '').replace(this.numeralDecimalMark, '.'); 547 }, 548 549 format: function (value) { 550 var owner = this, parts, partInteger, partDecimal = ''; 551 552 // strip alphabet letters 553 value = value.replace(/[A-Za-z]/g, '') 554 // replace the first decimal mark with reserved placeholder 555 .replace(owner.numeralDecimalMark, 'M') 556 557 // strip non numeric letters except minus and "M" 558 // this is to ensure prefix has been stripped 559 .replace(/[^\dM-]/g, '') 560 561 // replace the leading minus with reserved placeholder 562 .replace(/^\-/, 'N') 563 564 // strip the other minus sign (if present) 565 .replace(/\-/g, '') 566 567 // replace the minus sign (if present) 568 .replace('N', owner.numeralPositiveOnly ? '' : '-') 569 570 // replace decimal mark 571 .replace('M', owner.numeralDecimalMark); 572 573 // strip any leading zeros 574 if (owner.stripLeadingZeroes) { 575 value = value.replace(/^(-)?0+(?=\d)/, '$1'); 576 } 577 578 partInteger = value; 579 580 if (value.indexOf(owner.numeralDecimalMark) >= 0) { 581 parts = value.split(owner.numeralDecimalMark); 582 partInteger = parts[0]; 583 partDecimal = owner.numeralDecimalMark + parts[1].slice(0, owner.numeralDecimalScale); 584 } 585 586 if (owner.numeralIntegerScale > 0) { 587 partInteger = partInteger.slice(0, owner.numeralIntegerScale + (value.slice(0, 1) === '-' ? 1 : 0)); 588 } 589 590 switch (owner.numeralThousandsGroupStyle) { 591 case NumeralFormatter.groupStyle.lakh: 592 partInteger = partInteger.replace(/(\d)(?=(\d\d)+\d$)/g, '$1' + owner.delimiter); 593 594 break; 595 596 case NumeralFormatter.groupStyle.wan: 597 partInteger = partInteger.replace(/(\d)(?=(\d{4})+$)/g, '$1' + owner.delimiter); 598 599 break; 600 601 case NumeralFormatter.groupStyle.thousand: 602 partInteger = partInteger.replace(/(\d)(?=(\d{3})+$)/g, '$1' + owner.delimiter); 603 604 break; 605 } 606 607 return partInteger.toString() + (owner.numeralDecimalScale > 0 ? partDecimal.toString() : ''); 608 } 609 }; 610 611 module.exports = NumeralFormatter; 612 613 614/***/ }), 615/* 2 */ 616/***/ (function(module, exports) { 617 618 'use strict'; 619 620 var DateFormatter = function (datePattern) { 621 var owner = this; 622 623 owner.date = []; 624 owner.blocks = []; 625 owner.datePattern = datePattern; 626 owner.initBlocks(); 627 }; 628 629 DateFormatter.prototype = { 630 initBlocks: function () { 631 var owner = this; 632 owner.datePattern.forEach(function (value) { 633 if (value === 'Y') { 634 owner.blocks.push(4); 635 } else { 636 owner.blocks.push(2); 637 } 638 }); 639 }, 640 641 getISOFormatDate: function () { 642 var owner = this, 643 date = owner.date; 644 645 return date[2] ? ( 646 date[2] + '-' + owner.addLeadingZero(date[1]) + '-' + owner.addLeadingZero(date[0]) 647 ) : ''; 648 }, 649 650 getBlocks: function () { 651 return this.blocks; 652 }, 653 654 getValidatedDate: function (value) { 655 var owner = this, result = ''; 656 657 value = value.replace(/[^\d]/g, ''); 658 659 owner.blocks.forEach(function (length, index) { 660 if (value.length > 0) { 661 var sub = value.slice(0, length), 662 sub0 = sub.slice(0, 1), 663 rest = value.slice(length); 664 665 switch (owner.datePattern[index]) { 666 case 'd': 667 if (sub === '00') { 668 sub = '01'; 669 } else if (parseInt(sub0, 10) > 3) { 670 sub = '0' + sub0; 671 } else if (parseInt(sub, 10) > 31) { 672 sub = '31'; 673 } 674 675 break; 676 677 case 'm': 678 if (sub === '00') { 679 sub = '01'; 680 } else if (parseInt(sub0, 10) > 1) { 681 sub = '0' + sub0; 682 } else if (parseInt(sub, 10) > 12) { 683 sub = '12'; 684 } 685 686 break; 687 } 688 689 result += sub; 690 691 // update remaining string 692 value = rest; 693 } 694 }); 695 696 return this.getFixedDateString(result); 697 }, 698 699 getFixedDateString: function (value) { 700 var owner = this, datePattern = owner.datePattern, date = [], 701 dayIndex = 0, monthIndex = 0, yearIndex = 0, 702 dayStartIndex = 0, monthStartIndex = 0, yearStartIndex = 0, 703 day, month, year, fullYearDone = false; 704 705 // mm-dd || dd-mm 706 if (value.length === 4 && datePattern[0].toLowerCase() !== 'y' && datePattern[1].toLowerCase() !== 'y') { 707 dayStartIndex = datePattern[0] === 'd' ? 0 : 2; 708 monthStartIndex = 2 - dayStartIndex; 709 day = parseInt(value.slice(dayStartIndex, dayStartIndex + 2), 10); 710 month = parseInt(value.slice(monthStartIndex, monthStartIndex + 2), 10); 711 712 date = this.getFixedDate(day, month, 0); 713 } 714 715 // yyyy-mm-dd || yyyy-dd-mm || mm-dd-yyyy || dd-mm-yyyy || dd-yyyy-mm || mm-yyyy-dd 716 if (value.length === 8) { 717 datePattern.forEach(function (type, index) { 718 switch (type) { 719 case 'd': 720 dayIndex = index; 721 break; 722 case 'm': 723 monthIndex = index; 724 break; 725 default: 726 yearIndex = index; 727 break; 728 } 729 }); 730 731 yearStartIndex = yearIndex * 2; 732 dayStartIndex = (dayIndex <= yearIndex) ? dayIndex * 2 : (dayIndex * 2 + 2); 733 monthStartIndex = (monthIndex <= yearIndex) ? monthIndex * 2 : (monthIndex * 2 + 2); 734 735 day = parseInt(value.slice(dayStartIndex, dayStartIndex + 2), 10); 736 month = parseInt(value.slice(monthStartIndex, monthStartIndex + 2), 10); 737 year = parseInt(value.slice(yearStartIndex, yearStartIndex + 4), 10); 738 739 fullYearDone = value.slice(yearStartIndex, yearStartIndex + 4).length === 4; 740 741 date = this.getFixedDate(day, month, year); 742 } 743 744 owner.date = date; 745 746 return date.length === 0 ? value : datePattern.reduce(function (previous, current) { 747 switch (current) { 748 case 'd': 749 return previous + owner.addLeadingZero(date[0]); 750 case 'm': 751 return previous + owner.addLeadingZero(date[1]); 752 default: 753 return previous + (fullYearDone ? owner.addLeadingZeroForYear(date[2]) : ''); 754 } 755 }, ''); 756 }, 757 758 getFixedDate: function (day, month, year) { 759 day = Math.min(day, 31); 760 month = Math.min(month, 12); 761 year = parseInt((year || 0), 10); 762 763 if ((month < 7 && month % 2 === 0) || (month > 8 && month % 2 === 1)) { 764 day = Math.min(day, month === 2 ? (this.isLeapYear(year) ? 29 : 28) : 30); 765 } 766 767 return [day, month, year]; 768 }, 769 770 isLeapYear: function (year) { 771 return ((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0); 772 }, 773 774 addLeadingZero: function (number) { 775 return (number < 10 ? '0' : '') + number; 776 }, 777 778 addLeadingZeroForYear: function (number) { 779 return (number < 10 ? '000' : (number < 100 ? '00' : (number < 1000 ? '0' : ''))) + number; 780 } 781 }; 782 783 module.exports = DateFormatter;
vendor: 8,006 bytes, lines 784-1058
784 785 786 787/***/ }), 788/* 3 */ 789/***/ (function(module, exports) { 790 791 'use strict'; 792 793 var TimeFormatter = function (timePattern, timeFormat) { 794 var owner = this; 795 796 owner.time = []; 797 owner.blocks = []; 798 owner.timePattern = timePattern; 799 owner.timeFormat = timeFormat; 800 owner.initBlocks(); 801 }; 802 803 TimeFormatter.prototype = { 804 initBlocks: function () { 805 var owner = this; 806 owner.timePattern.forEach(function () { 807 owner.blocks.push(2); 808 }); 809 }, 810 811 getISOFormatTime: function () { 812 var owner = this, 813 time = owner.time; 814 815 return time[2] ? ( 816 owner.addLeadingZero(time[0]) + ':' + owner.addLeadingZero(time[1]) + ':' + owner.addLeadingZero(time[2]) 817 ) : ''; 818 }, 819 820 getBlocks: function () { 821 return this.blocks; 822 }, 823 824 getTimeFormatOptions: function () { 825 var owner = this; 826 if (String(owner.timeFormat) === '12') { 827 return { 828 maxHourFirstDigit: 1, 829 maxHours: 12, 830 maxMinutesFirstDigit: 5, 831 maxMinutes: 60 832 }; 833 } 834 835 return { 836 maxHourFirstDigit: 2, 837 maxHours: 23, 838 maxMinutesFirstDigit: 5, 839 maxMinutes: 60 840 }; 841 }, 842 843 getValidatedTime: function (value) { 844 var owner = this, result = ''; 845 846 value = value.replace(/[^\d]/g, ''); 847 848 var timeFormatOptions = owner.getTimeFormatOptions(); 849 850 owner.blocks.forEach(function (length, index) { 851 if (value.length > 0) { 852 var sub = value.slice(0, length), 853 sub0 = sub.slice(0, 1), 854 rest = value.slice(length); 855 856 switch (owner.timePattern[index]) { 857 858 case 'h': 859 if (parseInt(sub0, 10) > timeFormatOptions.maxHourFirstDigit) { 860 sub = '0' + sub0; 861 } else if (parseInt(sub, 10) > timeFormatOptions.maxHours) { 862 sub = timeFormatOptions.maxHours + ''; 863 } 864 865 break; 866 867 case 'm': 868 case 's': 869 if (parseInt(sub0, 10) > timeFormatOptions.maxMinutesFirstDigit) { 870 sub = '0' + sub0; 871 } else if (parseInt(sub, 10) > timeFormatOptions.maxMinutes) { 872 sub = timeFormatOptions.maxMinutes + ''; 873 } 874 break; 875 } 876 877 result += sub; 878 879 // update remaining string 880 value = rest; 881 } 882 }); 883 884 return this.getFixedTimeString(result); 885 }, 886 887 getFixedTimeString: function (value) { 888 var owner = this, timePattern = owner.timePattern, time = [], 889 secondIndex = 0, minuteIndex = 0, hourIndex = 0, 890 secondStartIndex = 0, minuteStartIndex = 0, hourStartIndex = 0, 891 second, minute, hour; 892 893 if (value.length === 6) { 894 timePattern.forEach(function (type, index) { 895 switch (type) { 896 case 's': 897 secondIndex = index * 2; 898 break; 899 case 'm': 900 minuteIndex = index * 2; 901 break; 902 case 'h': 903 hourIndex = index * 2; 904 break; 905 } 906 }); 907 908 hourStartIndex = hourIndex; 909 minuteStartIndex = minuteIndex; 910 secondStartIndex = secondIndex; 911 912 second = parseInt(value.slice(secondStartIndex, secondStartIndex + 2), 10); 913 minute = parseInt(value.slice(minuteStartIndex, minuteStartIndex + 2), 10); 914 hour = parseInt(value.slice(hourStartIndex, hourStartIndex + 2), 10); 915 916 time = this.getFixedTime(hour, minute, second); 917 } 918 919 if (value.length === 4 && owner.timePattern.indexOf('s') < 0) { 920 timePattern.forEach(function (type, index) { 921 switch (type) { 922 case 'm': 923 minuteIndex = index * 2; 924 break; 925 case 'h': 926 hourIndex = index * 2; 927 break; 928 } 929 }); 930 931 hourStartIndex = hourIndex; 932 minuteStartIndex = minuteIndex; 933 934 second = 0; 935 minute = parseInt(value.slice(minuteStartIndex, minuteStartIndex + 2), 10); 936 hour = parseInt(value.slice(hourStartIndex, hourStartIndex + 2), 10); 937 938 time = this.getFixedTime(hour, minute, second); 939 } 940 941 owner.time = time; 942 943 return time.length === 0 ? value : timePattern.reduce(function (previous, current) { 944 switch (current) { 945 case 's': 946 return previous + owner.addLeadingZero(time[2]); 947 case 'm': 948 return previous + owner.addLeadingZero(time[1]); 949 case 'h': 950 return previous + owner.addLeadingZero(time[0]); 951 } 952 }, ''); 953 }, 954 955 getFixedTime: function (hour, minute, second) { 956 second = Math.min(parseInt(second || 0, 10), 60); 957 minute = Math.min(minute, 60); 958 hour = Math.min(hour, 60); 959 960 return [hour, minute, second]; 961 }, 962 963 addLeadingZero: function (number) { 964 return (number < 10 ? '0' : '') + number; 965 } 966 }; 967 968 module.exports = TimeFormatter; 969 970 971/***/ }), 972/* 4 */ 973/***/ (function(module, exports) { 974 975 'use strict'; 976 977 var PhoneFormatter = function (formatter, delimiter) { 978 var owner = this; 979 980 owner.delimiter = (delimiter || delimiter === '') ? delimiter : ' '; 981 owner.delimiterRE = delimiter ? new RegExp('\\' + delimiter, 'g') : ''; 982 983 owner.formatter = formatter; 984 }; 985 986 PhoneFormatter.prototype = { 987 setFormatter: function (formatter) { 988 this.formatter = formatter; 989 }, 990 991 format: function (phoneNumber) { 992 var owner = this; 993 994 owner.formatter.clear(); 995 996 // only keep number and + 997 phoneNumber = phoneNumber.replace(/[^\d+]/g, ''); 998 999 // strip non-leading + 1000 phoneNumber = phoneNumber.replace(/^\+/, 'B').replace(/\+/g, '').replace('B', '+'); 1001 1002 // strip delimiter 1003 phoneNumber = phoneNumber.replace(owner.delimiterRE, ''); 1004 1005 var result = '', current, validated = false; 1006 1007 for (var i = 0, iMax = phoneNumber.length; i < iMax; i++) { 1008 current = owner.formatter.inputDigit(phoneNumber.charAt(i)); 1009 1010 // has ()- or space inside 1011 if (/[\s()-]/g.test(current)) { 1012 result = current; 1013 1014 validated = true; 1015 } else { 1016 if (!validated) { 1017 result = current; 1018 } 1019 // else: over length input 1020 // it turns to invalid number again 1021 } 1022 } 1023 1024 // strip () 1025 // e.g. US: 7161234567 returns (716) 123-4567 1026 result = result.replace(/[()]/g, ''); 1027 // replace library delimiter with user customized delimiter 1028 result = result.replace(/[\s-]/g, owner.delimiter); 1029 1030 return result; 1031 } 1032 }; 1033 1034 module.exports = PhoneFormatter; 1035 1036 1037/***/ }), 1038/* 5 */ 1039/***/ (function(module, exports) { 1040 1041 'use strict'; 1042 1043 var CreditCardDetector = { 1044 blocks: { 1045 uatp: [4, 5, 6], 1046 amex: [4, 6, 5], 1047 diners: [4, 6, 4], 1048 discover: [4, 4, 4, 4], 1049 mastercard: [4, 4, 4, 4], 1050 dankort: [4, 4, 4, 4], 1051 instapayment: [4, 4, 4, 4], 1052 jcb15: [4, 6, 5], 1053 jcb: [4, 4, 4, 4], 1054 maestro: [4, 4, 4, 4], 1055 visa: [4, 4, 4, 4], 1056 mir: [4, 4, 4, 4], 1057 unionPay: [4, 4, 4, 4], 1058 general: [4, 4, 4, 4]
vendor: 4,297 bytes, lines 1058-1199
1058, 1059 generalStrict: [4, 4, 4, 7] 1060 }, 1061 1062 re: { 1063 // starts with 1; 15 digits, not starts with 1800 (jcb card) 1064 uatp: /^(?!1800)1\d{0,14}/, 1065 1066 // starts with 34/37; 15 digits 1067 amex: /^3[47]\d{0,13}/, 1068 1069 // starts with 6011/65/644-649; 16 digits 1070 discover: /^(?:6011|65\d{0,2}|64[4-9]\d?)\d{0,12}/, 1071 1072 // starts with 300-305/309 or 36/38/39; 14 digits 1073 diners: /^3(?:0([0-5]|9)|[689]\d?)\d{0,11}/, 1074 1075 // starts with 51-55/2221â2720; 16 digits 1076 mastercard: /^(5[1-5]\d{0,2}|22[2-9]\d{0,1}|2[3-7]\d{0,2})\d{0,12}/, 1077 1078 // starts with 5019/4175/4571; 16 digits 1079 dankort: /^(5019|4175|4571)\d{0,12}/, 1080 1081 // starts with 637-639; 16 digits 1082 instapayment: /^63[7-9]\d{0,13}/, 1083 1084 // starts with 2131/1800; 15 digits 1085 jcb15: /^(?:2131|1800)\d{0,11}/, 1086 1087 // starts with 2131/1800/35; 16 digits 1088 jcb: /^(?:35\d{0,2})\d{0,12}/, 1089 1090 // starts with 50/56-58/6304/67; 16 digits 1091 maestro: /^(?:5[0678]\d{0,2}|6304|67\d{0,2})\d{0,12}/, 1092 1093 // starts with 22; 16 digits 1094 mir: /^220[0-4]\d{0,12}/, 1095 1096 // starts with 4; 16 digits 1097 visa: /^4\d{0,15}/, 1098 1099 // starts with 62; 16 digits 1100 unionPay: /^62\d{0,14}/ 1101 }, 1102 1103 getInfo: function (value, strictMode) { 1104 var blocks = CreditCardDetector.blocks, 1105 re = CreditCardDetector.re; 1106 1107 // Some credit card can have up to 19 digits number. 1108 // Set strictMode to true will remove the 16 max-length restrain, 1109 // however, I never found any website validate card number like 1110 // this, hence probably you don't want to enable this option. 1111 strictMode = !!strictMode; 1112 1113 for (var key in re) { 1114 if (re[key].test(value)) { 1115 var block; 1116 1117 if (strictMode) { 1118 block = blocks.generalStrict; 1119 } else { 1120 block = blocks[key]; 1121 } 1122 1123 return { 1124 type: key, 1125 blocks: block 1126 }; 1127 } 1128 } 1129 1130 return { 1131 type: 'unknown', 1132 blocks: strictMode ? blocks.generalStrict : blocks.general 1133 }; 1134 } 1135 }; 1136 1137 module.exports = CreditCardDetector; 1138 1139 1140/***/ }), 1141/* 6 */ 1142/***/ (function(module, exports) { 1143 1144 'use strict'; 1145 1146 var Util = { 1147 noop: function () { 1148 }, 1149 1150 strip: function (value, re) { 1151 return value.replace(re, ''); 1152 }, 1153 1154 getPostDelimiter: function (value, delimiter, delimiters) { 1155 // single delimiter 1156 if (delimiters.length === 0) { 1157 return value.slice(-delimiter.length) === delimiter ? delimiter : ''; 1158 } 1159 1160 // multiple delimiters 1161 var matchedDelimiter = ''; 1162 delimiters.forEach(function (current) { 1163 if (value.slice(-current.length) === current) { 1164 matchedDelimiter = current; 1165 } 1166 }); 1167 1168 return matchedDelimiter; 1169 }, 1170 1171 getDelimiterREByDelimiter: function (delimiter) { 1172 return new RegExp(delimiter.replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1'), 'g'); 1173 }, 1174 1175 getNextCursorPosition: function (prevPos, oldValue, newValue, delimiter, delimiters) { 1176 // If cursor was at the end of value, just place it back. 1177 // Because new value could contain additional chars. 1178 if (oldValue.length === prevPos) { 1179 return newValue.length; 1180 } 1181 1182 return prevPos + this.getPositionOffset(prevPos, oldValue, newValue, delimiter ,delimiters); 1183 }, 1184 1185 getPositionOffset: function (prevPos, oldValue, newValue, delimiter, delimiters) { 1186 var oldRawValue, newRawValue, lengthOffset; 1187 1188 oldRawValue = this.stripDelimiters(oldValue.slice(0, prevPos), delimiter, delimiters); 1189 newRawValue = this.stripDelimiters(newValue.slice(0, prevPos), delimiter, delimiters); 1190 lengthOffset = oldRawValue.length - newRawValue.length; 1191 1192 return (lengthOffset !== 0) ? (lengthOffset / Math.abs(lengthOffset)) : 0; 1193 }, 1194 1195 stripDelimiters: function (value, delimiter, delimiters) { 1196 var owner = this; 1197 1198 // single delimiter 1199 if (delimiters.length === 0) {
1200 var delimiterRE = delimiter ? owner.getDelimiterREByDelimiter(delimiter) : ''; 1201 1202 return value.replace(delimiterRE, ''); 1203 } 1204 1205 // multiple delimiters 1206 delimiters.forEach(function (current) { 1207 current.split('').forEach(function (letter) { 1208 value = value.replace(owner.getDelimiterREByDelimiter(letter), ''); 1209 }); 1210 }); 1211 1212 return value; 1213 }, 1214 1215 headStr: function (str, length) { 1216 return str.slice(0, length); 1217 }, 1218 1219 getMaxLength: function (blocks) { 1220 return blocks.reduce(function (previous, current) { 1221 return previous + current; 1222 }, 0); 1223 }, 1224 1225 // strip value by prefix length 1226 // for prefix: PRE 1227 // (PRE123, 3) -> 123 1228 // (PR123, 3) -> 23 this happens when user hits backspace in front of "PRE" 1229 getPrefixStrippedValue: function (value, prefix, prefixLength, prevValue) { 1230 if (value.slice(0, prefixLength) !== prefix) { 1231 1232 // Check whether if it is a deletion 1233 if (value.length < prevValue.length) { 1234 value = value.length > prefixLength ? prevValue : prefix; 1235 } else { 1236 var diffIndex = this.getFirstDiffIndex(prefix, value.slice(0, prefixLength)); 1237 value = prefix + value.slice(diffIndex, diffIndex + 1) + value.slice(prefixLength + 1); 1238 } 1239 } 1240 1241 return value.slice(prefixLength); 1242 }, 1243 1244 getFirstDiffIndex: function (prev, current) { 1245 var index = 0; 1246 1247 while (prev.charAt(index) === current.charAt(index)) { 1248 if (prev.charAt(index++) === '') { 1249 return -1; 1250 } 1251 } 1252 1253 return index; 1254 }, 1255 1256 getFormattedValue: function (value, blocks, blocksLength, delimiter, delimiters, delimiterLazyShow) { 1257 var result = '', 1258 multipleDelimiters = delimiters.length > 0, 1259 currentDelimiter; 1260 1261 // no options, normal input 1262 if (blocksLength === 0) { 1263 return value; 1264 } 1265 1266 blocks.forEach(function (length, index) { 1267 if (value.length > 0) { 1268 var sub = value.slice(0, length), 1269 rest = value.slice(length); 1270 1271 if (multipleDelimiters) { 1272 currentDelimiter = delimiters[delimiterLazyShow ? (index - 1) : index] || currentDelimiter; 1273 } else { 1274 currentDelimiter = delimiter; 1275 } 1276 1277 if (delimiterLazyShow) { 1278 if (index > 0) { 1279 result += currentDelimiter; 1280 } 1281 1282 result += sub; 1283 } else { 1284 result += sub; 1285 1286 if (sub.length === length && index < blocksLength - 1) { 1287 result += currentDelimiter; 1288 } 1289 } 1290
vendor: 5,587 bytes, lines 1291-1456
1291 // update remaining string 1292 value = rest; 1293 } 1294 }); 1295 1296 return result; 1297 }, 1298 1299 // move cursor to the end 1300 // the first time user focuses on an input with prefix 1301 fixPrefixCursor: function (el, prefix, delimiter, delimiters) { 1302 if (!el) { 1303 return; 1304 } 1305 1306 var val = el.value, 1307 appendix = delimiter || (delimiters[0] || ' '); 1308 1309 if (!el.setSelectionRange || !prefix || (prefix.length + appendix.length) < val.length) { 1310 return; 1311 } 1312 1313 var len = val.length * 2; 1314 1315 // set timeout to avoid blink 1316 setTimeout(function () { 1317 el.setSelectionRange(len, len); 1318 }, 1); 1319 }, 1320 1321 setSelection: function (element, position, doc) { 1322 if (element !== this.getActiveElement(doc)) { 1323 return; 1324 } 1325 1326 // cursor is already in the end 1327 if (element && element.value.length <= position) { 1328 return; 1329 } 1330 1331 if (element.createTextRange) { 1332 var range = element.createTextRange(); 1333 1334 range.move('character', position); 1335 range.select(); 1336 } else { 1337 try { 1338 element.setSelectionRange(position, position); 1339 } catch (e) { 1340 // eslint-disable-next-line 1341 console.warn('The input element type does not support selection'); 1342 } 1343 } 1344 }, 1345 1346 getActiveElement: function(parent) { 1347 var activeElement = parent.activeElement; 1348 if (activeElement && activeElement.shadowRoot) { 1349 return this.getActiveElement(activeElement.shadowRoot); 1350 } 1351 return activeElement; 1352 }, 1353 1354 isAndroid: function () { 1355 return navigator && /android/i.test(navigator.userAgent); 1356 }, 1357 1358 // On Android chrome, the keyup and keydown events 1359 // always return key code 229 as a composition that 1360 // buffers the userâs keystrokes 1361 // see https://github.com/nosir/cleave.js/issues/147 1362 isAndroidBackspaceKeydown: function (lastInputValue, currentInputValue) { 1363 if (!this.isAndroid() || !lastInputValue || !currentInputValue) { 1364 return false; 1365 } 1366 1367 return currentInputValue === lastInputValue.slice(0, -1); 1368 } 1369 }; 1370 1371 module.exports = Util; 1372 1373 1374/***/ }), 1375/* 7 */ 1376/***/ (function(module, exports) { 1377 1378 /* WEBPACK VAR INJECTION */(function(global) {'use strict'; 1379 1380 /** 1381 * Props Assignment 1382 * 1383 * Separate this, so react module can share the usage 1384 */ 1385 var DefaultProperties = { 1386 // Maybe change to object-assign 1387 // for now just keep it as simple 1388 assign: function (target, opts) { 1389 target = target || {}; 1390 opts = opts || {}; 1391 1392 // credit card 1393 target.creditCard = !!opts.creditCard; 1394 target.creditCardStrictMode = !!opts.creditCardStrictMode; 1395 target.creditCardType = ''; 1396 target.onCreditCardTypeChanged = opts.onCreditCardTypeChanged || (function () {}); 1397 1398 // phone 1399 target.phone = !!opts.phone; 1400 target.phoneRegionCode = opts.phoneRegionCode || 'AU'; 1401 target.phoneFormatter = {}; 1402 1403 // time 1404 target.time = !!opts.time; 1405 target.timePattern = opts.timePattern || ['h', 'm', 's']; 1406 target.timeFormat = opts.timeFormat || '24'; 1407 target.timeFormatter = {}; 1408 1409 // date 1410 target.date = !!opts.date; 1411 target.datePattern = opts.datePattern || ['d', 'm', 'Y']; 1412 target.dateFormatter = {}; 1413 1414 // numeral 1415 target.numeral = !!opts.numeral; 1416 target.numeralIntegerScale = opts.numeralIntegerScale > 0 ? opts.numeralIntegerScale : 0; 1417 target.numeralDecimalScale = opts.numeralDecimalScale >= 0 ? opts.numeralDecimalScale : 2; 1418 target.numeralDecimalMark = opts.numeralDecimalMark || '.'; 1419 target.numeralThousandsGroupStyle = opts.numeralThousandsGroupStyle || 'thousand'; 1420 target.numeralPositiveOnly = !!opts.numeralPositiveOnly; 1421 target.stripLeadingZeroes = opts.stripLeadingZeroes !== false; 1422 1423 // others 1424 target.numericOnly = target.creditCard || target.date || !!opts.numericOnly; 1425 1426 target.uppercase = !!opts.uppercase; 1427 target.lowercase = !!opts.lowercase; 1428 1429 target.prefix = (target.creditCard || target.date) ? '' : (opts.prefix || ''); 1430 target.noImmediatePrefix = !!opts.noImmediatePrefix; 1431 target.prefixLength = target.prefix.length; 1432 target.rawValueTrimPrefix = !!opts.rawValueTrimPrefix; 1433 target.copyDelimiter = !!opts.copyDelimiter; 1434 1435 target.initValue = (opts.initValue !== undefined && opts.initValue !== null) ? opts.initValue.toString() : ''; 1436 1437 target.delimiter = 1438 (opts.delimiter || opts.delimiter === '') ? opts.delimiter : 1439 (opts.date ? '/' : 1440 (opts.time ? ':' : 1441 (opts.numeral ? ',' : 1442 (opts.phone ? ' ' : 1443 ' ')))); 1444 target.delimiterLength = target.delimiter.length; 1445 target.delimiterLazyShow = !!opts.delimiterLazyShow; 1446 target.delimiters = opts.delimiters || []; 1447 1448 target.blocks = opts.blocks || []; 1449 target.blocksLength = target.blocks.length; 1450 1451 target.root = (typeof global === 'object' && global) ? global : window; 1452 target.document = opts.document || target.root.document; 1453 1454 target.maxLength = 0; 1455 1456 target.backspace = false;
1457 target.result = ''; 1458 1459 target.onValueChanged = opts.onValueChanged || (function () {}); 1460 1461 return target; 1462 } 1463 }; 1464 1465 module.exports = DefaultProperties; 1466 1467 /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) 1468 1469/***/ }) 1470/******/ ]) 1471}); 1472;
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.