1;(function() { 2 3 if (typeof window.BX === 'function') 4 { 5 return; 6 } 7 8/** 9 * Babel external helpers 10 * (c) 2018 Babel 11 * @license MIT 12 */ 13(function (global) { 14 var babelHelpers = global.babelHelpers = {}; 15 16 function _typeof(obj) { 17 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 18 babelHelpers.typeof = _typeof = function (obj) { 19 return typeof obj; 20 }; 21 } else { 22 babelHelpers.typeof = _typeof = function (obj) { 23 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; 24 }; 25 } 26 27 return _typeof(obj); 28 } 29 30 babelHelpers.typeof = _typeof; 31 var REACT_ELEMENT_TYPE; 32 33 function _createRawReactElement(type, props, key, children) { 34 if (!REACT_ELEMENT_TYPE) { 35 REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7; 36 } 37 38 var defaultProps = type && type.defaultProps; 39 var childrenLength = arguments.length - 3; 40 41 if (!props && childrenLength !== 0) { 42 props = { 43 children: void 0 44 }; 45 } 46 47 if (props && defaultProps) { 48 for (var propName in defaultProps) { 49 if (props[propName] === void 0) { 50 props[propName] = defaultProps[propName]; 51 } 52 } 53 } else if (!props) { 54 props = defaultProps || {}; 55 } 56 57 if (childrenLength === 1) { 58 props.children = children; 59 } else if (childrenLength > 1) { 60 var childArray = new Array(childrenLength); 61 62 for (var i = 0; i < childrenLength; i++) { 63 childArray[i] = arguments[i + 3]; 64 } 65 66 props.children = childArray; 67 } 68 69 return { 70 $$typeof: REACT_ELEMENT_TYPE, 71 type: type, 72 key: key === undefined ? null : '' + key, 73 ref: null, 74 props: props, 75 _owner: null 76 }; 77 } 78 79 babelHelpers.jsx = _createRawReactElement; 80 81 function _asyncIterator(iterable) { 82 var method; 83 84 if (typeof Symbol === "function") { 85 if (Symbol.asyncIterator) { 86 method = iterable[Symbol.asyncIterator]; 87 if (method != null) return method.call(iterable); 88 } 89 90 if (Symbol.iterator) { 91 method = iterable[Symbol.iterator]; 92 if (method != null) return method.call(iterable); 93 } 94 } 95 96 throw new TypeError("Object is not async iterable"); 97 } 98 99 babelHelpers.asyncIterator = _asyncIterator; 100 101 function _AwaitValue(value) { 102 this.wrapped = value; 103 } 104 105 babelHelpers.AwaitValue = _AwaitValue; 106 107 function AsyncGenerator(gen) { 108 var front, back; 109 110 function send(key, arg) { 111 return new Promise(function (resolve, reject) { 112 var request = { 113 key: key, 114 arg: arg, 115 resolve: resolve, 116 reject: reject, 117 next: null 118 }; 119 120 if (back) { 121 back = back.next = request; 122 } else { 123 front = back = request; 124 resume(key, arg); 125 } 126 }); 127 } 128 129 function resume(key, arg) { 130 try { 131 var result = gen[key](arg); 132 var value = result.value; 133 var wrappedAwait = value instanceof babelHelpers.AwaitValue; 134 Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { 135 if (wrappedAwait) { 136 resume("next", arg); 137 return; 138 } 139 140 settle(result.done ? "return" : "normal", arg); 141 }, function (err) { 142 resume("throw", err); 143 }); 144 } catch (err) { 145 settle("throw", err); 146 } 147 } 148 149 function settle(type, value) { 150 switch (type) { 151 case "return": 152 front.resolve({ 153 value: value, 154 done: true 155 }); 156 break; 157 158 case "throw": 159 front.reject(value); 160 break; 161 162 default: 163 front.resolve({ 164 value: value, 165 done: false 166 }); 167 break; 168 } 169 170 front = front.next; 171 172 if (front) { 173 resume(front.key, front.arg); 174 } else { 175 back = null; 176 } 177 } 178 179 this._invoke = send; 180 181 if (typeof gen.return !== "function") { 182 this.return = undefined; 183 } 184 } 185 186 if (typeof Symbol === "function" && Symbol.asyncIterator) { 187 AsyncGenerator.prototype[Symbol.asyncIterator] = function () { 188 return this; 189 }; 190 } 191 192 AsyncGenerator.prototype.next = function (arg) { 193 return this._invoke("next", arg); 194 }; 195 196 AsyncGenerator.prototype.throw = function (arg) { 197 return this._invoke("throw", arg); 198 }; 199 200 AsyncGenerator.prototype.return = function (arg) { 201 return this._invoke("return", arg); 202 }; 203 204 babelHelpers.AsyncGenerator = AsyncGenerator; 205 206 function _wrapAsyncGenerator(fn) { 207 return function () { 208 return new babelHelpers.AsyncGenerator(fn.apply(this, arguments)); 209 }; 210 } 211 212 babelHelpers.wrapAsyncGenerator = _wrapAsyncGenerator; 213 214 function _awaitAsyncGenerator(value) { 215 return new babelHelpers.AwaitValue(value); 216 } 217 218 babelHelpers.awaitAsyncGenerator = _awaitAsyncGenerator; 219 220 function _asyncGeneratorDelegate(inner, awaitWrap) { 221 var iter = {}, 222 waiting = false;
223 224 function pump(key, value) { 225 waiting = true; 226 value = new Promise(function (resolve) { 227 resolve(inner[key](value)); 228 }); 229 return { 230 done: false, 231 value: awaitWrap(value) 232 }; 233 } 234 235 ; 236 237 if (typeof Symbol === "function" && Symbol.iterator) { 238 iter[Symbol.iterator] = function () { 239 return this; 240 }; 241 } 242 243 iter.next = function (value) { 244 if (waiting) { 245 waiting = false; 246 return value; 247 } 248 249 return pump("next", value); 250 }; 251 252 if (typeof inner.throw === "function") { 253 iter.throw = function (value) { 254 if (waiting) { 255 waiting = false; 256 throw value; 257 } 258 259 return pump("throw", value); 260 }; 261 } 262 263 if (typeof inner.return === "function") { 264 iter.return = function (value) { 265 return pump("return", value); 266 }; 267 } 268 269 return iter; 270 } 271 272 babelHelpers.asyncGeneratorDelegate = _asyncGeneratorDelegate; 273 274 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { 275 try { 276 var info = gen[key](arg); 277 var value = info.value; 278 } catch (error) { 279 reject(error); 280 return; 281 } 282 283 if (info.done) { 284 resolve(value); 285 } else { 286 Promise.resolve(value).then(_next, _throw); 287 } 288 } 289 290 function _asyncToGenerator(fn) { 291 return function () { 292 var self = this, 293 args = arguments; 294 return new Promise(function (resolve, reject) { 295 var gen = fn.apply(self, args); 296 297 function _next(value) { 298 asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); 299 } 300 301 function _throw(err) { 302 asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); 303 } 304 305 _next(undefined); 306 }); 307 }; 308 } 309 310 babelHelpers.asyncToGenerator = _asyncToGenerator; 311 312 function _classCallCheck(instance, Constructor) { 313 if (!(instance instanceof Constructor)) { 314 throw new TypeError("Cannot call a class as a function"); 315 } 316 } 317 318 babelHelpers.classCallCheck = _classCallCheck; 319 320 function _defineProperties(target, props) { 321 for (var i = 0; i < props.length; i++) { 322 var descriptor = props[i]; 323 descriptor.enumerable = descriptor.enumerable || false; 324 descriptor.configurable = true; 325 if ("value" in descriptor) descriptor.writable = true; 326 Object.defineProperty(target, descriptor.key, descriptor); 327 } 328 } 329 330 function _createClass(Constructor, protoProps, staticProps) { 331 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 332 if (staticProps) _defineProperties(Constructor, staticProps); 333 return Constructor; 334 } 335 336 babelHelpers.createClass = _createClass; 337 338 function _defineEnumerableProperties(obj, descs) { 339 for (var key in descs) { 340 var desc = descs[key]; 341 desc.configurable = desc.enumerable = true; 342 if ("value" in desc) desc.writable = true; 343 Object.defineProperty(obj, key, desc); 344 } 345 346 if (Object.getOwnPropertySymbols) { 347 var objectSymbols = Object.getOwnPropertySymbols(descs); 348 349 for (var i = 0; i < objectSymbols.length; i++) { 350 var sym = objectSymbols[i]; 351 var desc = descs[sym]; 352 desc.configurable = desc.enumerable = true; 353 if ("value" in desc) desc.writable = true; 354 Object.defineProperty(obj, sym, desc); 355 } 356 } 357 358 return obj; 359 } 360 361 babelHelpers.defineEnumerableProperties = _defineEnumerableProperties; 362 363 function _defaults(obj, defaults) { 364 var keys = Object.getOwnPropertyNames(defaults); 365 366 for (var i = 0; i < keys.length; i++) { 367 var key = keys[i]; 368 var value = Object.getOwnPropertyDescriptor(defaults, key); 369 370 if (value && value.configurable && obj[key] === undefined) { 371 Object.defineProperty(obj, key, value); 372 } 373 } 374 375 return obj; 376 } 377 378 babelHelpers.defaults = _defaults; 379 380 function _defineProperty(obj, key, value) { 381 if (key in obj) { 382 Object.defineProperty(obj, key, { 383 value: value, 384 enumerable: true, 385 configurable: true, 386 writable: true 387 }); 388 } else { 389 obj[key] = value; 390 } 391 392 return obj; 393 } 394 395 babelHelpers.defineProperty = _defineProperty; 396 397 function _extends() { 398 babelHelpers.extends = _extends = Object.assign || function (target) { 399 for (var i = 1; i < arguments.length; i++) { 400 var source = arguments[i]; 401 402 for (var key in source) { 403 if (Object.prototype.hasOwnProperty.call(source, key)) { 404 target[key] = source[key]; 405 } 406 } 407 } 408 409 return target; 410 }; 411 412 return _extends.apply(this, arguments); 413 } 414 415 babelHelpers.extends = _extends; 416 417 function _objectSpread(target) { 418 for (var i = 1; i < arguments.length; i++) { 419 var source = arguments[i] != null ? arguments[i] : {}; 420 var ownKeys = Object.keys(source); 421 422 if (typeof Object.getOwnPropertySymbols === 'function') { 423 ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { 424 return Object.getOwnPropertyDescriptor(source, sym).enumerable; 425 })); 426 } 427 428 ownKeys.forEach(function (key) { 429 babelHelpers.defineProperty(target, key, source[key]); 430 }); 431 } 432 433 return target; 434 } 435 436 babelHelpers.objectSpread = _objectSpread; 437 438 function _inherits(subClass, superClass) { 439 if (typeof superClass !== "function" && superClass !== null) { 440 throw new TypeError("Super expression must either be null or a function"); 441 } 442 443 subClass.prototype = Object.create(superClass && superClass.prototype, { 444 constructor: { 445 value: subClass, 446 writable: true, 447 configurable: true 448 } 449 }); 450 if (superClass) babelHelpers.setPrototypeOf(subClass, superClass); 451 } 452 453 babelHelpers.inherits = _inherits; 454 455 function _inheritsLoose(subClass, superClass) { 456 subClass.prototype = Object.create(superClass.prototype); 457 subClass.prototype.constructor = subClass; 458 subClass.__proto__ = superClass; 459 } 460 461 babelHelpers.inheritsLoose = _inheritsLoose; 462
463 function _getPrototypeOf(o) { 464 babelHelpers.getPrototypeOf = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { 465 return o.__proto__ || Object.getPrototypeOf(o); 466 }; 467 return _getPrototypeOf(o); 468 } 469 470 babelHelpers.getPrototypeOf = _getPrototypeOf; 471 472 function _setPrototypeOf(o, p) { 473 babelHelpers.setPrototypeOf = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { 474 o.__proto__ = p; 475 return o; 476 }; 477 478 return _setPrototypeOf(o, p); 479 } 480 481 babelHelpers.setPrototypeOf = _setPrototypeOf; 482 483 function isNativeReflectConstruct() { 484 if (typeof Reflect === "undefined" || !Reflect.construct) return false; 485 if (Reflect.construct.sham) return false; 486 if (typeof Proxy === "function") return true; 487 488 try { 489 Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); 490 return true; 491 } catch (e) { 492 return false; 493 } 494 } 495 496 function _construct(Parent, args, Class) { 497 if (isNativeReflectConstruct()) { 498 babelHelpers.construct = _construct = Reflect.construct; 499 } else { 500 babelHelpers.construct = _construct = function _construct(Parent, args, Class) { 501 var a = [null]; 502 a.push.apply(a, args); 503 var Constructor = Function.bind.apply(Parent, a); 504 var instance = new Constructor(); 505 if (Class) babelHelpers.setPrototypeOf(instance, Class.prototype); 506 return instance; 507 }; 508 } 509 510 return _construct.apply(null, arguments); 511 } 512 513 babelHelpers.construct = _construct; 514 515 function _isNativeFunction(fn) { 516 return Function.toString.call(fn).indexOf("[native code]") !== -1; 517 } 518 519 babelHelpers.isNativeFunction = _isNativeFunction; 520 521 function _wrapNativeSuper(Class) { 522 var _cache = typeof Map === "function" ? new Map() : undefined; 523 524 babelHelpers.wrapNativeSuper = _wrapNativeSuper = function _wrapNativeSuper(Class) { 525 if (Class === null || !babelHelpers.isNativeFunction(Class)) return Class; 526 527 if (typeof Class !== "function") { 528 throw new TypeError("Super expression must either be null or a function"); 529 } 530 531 if (typeof _cache !== "undefined") { 532 if (_cache.has(Class)) return _cache.get(Class); 533 534 _cache.set(Class, Wrapper); 535 } 536 537 function Wrapper() { 538 return babelHelpers.construct(Class, arguments, babelHelpers.getPrototypeOf(this).constructor); 539 } 540 541 Wrapper.prototype = Object.create(Class.prototype, { 542 constructor: { 543 value: Wrapper, 544 enumerable: false, 545 writable: true, 546 configurable: true 547 } 548 }); 549 return babelHelpers.setPrototypeOf(Wrapper, Class); 550 }; 551 552 return _wrapNativeSuper(Class); 553 } 554 555 babelHelpers.wrapNativeSuper = _wrapNativeSuper; 556 557 function _instanceof(left, right) { 558 if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { 559 return right[Symbol.hasInstance](left); 560 } else { 561 return left instanceof right; 562 } 563 } 564 565 babelHelpers.instanceof = _instanceof; 566 567 function _interopRequireDefault(obj) { 568 return obj && obj.__esModule ? obj : { 569 default: obj 570 }; 571 } 572 573 babelHelpers.interopRequireDefault = _interopRequireDefault; 574 575 function _interopRequireWildcard(obj) { 576 if (obj && obj.__esModule) { 577 return obj; 578 } else { 579 var newObj = {}; 580 581 if (obj != null) { 582 for (var key in obj) { 583 if (Object.prototype.hasOwnProperty.call(obj, key)) { 584 var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; 585 586 if (desc.get || desc.set) { 587 Object.defineProperty(newObj, key, desc); 588 } else { 589 newObj[key] = obj[key]; 590 } 591 } 592 } 593 } 594 595 newObj.default = obj; 596 return newObj; 597 } 598 } 599 600 babelHelpers.interopRequireWildcard = _interopRequireWildcard; 601 602 function _newArrowCheck(innerThis, boundThis) { 603 if (innerThis !== boundThis) { 604 throw new TypeError("Cannot instantiate an arrow function"); 605 } 606 } 607 608 babelHelpers.newArrowCheck = _newArrowCheck; 609 610 function _objectDestructuringEmpty(obj) { 611 if (obj == null) throw new TypeError("Cannot destructure undefined"); 612 } 613 614 babelHelpers.objectDestructuringEmpty = _objectDestructuringEmpty; 615 616 function _objectWithoutPropertiesLoose(source, excluded) { 617 if (source == null) return {}; 618 var target = {}; 619 var sourceKeys = Object.keys(source); 620 var key, i; 621 622 for (i = 0; i < sourceKeys.length; i++) { 623 key = sourceKeys[i]; 624 if (excluded.indexOf(key) >= 0) continue; 625 target[key] = source[key]; 626 } 627 628 return target; 629 } 630 631 babelHelpers.objectWithoutPropertiesLoose = _objectWithoutPropertiesLoose; 632 633 function _objectWithoutProperties(source, excluded) { 634 if (source == null) return {}; 635 var target = babelHelpers.objectWithoutPropertiesLoose(source, excluded); 636 var key, i; 637 638 if (Object.getOwnPropertySymbols) { 639 var sourceSymbolKeys = Object.getOwnPropertySymbols(source); 640 641 for (i = 0; i < sourceSymbolKeys.length; i++) { 642 key = sourceSymbolKeys[i]; 643 if (excluded.indexOf(key) >= 0) continue; 644 if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; 645 target[key] = source[key]; 646 } 647 } 648 649 return target; 650 } 651 652 babelHelpers.objectWithoutProperties = _objectWithoutProperties; 653 654 function _assertThisInitialized(self) { 655 if (self === void 0) { 656 throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); 657 } 658 659 return self; 660 } 661 662 babelHelpers.assertThisInitialized = _assertThisInitialized; 663 664 function _possibleConstructorReturn(self, call) { 665 if (call && (typeof call === "object" || typeof call === "function")) { 666 return call; 667 } 668 669 return babelHelpers.assertThisInitialized(self); 670 } 671 672 babelHelpers.possibleConstructorReturn = _possibleConstructorReturn; 673 674 function _superPropBase(object, property) { 675 while (!Object.prototype.hasOwnProperty.call(object, property)) { 676 object = babelHelpers.getPrototypeOf(object); 677 if (object === null) break; 678 } 679 680 return object; 681 } 682 683 babelHelpers.superPropBase = _superPropBase; 684 685 function _get(target, property, receiver) { 686 if (typeof Reflect !== "undefined" && Reflect.get) { 687 babelHelpers.get = _get = Reflect.get; 688 } else { 689 babelHelpers.get = _get = function _get(target, property, receiver) { 690 var base = babelHelpers.superPropBase(target, property); 691 if (!base) return; 692 var desc = Object.getOwnPropertyDescriptor(base, property); 693 694 if (desc.get) { 695 return desc.get.call(receiver); 696 } 697 698 return desc.value; 699 }; 700 } 701 702 return _get(target, property, receiver || target); 703 } 704 705 babelHelpers.get = _get; 706 707 function set(target, property, value, receiver) { 708 if (typeof Reflect !== "undefined" && Reflect.set) { 709 set = Reflect.set; 710 } else { 711 set = function set(target, property, value, receiver) { 712 var base = babelHelpers.superPropBase(target, property); 713 var desc; 714 715 if (base) { 716 desc = Object.getOwnPropertyDescriptor(base, property); 717 718 if (desc.set) { 719 desc.set.call(receiver, value); 720 return true; 721 } else if (!desc.writable) { 722 return false;
723 } 724 } 725 726 desc = Object.getOwnPropertyDescriptor(receiver, property); 727 728 if (desc) { 729 if (!desc.writable) { 730 return false; 731 } 732 733 desc.value = value; 734 Object.defineProperty(receiver, property, desc); 735 } else { 736 babelHelpers.defineProperty(receiver, property, value); 737 } 738 739 return true; 740 }; 741 } 742 743 return set(target, property, value, receiver); 744 } 745 746 function _set(target, property, value, receiver, isStrict) { 747 var s = set(target, property, value, receiver || target); 748 749 if (!s && isStrict) { 750 throw new Error('failed to set property'); 751 } 752 753 return value; 754 } 755 756 babelHelpers.set = _set; 757 758 function _taggedTemplateLiteral(strings, raw) { 759 if (!raw) { 760 raw = strings.slice(0); 761 } 762 763 return Object.freeze(Object.defineProperties(strings, { 764 raw: { 765 value: Object.freeze(raw) 766 } 767 })); 768 } 769 770 babelHelpers.taggedTemplateLiteral = _taggedTemplateLiteral; 771 772 function _taggedTemplateLiteralLoose(strings, raw) { 773 if (!raw) { 774 raw = strings.slice(0); 775 } 776 777 strings.raw = raw; 778 return strings; 779 } 780 781 babelHelpers.taggedTemplateLiteralLoose = _taggedTemplateLiteralLoose; 782 783 function _temporalRef(val, name) { 784 if (val === babelHelpers.temporalUndefined) { 785 throw new ReferenceError(name + " is not defined - temporal dead zone"); 786 } else { 787 return val; 788 } 789 } 790 791 babelHelpers.temporalRef = _temporalRef; 792 793 function _readOnlyError(name) { 794 throw new Error("\"" + name + "\" is read-only"); 795 } 796 797 babelHelpers.readOnlyError = _readOnlyError; 798 799 function _classNameTDZError(name) { 800 throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); 801 } 802 803 babelHelpers.classNameTDZError = _classNameTDZError; 804 babelHelpers.temporalUndefined = {}; 805 806 function _slicedToArray(arr, i) { 807 return babelHelpers.arrayWithHoles(arr) || babelHelpers.iterableToArrayLimit(arr, i) || babelHelpers.nonIterableRest(); 808 } 809 810 babelHelpers.slicedToArray = _slicedToArray; 811 812 function _slicedToArrayLoose(arr, i) { 813 return babelHelpers.arrayWithHoles(arr) || babelHelpers.iterableToArrayLimitLoose(arr, i) || babelHelpers.nonIterableRest(); 814 } 815 816 babelHelpers.slicedToArrayLoose = _slicedToArrayLoose; 817 818 function _toArray(arr) { 819 return babelHelpers.arrayWithHoles(arr) || babelHelpers.iterableToArray(arr) || babelHelpers.nonIterableRest(); 820 } 821 822 babelHelpers.toArray = _toArray; 823 824 function _toConsumableArray(arr) { 825 return babelHelpers.arrayWithoutHoles(arr) || babelHelpers.iterableToArray(arr) || babelHelpers.nonIterableSpread(); 826 } 827 828 babelHelpers.toConsumableArray = _toConsumableArray; 829 830 function _arrayWithoutHoles(arr) { 831 if (Array.isArray(arr)) { 832 for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; 833 834 return arr2; 835 } 836 } 837 838 babelHelpers.arrayWithoutHoles = _arrayWithoutHoles; 839 840 function _arrayWithHoles(arr) { 841 if (Array.isArray(arr)) return arr; 842 } 843 844 babelHelpers.arrayWithHoles = _arrayWithHoles; 845 846 function _iterableToArray(iter) { 847 if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); 848 } 849 850 babelHelpers.iterableToArray = _iterableToArray; 851 852 function _iterableToArrayLimit(arr, i) { 853 var _arr = []; 854 var _n = true; 855 var _d = false; 856 var _e = undefined; 857 858 try { 859 for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { 860 _arr.push(_s.value); 861 862 if (i && _arr.length === i) break; 863 } 864 } catch (err) { 865 _d = true; 866 _e = err; 867 } finally { 868 try { 869 if (!_n && _i["return"] != null) _i["return"](); 870 } finally { 871 if (_d) throw _e; 872 } 873 } 874 875 return _arr; 876 } 877 878 babelHelpers.iterableToArrayLimit = _iterableToArrayLimit; 879 880 function _iterableToArrayLimitLoose(arr, i) { 881 var _arr = []; 882 883 for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { 884 _arr.push(_step.value); 885 886 if (i && _arr.length === i) break; 887 } 888 889 return _arr; 890 } 891 892 babelHelpers.iterableToArrayLimitLoose = _iterableToArrayLimitLoose; 893 894 function _nonIterableSpread() { 895 throw new TypeError("Invalid attempt to spread non-iterable instance"); 896 } 897 898 babelHelpers.nonIterableSpread = _nonIterableSpread; 899 900 function _nonIterableRest() {
901 throw new TypeError("Invalid attempt to destructure non-iterable instance"); 902 } 903 904 babelHelpers.nonIterableRest = _nonIterableRest; 905 906 function _skipFirstGeneratorNext(fn) { 907 return function () { 908 var it = fn.apply(this, arguments); 909 it.next(); 910 return it; 911 }; 912 } 913 914 babelHelpers.skipFirstGeneratorNext = _skipFirstGeneratorNext; 915 916 function _toPropertyKey(key) { 917 if (typeof key === "symbol") { 918 return key; 919 } else { 920 return String(key); 921 } 922 } 923 924 babelHelpers.toPropertyKey = _toPropertyKey; 925 926 function _initializerWarningHelper(descriptor, context) { 927 throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and set to use loose mode. ' + 'To use proposal-class-properties in spec mode with decorators, wait for ' + 'the next major version of decorators in stage 2.'); 928 } 929 930 babelHelpers.initializerWarningHelper = _initializerWarningHelper; 931 932 function _initializerDefineProperty(target, property, descriptor, context) { 933 if (!descriptor) return; 934 Object.defineProperty(target, property, { 935 enumerable: descriptor.enumerable, 936 configurable: descriptor.configurable, 937 writable: descriptor.writable, 938 value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 939 }); 940 } 941 942 babelHelpers.initializerDefineProperty = _initializerDefineProperty; 943 944 function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { 945 var desc = {}; 946 Object['ke' + 'ys'](descriptor).forEach(function (key) { 947 desc[key] = descriptor[key]; 948 }); 949 desc.enumerable = !!desc.enumerable; 950 desc.configurable = !!desc.configurable; 951 952 if ('value' in desc || desc.initializer) { 953 desc.writable = true; 954 } 955 956 desc = decorators.slice().reverse().reduce(function (desc, decorator) { 957 return decorator(target, property, desc) || desc; 958 }, desc); 959 960 if (context && desc.initializer !== void 0) { 961 desc.value = desc.initializer ? desc.initializer.call(context) : void 0; 962 desc.initializer = undefined; 963 } 964 965 if (desc.initializer === void 0) { 966 Object['define' + 'Property'](target, property, desc); 967 desc = null; 968 } 969 970 return desc; 971 } 972 973 babelHelpers.applyDecoratedDescriptor = _applyDecoratedDescriptor; 974 var id = 0; 975 976 function _classPrivateFieldKey(name) { 977 return "__private_" + id++ + "_" + name; 978 } 979 980 babelHelpers.classPrivateFieldLooseKey = _classPrivateFieldKey; 981 982 function _classPrivateFieldBase(receiver, privateKey) { 983 if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { 984 throw new TypeError("attempted to use private field on non-instance"); 985 } 986 987 return receiver; 988 } 989 990 babelHelpers.classPrivateFieldLooseBase = _classPrivateFieldBase; 991 992 function _classPrivateFieldGet(receiver, privateMap) { 993 if (!privateMap.has(receiver)) { 994 throw new TypeError("attempted to get private field on non-instance"); 995 } 996 997 return privateMap.get(receiver).value; 998 } 999 1000 babelHelpers.classPrivateFieldGet = _classPrivateFieldGet; 1001 1002 function _classPrivateFieldSet(receiver, privateMap, value) { 1003 if (!privateMap.has(receiver)) { 1004 throw new TypeError("attempted to set private field on non-instance"); 1005 } 1006 1007 var descriptor = privateMap.get(receiver); 1008 1009 if (!descriptor.writable) { 1010 throw new TypeError("attempted to set read only private field"); 1011 } 1012 1013 descriptor.value = value; 1014 return value; 1015 } 1016 1017 babelHelpers.classPrivateFieldSet = _classPrivateFieldSet; 1018})(typeof global === "undefined" ? window : global); 1019 1020/** 1021 * Copyright (c) 2014-present, Facebook, Inc. 1022 * 1023 * This source code is licensed under the MIT license found in the 1024 * LICENSE file in the root directory of this source tree. 1025 */ 1026 1027!(function(global) { 1028 "use strict"; 1029 1030 var Op = Object.prototype; 1031 var hasOwn = Op.hasOwnProperty; 1032 var undefined; // More compressible than void 0. 1033 var $Symbol = typeof Symbol === "function" ? Symbol : {}; 1034 var iteratorSymbol = $Symbol.iterator || "@@iterator"; 1035 var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator"; 1036 var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; 1037 1038 // Define the runtime globally (as expected by generated code) as either 1039 // module.exports (if we're in a module) or a new, empty object. 1040 var runtime = global.regeneratorRuntime = {}; 1041 1042 function wrap(innerFn, outerFn, self, tryLocsList) { 1043 // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator. 1044 var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; 1045 var generator = Object.create(protoGenerator.prototype); 1046 var context = new Context(tryLocsList || []); 1047 1048 // The ._invoke method unifies the implementations of the .next, 1049 // .throw, and .return methods. 1050 generator._invoke = makeInvokeMethod(innerFn, self, context); 1051 1052 return generator; 1053 } 1054 runtime.wrap = wrap; 1055 1056 // Try/catch helper to minimize deoptimizations. Returns a completion 1057 // record like context.tryEntries[i].completion. This interface could
vendor: 10,591 bytes, lines 1058-1351
1058 // have been (and was previously) designed to take a closure to be 1059 // invoked without arguments, but in all the cases we care about we 1060 // already have an existing method we want to call, so there's no need 1061 // to create a new function object. We can even get away with assuming 1062 // the method takes exactly one argument, since that happens to be true 1063 // in every case, so we don't have to touch the arguments object. The 1064 // only additional allocation required is the completion record, which 1065 // has a stable shape and so hopefully should be cheap to allocate. 1066 function tryCatch(fn, obj, arg) { 1067 try { 1068 return { type: "normal", arg: fn.call(obj, arg) }; 1069 } catch (err) { 1070 return { type: "throw", arg: err }; 1071 } 1072 } 1073 1074 var GenStateSuspendedStart = "suspendedStart"; 1075 var GenStateSuspendedYield = "suspendedYield"; 1076 var GenStateExecuting = "executing"; 1077 var GenStateCompleted = "completed"; 1078 1079 // Returning this object from the innerFn has the same effect as 1080 // breaking out of the dispatch switch statement. 1081 var ContinueSentinel = {}; 1082 1083 // Dummy constructor functions that we use as the .constructor and 1084 // .constructor.prototype properties for functions that return Generator 1085 // objects. For full spec compliance, you may wish to configure your 1086 // minifier not to mangle the names of these two functions. 1087 function Generator() {} 1088 function GeneratorFunction() {} 1089 function GeneratorFunctionPrototype() {} 1090 1091 // This is a polyfill for %IteratorPrototype% for environments that 1092 // don't natively support it. 1093 var IteratorPrototype = {}; 1094 IteratorPrototype[iteratorSymbol] = function () { 1095 return this; 1096 }; 1097 1098 var getProto = Object.getPrototypeOf; 1099 var NativeIteratorPrototype = getProto && getProto(getProto(values([]))); 1100 if (NativeIteratorPrototype && 1101 NativeIteratorPrototype !== Op && 1102 hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) { 1103 // This environment has a native %IteratorPrototype%; use it instead 1104 // of the polyfill. 1105 IteratorPrototype = NativeIteratorPrototype; 1106 } 1107 1108 var Gp = GeneratorFunctionPrototype.prototype = 1109 Generator.prototype = Object.create(IteratorPrototype); 1110 GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; 1111 GeneratorFunctionPrototype.constructor = GeneratorFunction; 1112 GeneratorFunctionPrototype[toStringTagSymbol] = 1113 GeneratorFunction.displayName = "GeneratorFunction"; 1114 1115 // Helper for defining the .next, .throw, and .return methods of the 1116 // Iterator interface in terms of a single ._invoke method. 1117 function defineIteratorMethods(prototype) { 1118 ["next", "throw", "return"].forEach(function(method) { 1119 prototype[method] = function(arg) { 1120 return this._invoke(method, arg); 1121 }; 1122 }); 1123 } 1124 1125 runtime.isGeneratorFunction = function(genFun) { 1126 var ctor = typeof genFun === "function" && genFun.constructor; 1127 return ctor 1128 ? ctor === GeneratorFunction || 1129 // For the native GeneratorFunction constructor, the best we can 1130 // do is to check its .name property. 1131 (ctor.displayName || ctor.name) === "GeneratorFunction" 1132 : false; 1133 }; 1134 1135 runtime.mark = function(genFun) { 1136 if (Object.setPrototypeOf) { 1137 Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); 1138 } else { 1139 genFun.__proto__ = GeneratorFunctionPrototype; 1140 if (!(toStringTagSymbol in genFun)) { 1141 genFun[toStringTagSymbol] = "GeneratorFunction"; 1142 } 1143 } 1144 genFun.prototype = Object.create(Gp); 1145 return genFun; 1146 }; 1147 1148 // Within the body of any async function, `await x` is transformed to 1149 // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test 1150 // `hasOwn.call(value, "__await")` to determine if the yielded value is 1151 // meant to be awaited. 1152 runtime.awrap = function(arg) { 1153 return { __await: arg }; 1154 }; 1155 1156 function AsyncIterator(generator) { 1157 function invoke(method, arg, resolve, reject) { 1158 var record = tryCatch(generator[method], generator, arg); 1159 if (record.type === "throw") { 1160 reject(record.arg); 1161 } else { 1162 var result = record.arg; 1163 var value = result.value; 1164 if (value && 1165 typeof value === "object" && 1166 hasOwn.call(value, "__await")) { 1167 return Promise.resolve(value.__await).then(function(value) { 1168 invoke("next", value, resolve, reject); 1169 }, function(err) { 1170 invoke("throw", err, resolve, reject); 1171 }); 1172 } 1173 1174 return Promise.resolve(value).then(function(unwrapped) { 1175 // When a yielded Promise is resolved, its final value becomes 1176 // the .value of the Promise<{value,done}> result for the 1177 // current iteration. If the Promise is rejected, however, the 1178 // result for this iteration will be rejected with the same 1179 // reason. Note that rejections of yielded Promises are not 1180 // thrown back into the generator function, as is the case 1181 // when an awaited Promise is rejected. This difference in 1182 // behavior between yield and await is important, because it 1183 // allows the consumer to decide what to do with the yielded 1184 // rejection (swallow it and continue, manually .throw it back 1185 // into the generator, abandon iteration, whatever). With 1186 // await, by contrast, there is no opportunity to examine the 1187 // rejection reason outside the generator function, so the 1188 // only option is to throw it from the await expression, and 1189 // let the generator function handle the exception. 1190 result.value = unwrapped; 1191 resolve(result); 1192 }, reject); 1193 } 1194 } 1195 1196 var previousPromise; 1197 1198 function enqueue(method, arg) { 1199 function callInvokeWithMethodAndArg() { 1200 return new Promise(function(resolve, reject) { 1201 invoke(method, arg, resolve, reject); 1202 }); 1203 } 1204 1205 return previousPromise = 1206 // If enqueue has been called before, then we want to wait until 1207 // all previous Promises have been resolved before calling invoke, 1208 // so that results are always delivered in the correct order. If 1209 // enqueue has not been called before, then it is important to 1210 // call invoke immediately, without waiting on a callback to fire, 1211 // so that the async generator function has the opportunity to do 1212 // any necessary setup in a predictable way. This predictability 1213 // is why the Promise constructor synchronously invokes its 1214 // executor callback, and why async functions synchronously 1215 // execute code before the first await. Since we implement simple 1216 // async functions in terms of async generators, it is especially 1217 // important to get this right, even though it requires care. 1218 previousPromise ? previousPromise.then( 1219 callInvokeWithMethodAndArg, 1220 // Avoid propagating failures to Promises returned by later 1221 // invocations of the iterator. 1222 callInvokeWithMethodAndArg 1223 ) : callInvokeWithMethodAndArg(); 1224 } 1225 1226 // Define the unified helper method that is used to implement .next, 1227 // .throw, and .return (see defineIteratorMethods). 1228 this._invoke = enqueue; 1229 } 1230 1231 defineIteratorMethods(AsyncIterator.prototype); 1232 AsyncIterator.prototype[asyncIteratorSymbol] = function () { 1233 return this; 1234 }; 1235 runtime.AsyncIterator = AsyncIterator; 1236 1237 // Note that simple async functions are implemented on top of 1238 // AsyncIterator objects; they just return a Promise for the value of 1239 // the final result produced by the iterator. 1240 runtime.async = function(innerFn, outerFn, self, tryLocsList) { 1241 var iter = new AsyncIterator( 1242 wrap(innerFn, outerFn, self, tryLocsList) 1243 ); 1244 1245 return runtime.isGeneratorFunction(outerFn) 1246 ? iter // If outerFn is a generator, return the full iterator. 1247 : iter.next().then(function(result) { 1248 return result.done ? result.value : iter.next(); 1249 }); 1250 }; 1251 1252 function makeInvokeMethod(innerFn, self, context) { 1253 var state = GenStateSuspendedStart; 1254 1255 return function invoke(method, arg) { 1256 if (state === GenStateExecuting) { 1257 throw new Error("Generator is already running"); 1258 } 1259 1260 if (state === GenStateCompleted) { 1261 if (method === "throw") { 1262 throw arg; 1263 } 1264 1265 // Be forgiving, per 25.3.3.3.3 of the spec: 1266 // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume 1267 return doneResult(); 1268 } 1269 1270 context.method = method; 1271 context.arg = arg; 1272 1273 while (true) { 1274 var delegate = context.delegate; 1275 if (delegate) { 1276 var delegateResult = maybeInvokeDelegate(delegate, context); 1277 if (delegateResult) { 1278 if (delegateResult === ContinueSentinel) continue; 1279 return delegateResult; 1280 } 1281 } 1282 1283 if (context.method === "next") { 1284 // Setting context._sent for legacy support of Babel's 1285 // function.sent implementation. 1286 context.sent = context._sent = context.arg; 1287 1288 } else if (context.method === "throw") { 1289 if (state === GenStateSuspendedStart) { 1290 state = GenStateCompleted; 1291 throw context.arg; 1292 } 1293 1294 context.dispatchException(context.arg); 1295 1296 } else if (context.method === "return") { 1297 context.abrupt("return", context.arg); 1298 } 1299 1300 state = GenStateExecuting; 1301 1302 var record = tryCatch(innerFn, self, context); 1303 if (record.type === "normal") { 1304 // If an exception is thrown from innerFn, we leave state === 1305 // GenStateExecuting and loop back for another invocation. 1306 state = context.done 1307 ? GenStateCompleted 1308 : GenStateSuspendedYield; 1309 1310 if (record.arg === ContinueSentinel) { 1311 continue; 1312 } 1313 1314 return { 1315 value: record.arg, 1316 done: context.done 1317 }; 1318 1319 } else if (record.type === "throw") { 1320 state = GenStateCompleted; 1321 // Dispatch the exception by looping back around to the 1322 // context.dispatchException(context.arg) call above. 1323 context.method = "throw"; 1324 context.arg = record.arg; 1325 } 1326 } 1327 }; 1328 } 1329 1330 // Call delegate.iterator[context.method](context.arg) and handle the 1331 // result, either by returning a { value, done } result from the 1332 // delegate iterator, or by modifying context.method and context.arg, 1333 // setting context.delegate to null, and returning the ContinueSentinel. 1334 function maybeInvokeDelegate(delegate, context) { 1335 var method = delegate.iterator[context.method]; 1336 if (method === undefined) { 1337 // A .throw or .return when the delegate iterator has no .throw 1338 // method always terminates the yield* loop. 1339 context.delegate = null; 1340 1341 if (context.method === "throw") { 1342 if (delegate.iterator.return) { 1343 // If the delegate iterator has a return method, give it a 1344 // chance to clean up. 1345 context.method = "return"; 1346 context.arg = undefined; 1347 maybeInvokeDelegate(delegate, context); 1348 1349 if (context.method === "throw") { 1350 // If maybeInvokeDelegate(context) changed context.method from 1351 // "return" to "throw", let that override the TypeError below.
vendor: 4,172 bytes, lines 1352-1505
1352 return ContinueSentinel; 1353 } 1354 } 1355 1356 context.method = "throw"; 1357 context.arg = new TypeError( 1358 "The iterator does not provide a 'throw' method"); 1359 } 1360 1361 return ContinueSentinel; 1362 } 1363 1364 var record = tryCatch(method, delegate.iterator, context.arg); 1365 1366 if (record.type === "throw") { 1367 context.method = "throw"; 1368 context.arg = record.arg; 1369 context.delegate = null; 1370 return ContinueSentinel; 1371 } 1372 1373 var info = record.arg; 1374 1375 if (! info) { 1376 context.method = "throw"; 1377 context.arg = new TypeError("iterator result is not an object"); 1378 context.delegate = null; 1379 return ContinueSentinel; 1380 } 1381 1382 if (info.done) { 1383 // Assign the result of the finished delegate to the temporary 1384 // variable specified by delegate.resultName (see delegateYield). 1385 context[delegate.resultName] = info.value; 1386 1387 // Resume execution at the desired location (see delegateYield). 1388 context.next = delegate.nextLoc; 1389 1390 // If context.method was "throw" but the delegate handled the 1391 // exception, let the outer generator proceed normally. If 1392 // context.method was "next", forget context.arg since it has been 1393 // "consumed" by the delegate iterator. If context.method was 1394 // "return", allow the original .return call to continue in the 1395 // outer generator. 1396 if (context.method !== "return") { 1397 context.method = "next"; 1398 context.arg = undefined; 1399 } 1400 1401 } else { 1402 // Re-yield the result returned by the delegate method. 1403 return info; 1404 } 1405 1406 // The delegate iterator is finished, so forget it and continue with 1407 // the outer generator. 1408 context.delegate = null; 1409 return ContinueSentinel; 1410 } 1411 1412 // Define Generator.prototype.{next,throw,return} in terms of the 1413 // unified ._invoke helper method. 1414 defineIteratorMethods(Gp); 1415 1416 Gp[toStringTagSymbol] = "Generator"; 1417 1418 // A Generator should always return itself as the iterator object when the 1419 // @@iterator function is called on it. Some browsers' implementations of the 1420 // iterator prototype chain incorrectly implement this, causing the Generator 1421 // object to not be returned from this call. This ensures that doesn't happen. 1422 // See https://github.com/facebook/regenerator/issues/274 for more details. 1423 Gp[iteratorSymbol] = function() { 1424 return this; 1425 }; 1426 1427 Gp.toString = function() { 1428 return "[object Generator]"; 1429 }; 1430 1431 function pushTryEntry(locs) { 1432 var entry = { tryLoc: locs[0] }; 1433 1434 if (1 in locs) { 1435 entry.catchLoc = locs[1]; 1436 } 1437 1438 if (2 in locs) { 1439 entry.finallyLoc = locs[2]; 1440 entry.afterLoc = locs[3]; 1441 } 1442 1443 this.tryEntries.push(entry); 1444 } 1445 1446 function resetTryEntry(entry) { 1447 var record = entry.completion || {}; 1448 record.type = "normal"; 1449 delete record.arg; 1450 entry.completion = record; 1451 } 1452 1453 function Context(tryLocsList) { 1454 // The root entry object (effectively a try statement without a catch 1455 // or a finally block) gives us a place to store values thrown from 1456 // locations where there is no enclosing try statement. 1457 this.tryEntries = [{ tryLoc: "root" }]; 1458 tryLocsList.forEach(pushTryEntry, this); 1459 this.reset(true); 1460 } 1461 1462 runtime.keys = function(object) { 1463 var keys = []; 1464 for (var key in object) { 1465 keys.push(key); 1466 } 1467 keys.reverse(); 1468 1469 // Rather than returning an object with a next method, we keep 1470 // things simple and return the next function itself. 1471 return function next() { 1472 while (keys.length) { 1473 var key = keys.pop(); 1474 if (key in object) { 1475 next.value = key; 1476 next.done = false; 1477 return next; 1478 } 1479 } 1480 1481 // To avoid creating an additional object, we just hang the .value 1482 // and .done properties off the next function object itself. This 1483 // also ensures that the minifier will not anonymize the function. 1484 next.done = true; 1485 return next; 1486 }; 1487 }; 1488 1489 function values(iterable) { 1490 if (iterable) { 1491 var iteratorMethod = iterable[iteratorSymbol]; 1492 if (iteratorMethod) { 1493 return iteratorMethod.call(iterable); 1494 } 1495 1496 if (typeof iterable.next === "function") { 1497 return iterable; 1498 } 1499 1500 if (!isNaN(iterable.length)) { 1501 var i = -1, next = function next() { 1502 while (++i < iterable.length) { 1503 if (hasOwn.call(iterable, i)) { 1504 next.value = iterable[i]; 1505 next.done = false;
vendor: 10,304 bytes, lines 1506-1901
1506 return next; 1507 } 1508 } 1509 1510 next.value = undefined; 1511 next.done = true; 1512 1513 return next; 1514 }; 1515 1516 return next.next = next; 1517 } 1518 } 1519 1520 // Return an iterator with no values. 1521 return { next: doneResult }; 1522 } 1523 runtime.values = values; 1524 1525 function doneResult() { 1526 return { value: undefined, done: true }; 1527 } 1528 1529 Context.prototype = { 1530 constructor: Context, 1531 1532 reset: function(skipTempReset) { 1533 this.prev = 0; 1534 this.next = 0; 1535 // Resetting context._sent for legacy support of Babel's 1536 // function.sent implementation. 1537 this.sent = this._sent = undefined; 1538 this.done = false; 1539 this.delegate = null; 1540 1541 this.method = "next"; 1542 this.arg = undefined; 1543 1544 this.tryEntries.forEach(resetTryEntry); 1545 1546 if (!skipTempReset) { 1547 for (var name in this) { 1548 // Not sure about the optimal order of these conditions: 1549 if (name.charAt(0) === "t" && 1550 hasOwn.call(this, name) && 1551 !isNaN(+name.slice(1))) { 1552 this[name] = undefined; 1553 } 1554 } 1555 } 1556 }, 1557 1558 stop: function() { 1559 this.done = true; 1560 1561 var rootEntry = this.tryEntries[0]; 1562 var rootRecord = rootEntry.completion; 1563 if (rootRecord.type === "throw") { 1564 throw rootRecord.arg; 1565 } 1566 1567 return this.rval; 1568 }, 1569 1570 dispatchException: function(exception) { 1571 if (this.done) { 1572 throw exception; 1573 } 1574 1575 var context = this; 1576 function handle(loc, caught) { 1577 record.type = "throw"; 1578 record.arg = exception; 1579 context.next = loc; 1580 1581 if (caught) { 1582 // If the dispatched exception was caught by a catch block, 1583 // then let that catch block handle the exception normally. 1584 context.method = "next"; 1585 context.arg = undefined; 1586 } 1587 1588 return !! caught; 1589 } 1590 1591 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 1592 var entry = this.tryEntries[i]; 1593 var record = entry.completion; 1594 1595 if (entry.tryLoc === "root") { 1596 // Exception thrown outside of any try block that could handle 1597 // it, so set the completion value of the entire function to 1598 // throw the exception. 1599 return handle("end"); 1600 } 1601 1602 if (entry.tryLoc <= this.prev) { 1603 var hasCatch = hasOwn.call(entry, "catchLoc"); 1604 var hasFinally = hasOwn.call(entry, "finallyLoc"); 1605 1606 if (hasCatch && hasFinally) { 1607 if (this.prev < entry.catchLoc) { 1608 return handle(entry.catchLoc, true); 1609 } else if (this.prev < entry.finallyLoc) { 1610 return handle(entry.finallyLoc); 1611 } 1612 1613 } else if (hasCatch) { 1614 if (this.prev < entry.catchLoc) { 1615 return handle(entry.catchLoc, true); 1616 } 1617 1618 } else if (hasFinally) { 1619 if (this.prev < entry.finallyLoc) { 1620 return handle(entry.finallyLoc); 1621 } 1622 1623 } else { 1624 throw new Error("try statement without catch or finally"); 1625 } 1626 } 1627 } 1628 }, 1629 1630 abrupt: function(type, arg) { 1631 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 1632 var entry = this.tryEntries[i]; 1633 if (entry.tryLoc <= this.prev && 1634 hasOwn.call(entry, "finallyLoc") && 1635 this.prev < entry.finallyLoc) { 1636 var finallyEntry = entry; 1637 break; 1638 } 1639 } 1640 1641 if (finallyEntry && 1642 (type === "break" || 1643 type === "continue") && 1644 finallyEntry.tryLoc <= arg && 1645 arg <= finallyEntry.finallyLoc) { 1646 // Ignore the finally entry if control is not jumping to a 1647 // location outside the try/catch block. 1648 finallyEntry = null; 1649 } 1650 1651 var record = finallyEntry ? finallyEntry.completion : {}; 1652 record.type = type; 1653 record.arg = arg; 1654 1655 if (finallyEntry) { 1656 this.method = "next"; 1657 this.next = finallyEntry.finallyLoc; 1658 return ContinueSentinel; 1659 } 1660 1661 return this.complete(record); 1662 }, 1663 1664 complete: function(record, afterLoc) { 1665 if (record.type === "throw") { 1666 throw record.arg; 1667 } 1668 1669 if (record.type === "break" || 1670 record.type === "continue") { 1671 this.next = record.arg; 1672 } else if (record.type === "return") { 1673 this.rval = this.arg = record.arg; 1674 this.method = "return"; 1675 this.next = "end"; 1676 } else if (record.type === "normal" && afterLoc) { 1677 this.next = afterLoc; 1678 } 1679 1680 return ContinueSentinel; 1681 }, 1682 1683 finish: function(finallyLoc) { 1684 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 1685 var entry = this.tryEntries[i]; 1686 if (entry.finallyLoc === finallyLoc) { 1687 this.complete(entry.completion, entry.afterLoc); 1688 resetTryEntry(entry); 1689 return ContinueSentinel; 1690 } 1691 } 1692 }, 1693 1694 "catch": function(tryLoc) { 1695 for (var i = this.tryEntries.length - 1; i >= 0; --i) { 1696 var entry = this.tryEntries[i]; 1697 if (entry.tryLoc === tryLoc) { 1698 var record = entry.completion; 1699 if (record.type === "throw") { 1700 var thrown = record.arg; 1701 resetTryEntry(entry); 1702 } 1703 return thrown; 1704 } 1705 } 1706 1707 // The context.catch method must only be called with a location 1708 // argument that corresponds to a known catch block. 1709 throw new Error("illegal catch attempt"); 1710 }, 1711 1712 delegateYield: function(iterable, resultName, nextLoc) { 1713 this.delegate = { 1714 iterator: values(iterable), 1715 resultName: resultName, 1716 nextLoc: nextLoc 1717 }; 1718 1719 if (this.method === "next") { 1720 // Deliberately forget the last sent value so that we don't 1721 // accidentally pass it on to the delegate. 1722 this.arg = undefined; 1723 } 1724 1725 return ContinueSentinel; 1726 } 1727 }; 1728})( 1729 // In sloppy mode, unbound `this` refers to the global object, fallback to 1730 // Function constructor if we're in global strict mode. That is sadly a form 1731 // of indirect eval which violates Content Security Policy. 1732 (function() { return this })() || Function("return this")() 1733); 1734 1735(function (exports) { 1736 'use strict'; 1737 1738 function createCommonjsModule(fn, module) { 1739 return module = { 1740 exports: {} 1741 }, fn(module, module.exports), module.exports; 1742 } 1743 1744 var _global = createCommonjsModule(function (module) { 1745 // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 1746 var global = module.exports = typeof window != 'undefined' && window.Math == Math ? window : typeof self != 'undefined' && self.Math == Math ? self // eslint-disable-next-line no-new-func 1747 : Function('return this')(); 1748 if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef 1749 }); 1750 1751 var hasOwnProperty = {}.hasOwnProperty; 1752 1753 var _has = function (it, key) { 1754 return hasOwnProperty.call(it, key); 1755 }; 1756 1757 var _fails = function (exec) { 1758 try { 1759 return !!exec(); 1760 } catch (e) { 1761 return true; 1762 } 1763 }; 1764 1765 // Thank's IE8 for his funny defineProperty 1766 var _descriptors = !_fails(function () { 1767 return Object.defineProperty({}, 'a', { 1768 get: function get() { 1769 return 7; 1770 } 1771 }).a != 7; 1772 }); 1773 1774 var _core = createCommonjsModule(function (module) { 1775 var core = module.exports = { 1776 version: '2.6.3' 1777 }; 1778 if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef 1779 }); 1780 var _core_1 = _core.version; 1781 1782 var _isObject = function (it) { 1783 return babelHelpers.typeof(it) === 'object' ? it !== null : typeof it === 'function'; 1784 }; 1785 1786 var _anObject = function (it) { 1787 if (!_isObject(it)) throw TypeError(it + ' is not an object!'); 1788 return it; 1789 }; 1790 1791 var document$1 = _global.document; // typeof document.createElement is 'object' in old IE 1792 1793 1794 var is = _isObject(document$1) && _isObject(document$1.createElement); 1795 1796 var _domCreate = function (it) { 1797 return is ? document$1.createElement(it) : {}; 1798 }; 1799 1800 var _ie8DomDefine = !_descriptors && !_fails(function () { 1801 return Object.defineProperty(_domCreate('div'), 'a', { 1802 get: function get() { 1803 return 7; 1804 } 1805 }).a != 7; 1806 }); 1807 1808 // 7.1.1 ToPrimitive(input [, PreferredType]) 1809 // instead of the ES6 spec version, we didn't implement @@toPrimitive case 1810 // and the second argument - flag - preferred type is a string 1811 1812 1813 var _toPrimitive = function (it, S) { 1814 if (!_isObject(it)) return it; 1815 var fn, val; 1816 if (S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val; 1817 if (typeof (fn = it.valueOf) == 'function' && !_isObject(val = fn.call(it))) return val; 1818 if (!S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val; 1819 throw TypeError("Can't convert object to primitive value"); 1820 }; 1821 1822 var dP = Object.defineProperty; 1823 var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) { 1824 _anObject(O); 1825 P = _toPrimitive(P, true); 1826 _anObject(Attributes); 1827 if (_ie8DomDefine) try { 1828 return dP(O, P, Attributes); 1829 } catch (e) { 1830 /* empty */ 1831 } 1832 if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!'); 1833 if ('value' in Attributes) O[P] = Attributes.value; 1834 return O; 1835 }; 1836 1837 var _objectDp = { 1838 f: f 1839 }; 1840 1841 var _propertyDesc = function (bitmap, value) { 1842 return { 1843 enumerable: !(bitmap & 1), 1844 configurable: !(bitmap & 2), 1845 writable: !(bitmap & 4), 1846 value: value 1847 }; 1848 }; 1849 1850 var _hide = _descriptors ? function (object, key, value) { 1851 return _objectDp.f(object, key, _propertyDesc(1, value)); 1852 } : function (object, key, value) { 1853 object[key] = value; 1854 return object; 1855 }; 1856 1857 var id = 0; 1858 var px = Math.random(); 1859 1860 var _uid = function (key) { 1861 return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); 1862 }; 1863 1864 var _redefine = createCommonjsModule(function (module) { 1865 var SRC = _uid('src'); 1866 1867 var TO_STRING = 'toString'; 1868 var $toString = Function[TO_STRING]; 1869 var TPL = ('' + $toString).split(TO_STRING); 1870 1871 _core.inspectSource = function (it) { 1872 return $toString.call(it); 1873 }; 1874 1875 (module.exports = function (O, key, val, safe) { 1876 var isFunction = typeof val == 'function'; 1877 if (isFunction) _has(val, 'name') || _hide(val, 'name', key); 1878 if (O[key] === val) return; 1879 if (isFunction) _has(val, SRC) || _hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key))); 1880 1881 if (O === _global) { 1882 O[key] = val; 1883 } else if (!safe) { 1884 delete O[key]; 1885 _hide(O, key, val); 1886 } else if (O[key]) { 1887 O[key] = val; 1888 } else { 1889 _hide(O, key, val); 1890 } // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative 1891 1892 })(Function.prototype, TO_STRING, function toString() { 1893 return typeof this == 'function' && this[SRC] || $toString.call(this); 1894 }); 1895 }); 1896 1897 var _aFunction = function (it) { 1898 if (typeof it != 'function') throw TypeError(it + ' is not a function!'); 1899 return it; 1900 }; 1901
vendor: 4,977 bytes, lines 1902-2111
1902 // optional / simple context binding 1903 1904 1905 var _ctx = function (fn, that, length) { 1906 _aFunction(fn); 1907 if (that === undefined) return fn; 1908 1909 switch (length) { 1910 case 1: 1911 return function (a) { 1912 return fn.call(that, a); 1913 }; 1914 1915 case 2: 1916 return function (a, b) { 1917 return fn.call(that, a, b); 1918 }; 1919 1920 case 3: 1921 return function (a, b, c) { 1922 return fn.call(that, a, b, c); 1923 }; 1924 } 1925 1926 return function () 1927 /* ...args */ 1928 { 1929 return fn.apply(that, arguments); 1930 }; 1931 }; 1932 1933 var PROTOTYPE = 'prototype'; 1934 1935 var $export = function $export(type, name, source) { 1936 var IS_FORCED = type & $export.F; 1937 var IS_GLOBAL = type & $export.G; 1938 var IS_STATIC = type & $export.S; 1939 var IS_PROTO = type & $export.P; 1940 var IS_BIND = type & $export.B; 1941 var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] || (_global[name] = {}) : (_global[name] || {})[PROTOTYPE]; 1942 var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {}); 1943 var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {}); 1944 var key, own, out, exp; 1945 if (IS_GLOBAL) source = name; 1946 1947 for (key in source) { 1948 // contains in native 1949 own = !IS_FORCED && target && target[key] !== undefined; // export native or passed 1950 1951 out = (own ? target : source)[key]; // bind timers to global for call from export context 1952 1953 exp = IS_BIND && own ? _ctx(out, _global) : IS_PROTO && typeof out == 'function' ? _ctx(Function.call, out) : out; // extend global 1954 1955 if (target) _redefine(target, key, out, type & $export.U); // export 1956 1957 if (exports[key] != out) _hide(exports, key, exp); 1958 if (IS_PROTO && expProto[key] != out) expProto[key] = out; 1959 } 1960 }; 1961 1962 $export.F = 1; // forced 1963 1964 $export.G = 2; // global 1965 1966 $export.S = 4; // static 1967 1968 $export.P = 8; // proto 1969 1970 $export.B = 16; // bind 1971 1972 $export.W = 32; // wrap 1973 1974 $export.U = 64; // safe 1975 1976 $export.R = 128; // real proto method for `library` 1977 1978 var _export = $export; 1979 1980 var _meta = createCommonjsModule(function (module) { 1981 var META = _uid('meta'); 1982 1983 1984 1985 1986 1987 var setDesc = _objectDp.f; 1988 1989 var id = 0; 1990 1991 var isExtensible = Object.isExtensible || function () { 1992 return true; 1993 }; 1994 1995 var FREEZE = !_fails(function () { 1996 return isExtensible(Object.preventExtensions({})); 1997 }); 1998 1999 var setMeta = function setMeta(it) { 2000 setDesc(it, META, { 2001 value: { 2002 i: 'O' + ++id, 2003 // object ID 2004 w: {} // weak collections IDs 2005 2006 } 2007 }); 2008 }; 2009 2010 var fastKey = function fastKey(it, create) { 2011 // return primitive with prefix 2012 if (!_isObject(it)) return babelHelpers.typeof(it) == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; 2013 2014 if (!_has(it, META)) { 2015 // can't set metadata to uncaught frozen object 2016 if (!isExtensible(it)) return 'F'; // not necessary to add metadata 2017 2018 if (!create) return 'E'; // add missing metadata 2019 2020 setMeta(it); // return object ID 2021 } 2022 2023 return it[META].i; 2024 }; 2025 2026 var getWeak = function getWeak(it, create) { 2027 if (!_has(it, META)) { 2028 // can't set metadata to uncaught frozen object 2029 if (!isExtensible(it)) return true; // not necessary to add metadata 2030 2031 if (!create) return false; // add missing metadata 2032 2033 setMeta(it); // return hash weak collections IDs 2034 } 2035 2036 return it[META].w; 2037 }; // add metadata on freeze-family methods calling 2038 2039 2040 var onFreeze = function onFreeze(it) { 2041 if (FREEZE && meta.NEED && isExtensible(it) && !_has(it, META)) setMeta(it); 2042 return it; 2043 }; 2044 2045 var meta = module.exports = { 2046 KEY: META, 2047 NEED: false, 2048 fastKey: fastKey, 2049 getWeak: getWeak, 2050 onFreeze: onFreeze 2051 }; 2052 }); 2053 var _meta_1 = _meta.KEY; 2054 var _meta_2 = _meta.NEED; 2055 var _meta_3 = _meta.fastKey; 2056 var _meta_4 = _meta.getWeak; 2057 var _meta_5 = _meta.onFreeze; 2058 2059 var _library = false; 2060 2061 var _shared = createCommonjsModule(function (module) { 2062 var SHARED = '__core-js_shared__'; 2063 var store = _global[SHARED] || (_global[SHARED] = {}); 2064 (module.exports = function (key, value) { 2065 return store[key] || (store[key] = value !== undefined ? value : {}); 2066 })('versions', []).push({ 2067 version: _core.version, 2068 mode: _library ? 'pure' : 'global', 2069 copyright: '(c) 2019 Denis Pushkarev (zloirock.ru)' 2070 }); 2071 }); 2072 2073 var _wks = createCommonjsModule(function (module) { 2074 var store = _shared('wks'); 2075 2076 2077 2078 var _Symbol = _global.Symbol; 2079 2080 var USE_SYMBOL = typeof _Symbol == 'function'; 2081 2082 var $exports = module.exports = function (name) { 2083 return store[name] || (store[name] = USE_SYMBOL && _Symbol[name] || (USE_SYMBOL ? _Symbol : _uid)('Symbol.' + name)); 2084 }; 2085 2086 $exports.store = store; 2087 }); 2088 2089 var def = _objectDp.f; 2090 2091 2092 2093 var TAG = _wks('toStringTag'); 2094 2095 var _setToStringTag = function (it, tag, stat) { 2096 if (it && !_has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { 2097 configurable: true, 2098 value: tag 2099 }); 2100 }; 2101 2102 var f$1 = _wks; 2103 2104 var _wksExt = { 2105 f: f$1 2106 }; 2107 2108 var defineProperty = _objectDp.f; 2109 2110 var _wksDefine = function (name) { 2111 var $Symbol = _core.Symbol || (_core.Symbol = _library ? {}
vendor: 2,295 bytes, lines 2111-2204
2111 : _global.Symbol || {}); 2112 if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { 2113 value: _wksExt.f(name) 2114 }); 2115 }; 2116 2117 var toString = {}.toString; 2118 2119 var _cof = function (it) { 2120 return toString.call(it).slice(8, -1); 2121 }; 2122 2123 // fallback for non-array-like ES3 and non-enumerable old V8 strings 2124 // eslint-disable-next-line no-prototype-builtins 2125 2126 2127 var _iobject = Object('z').propertyIsEnumerable(0) ? Object : function (it) { 2128 return _cof(it) == 'String' ? it.split('') : Object(it); 2129 }; 2130 2131 // 7.2.1 RequireObjectCoercible(argument) 2132 var _defined = function (it) { 2133 if (it == undefined) throw TypeError("Can't call method on " + it); 2134 return it; 2135 }; 2136 2137 // to indexed object, toObject with fallback for non-array-like ES3 strings 2138 2139 2140 2141 2142 var _toIobject = function (it) { 2143 return _iobject(_defined(it)); 2144 }; 2145 2146 // 7.1.4 ToInteger 2147 var ceil = Math.ceil; 2148 var floor = Math.floor; 2149 2150 var _toInteger = function (it) { 2151 return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); 2152 }; 2153 2154 // 7.1.15 ToLength 2155 2156 2157 var min = Math.min; 2158 2159 var _toLength = function (it) { 2160 return it > 0 ? min(_toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 2161 }; 2162 2163 var max = Math.max; 2164 var min$1 = Math.min; 2165 2166 var _toAbsoluteIndex = function (index, length) { 2167 index = _toInteger(index); 2168 return index < 0 ? max(index + length, 0) : min$1(index, length); 2169 }; 2170 2171 // false -> Array#indexOf 2172 // true -> Array#includes 2173 2174 2175 2176 2177 2178 2179 var _arrayIncludes = function (IS_INCLUDES) { 2180 return function ($this, el, fromIndex) { 2181 var O = _toIobject($this); 2182 var length = _toLength(O.length); 2183 var index = _toAbsoluteIndex(fromIndex, length); 2184 var value; // Array#includes uses SameValueZero equality algorithm 2185 // eslint-disable-next-line no-self-compare 2186 2187 if (IS_INCLUDES && el != el) while (length > index) { 2188 value = O[index++]; // eslint-disable-next-line no-self-compare 2189 2190 if (value != value) return true; // Array#indexOf ignores holes, Array#includes - not 2191 } else for (; length > index; index++) { 2192 if (IS_INCLUDES || index in O) { 2193 if (O[index] === el) return IS_INCLUDES || index || 0; 2194 } 2195 } 2196 return !IS_INCLUDES && -1; 2197 }; 2198 }; 2199 2200 var shared = _shared('keys'); 2201 2202 2203 2204 var _sharedKey = function (key) {
2205 return shared[key] || (shared[key] = _uid(key)); 2206 }; 2207 2208 var arrayIndexOf = _arrayIncludes(false); 2209 2210 var IE_PROTO = _sharedKey('IE_PROTO'); 2211 2212 var _objectKeysInternal = function (object, names) { 2213 var O = _toIobject(object); 2214 var i = 0; 2215 var result = []; 2216 var key; 2217 2218 for (key in O) { 2219 if (key != IE_PROTO) _has(O, key) && result.push(key); 2220 } // Don't enum bug & hidden keys 2221 2222 2223 while (names.length > i) { 2224 if (_has(O, key = names[i++])) { 2225 ~arrayIndexOf(result, key) || result.push(key); 2226 } 2227 } 2228 2229 return result; 2230 }; 2231 2232 // IE 8- don't enum bug keys 2233 var _enumBugKeys = 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'.split(','); 2234 2235 // 19.1.2.14 / 15.2.3.14 Object.keys(O) 2236 2237 2238 2239 2240 var _objectKeys = Object.keys || function keys(O) { 2241 return _objectKeysInternal(O, _enumBugKeys); 2242 }; 2243 2244 var f$2 = Object.getOwnPropertySymbols; 2245 2246 var _objectGops = { 2247 f: f$2 2248 }; 2249 2250 var f$3 = {}.propertyIsEnumerable; 2251 2252 var _objectPie = { 2253 f: f$3 2254 }; 2255 2256 // all enumerable object keys, includes symbols 2257 2258 2259 2260 2261 2262 2263 var _enumKeys = function (it) { 2264 var result = _objectKeys(it); 2265 var getSymbols = _objectGops.f; 2266 2267 if (getSymbols) { 2268 var symbols = getSymbols(it); 2269 var isEnum = _objectPie.f; 2270 var i = 0; 2271 var key; 2272 2273 while (symbols.length > i) { 2274 if (isEnum.call(it, key = symbols[i++])) result.push(key); 2275 } 2276 } 2277 2278 return result; 2279 }; 2280 2281 // 7.2.2 IsArray(argument) 2282 2283 2284 var _isArray = Array.isArray || function isArray(arg) { 2285 return _cof(arg) == 'Array'; 2286 }; 2287 2288 var _objectDps = _descriptors ? Object.defineProperties : function defineProperties(O, Properties) { 2289 _anObject(O); 2290 var keys = _objectKeys(Properties); 2291 var length = keys.length; 2292 var i = 0; 2293 var P; 2294 2295 while (length > i) { 2296 _objectDp.f(O, P = keys[i++], Properties[P]); 2297 } 2298 2299 return O; 2300 }; 2301 2302 var document$2 = _global.document; 2303 2304 var _html = document$2 && document$2.documentElement; 2305 2306 // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) 2307 2308 2309 2310 2311 2312 2313 var IE_PROTO$1 = _sharedKey('IE_PROTO'); 2314 2315 var Empty = function Empty() { 2316 /* empty */ 2317 }; 2318 2319 var PROTOTYPE$1 = 'prototype'; // Create object with fake `null` prototype: use iframe Object with cleared prototype 2320 2321 var _createDict = function createDict() { 2322 // Thrash, waste and sodomy: IE GC bug 2323 var iframe = _domCreate('iframe'); 2324 2325 var i = _enumBugKeys.length; 2326 var lt = '<'; 2327 var gt = '>'; 2328 var iframeDocument; 2329 iframe.style.display = 'none'; 2330 2331 _html.appendChild(iframe); 2332 2333 iframe.src = 'javascript:'; // eslint-disable-line no-script-url 2334 // createDict = iframe.contentWindow.Object; 2335 // html.removeChild(iframe); 2336 2337 iframeDocument = iframe.contentWindow.document; 2338 iframeDocument.open(); 2339 iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt); 2340 iframeDocument.close(); 2341 _createDict = iframeDocument.F; 2342 2343 while (i--) { 2344 delete _createDict[PROTOTYPE$1][_enumBugKeys[i]]; 2345 } 2346 2347 return _createDict(); 2348 }; 2349 2350 var _objectCreate = Object.create || function create(O, Properties) { 2351 var result; 2352 2353 if (O !== null) { 2354 Empty[PROTOTYPE$1] = _anObject(O); 2355 result = new Empty(); 2356 Empty[PROTOTYPE$1] = null; // add "__proto__" for Object.getPrototypeOf polyfill 2357 2358 result[IE_PROTO$1] = O; 2359 } else result = _createDict(); 2360 2361 return Properties === undefined ? result : _objectDps(result, Properties); 2362 }; 2363 2364 // 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O) 2365 2366 2367 var hiddenKeys = _enumBugKeys.concat('length', 'prototype'); 2368 2369 var f$4 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { 2370 return _objectKeysInternal(O, hiddenKeys); 2371 }; 2372 2373 var _objectGopn = { 2374 f: f$4 2375 }; 2376 2377 // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window 2378 2379 2380 var gOPN = _objectGopn.f; 2381 2382 var toString$1 = {}.toString; 2383 var windowNames = (typeof window === "undefined" ? "undefined" : babelHelpers.typeof(window)) == 'object' && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : []; 2384 2385 var getWindowNames = function getWindowNames(it) { 2386 try { 2387 return gOPN(it); 2388 } catch (e) { 2389 return windowNames.slice(); 2390 } 2391 }; 2392 2393 var f$5 = function getOwnPropertyNames(it) { 2394 return windowNames && toString$1.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(_toIobject(it)); 2395 }; 2396 2397 var _objectGopnExt = { 2398 f: f$5 2399 }; 2400 2401 var gOPD = Object.getOwnPropertyDescriptor; 2402 var f$6 = _descriptors ? gOPD : function getOwnPropertyDescriptor(O, P) { 2403 O = _toIobject(O); 2404 P = _toPrimitive(P, true); 2405 if (_ie8DomDefine) try { 2406 return gOPD(O, P); 2407 } catch (e) { 2408 /* empty */ 2409 } 2410 if (_has(O, P)) return _propertyDesc(!_objectPie.f.call(O, P), O[P]); 2411 }; 2412 2413 var _objectGopd = { 2414 f: f$6 2415 }; 2416 2417 var META = _meta.KEY; 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 var gOPD$1 = _objectGopd.f; 2458 var dP$1 = _objectDp.f; 2459 var gOPN$1 = _objectGopnExt.f; 2460 var $Symbol = _global.Symbol; 2461 var $JSON = _global.JSON; 2462 2463 var _stringify = $JSON && $JSON.stringify; 2464 2465 var PROTOTYPE$2 = 'prototype'; 2466 var HIDDEN = _wks('_hidden'); 2467 var TO_PRIMITIVE = _wks('toPrimitive'); 2468 var isEnum = {}.propertyIsEnumerable; 2469 var SymbolRegistry = _shared('symbol-registry'); 2470 var AllSymbols = _shared('symbols');
vendor: 4,817 bytes, lines 2471-2626
2471 var OPSymbols = _shared('op-symbols'); 2472 var ObjectProto = Object[PROTOTYPE$2]; 2473 var USE_NATIVE = typeof $Symbol == 'function'; 2474 var QObject = _global.QObject; // Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 2475 2476 var setter = !QObject || !QObject[PROTOTYPE$2] || !QObject[PROTOTYPE$2].findChild; // fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 2477 2478 var setSymbolDesc = _descriptors && _fails(function () { 2479 return _objectCreate(dP$1({}, 'a', { 2480 get: function get() { 2481 return dP$1(this, 'a', { 2482 value: 7 2483 }).a; 2484 } 2485 })).a != 7; 2486 }) ? function (it, key, D) { 2487 var protoDesc = gOPD$1(ObjectProto, key); 2488 if (protoDesc) delete ObjectProto[key]; 2489 dP$1(it, key, D); 2490 if (protoDesc && it !== ObjectProto) dP$1(ObjectProto, key, protoDesc); 2491 } : dP$1; 2492 2493 var wrap = function wrap(tag) { 2494 var sym = AllSymbols[tag] = _objectCreate($Symbol[PROTOTYPE$2]); 2495 2496 sym._k = tag; 2497 return sym; 2498 }; 2499 2500 var isSymbol = USE_NATIVE && babelHelpers.typeof($Symbol.iterator) == 'symbol' ? function (it) { 2501 return babelHelpers.typeof(it) == 'symbol'; 2502 } : function (it) { 2503 return it instanceof $Symbol; 2504 }; 2505 2506 var $defineProperty = function defineProperty(it, key, D) { 2507 if (it === ObjectProto) $defineProperty(OPSymbols, key, D); 2508 _anObject(it); 2509 key = _toPrimitive(key, true); 2510 _anObject(D); 2511 2512 if (_has(AllSymbols, key)) { 2513 if (!D.enumerable) { 2514 if (!_has(it, HIDDEN)) dP$1(it, HIDDEN, _propertyDesc(1, {})); 2515 it[HIDDEN][key] = true; 2516 } else { 2517 if (_has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false; 2518 D = _objectCreate(D, { 2519 enumerable: _propertyDesc(0, false) 2520 }); 2521 } 2522 2523 return setSymbolDesc(it, key, D); 2524 } 2525 2526 return dP$1(it, key, D); 2527 }; 2528 2529 var $defineProperties = function defineProperties(it, P) { 2530 _anObject(it); 2531 var keys = _enumKeys(P = _toIobject(P)); 2532 var i = 0; 2533 var l = keys.length; 2534 var key; 2535 2536 while (l > i) { 2537 $defineProperty(it, key = keys[i++], P[key]); 2538 } 2539 2540 return it; 2541 }; 2542 2543 var $create = function create(it, P) { 2544 return P === undefined ? _objectCreate(it) : $defineProperties(_objectCreate(it), P); 2545 }; 2546 2547 var $propertyIsEnumerable = function propertyIsEnumerable(key) { 2548 var E = isEnum.call(this, key = _toPrimitive(key, true)); 2549 if (this === ObjectProto && _has(AllSymbols, key) && !_has(OPSymbols, key)) return false; 2550 return E || !_has(this, key) || !_has(AllSymbols, key) || _has(this, HIDDEN) && this[HIDDEN][key] ? E : true; 2551 }; 2552 2553 var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) { 2554 it = _toIobject(it); 2555 key = _toPrimitive(key, true); 2556 if (it === ObjectProto && _has(AllSymbols, key) && !_has(OPSymbols, key)) return; 2557 var D = gOPD$1(it, key); 2558 if (D && _has(AllSymbols, key) && !(_has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true; 2559 return D; 2560 }; 2561 2562 var $getOwnPropertyNames = function getOwnPropertyNames(it) { 2563 var names = gOPN$1(_toIobject(it)); 2564 var result = []; 2565 var i = 0; 2566 var key; 2567 2568 while (names.length > i) { 2569 if (!_has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key); 2570 } 2571 2572 return result; 2573 }; 2574 2575 var $getOwnPropertySymbols = function getOwnPropertySymbols(it) { 2576 var IS_OP = it === ObjectProto; 2577 var names = gOPN$1(IS_OP ? OPSymbols : _toIobject(it)); 2578 var result = []; 2579 var i = 0; 2580 var key; 2581 2582 while (names.length > i) { 2583 if (_has(AllSymbols, key = names[i++]) && (IS_OP ? _has(ObjectProto, key) : true)) result.push(AllSymbols[key]); 2584 } 2585 2586 return result; 2587 }; // 19.4.1.1 Symbol([description]) 2588 2589 2590 if (!USE_NATIVE) { 2591 $Symbol = function _Symbol() { 2592 if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!'); 2593 var tag = _uid(arguments.length > 0 ? arguments[0] : undefined); 2594 2595 var $set = function $set(value) { 2596 if (this === ObjectProto) $set.call(OPSymbols, value); 2597 if (_has(this, HIDDEN) && _has(this[HIDDEN], tag)) this[HIDDEN][tag] = false; 2598 setSymbolDesc(this, tag, _propertyDesc(1, value)); 2599 }; 2600 2601 if (_descriptors && setter) setSymbolDesc(ObjectProto, tag, { 2602 configurable: true, 2603 set: $set 2604 }); 2605 return wrap(tag); 2606 }; 2607 2608 _redefine($Symbol[PROTOTYPE$2], 'toString', function toString() { 2609 return this._k; 2610 }); 2611 _objectGopd.f = $getOwnPropertyDescriptor; 2612 _objectDp.f = $defineProperty; 2613 _objectGopn.f = _objectGopnExt.f = $getOwnPropertyNames; 2614 _objectPie.f = $propertyIsEnumerable; 2615 _objectGops.f = $getOwnPropertySymbols; 2616 2617 if (_descriptors && !_library) { 2618 _redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true); 2619 } 2620 2621 _wksExt.f = function (name) { 2622 return wrap(_wks(name)); 2623 }; 2624 } 2625 2626 _export(_export.G + _export.W + _export.F * !USE_NATIVE, {
2627 Symbol: $Symbol 2628 }); 2629 2630 for (var es6Symbols = // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14 2631 'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'.split(','), j = 0; es6Symbols.length > j;) { 2632 _wks(es6Symbols[j++]); 2633 } 2634 2635 for (var wellKnownSymbols = _objectKeys(_wks.store), k = 0; wellKnownSymbols.length > k;) { 2636 _wksDefine(wellKnownSymbols[k++]); 2637 } 2638 2639 _export(_export.S + _export.F * !USE_NATIVE, 'Symbol', { 2640 // 19.4.2.1 Symbol.for(key) 2641 'for': function _for(key) { 2642 return _has(SymbolRegistry, key += '') ? SymbolRegistry[key] : SymbolRegistry[key] = $Symbol(key); 2643 }, 2644 // 19.4.2.5 Symbol.keyFor(sym) 2645 keyFor: function keyFor(sym) { 2646 if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!'); 2647 2648 for (var key in SymbolRegistry) { 2649 if (SymbolRegistry[key] === sym) return key; 2650 } 2651 }, 2652 useSetter: function useSetter() { 2653 setter = true; 2654 }, 2655 useSimple: function useSimple() { 2656 setter = false; 2657 } 2658 }); 2659 _export(_export.S + _export.F * !USE_NATIVE, 'Object', { 2660 // 19.1.2.2 Object.create(O [, Properties]) 2661 create: $create, 2662 // 19.1.2.4 Object.defineProperty(O, P, Attributes) 2663 defineProperty: $defineProperty, 2664 // 19.1.2.3 Object.defineProperties(O, Properties) 2665 defineProperties: $defineProperties, 2666 // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P) 2667 getOwnPropertyDescriptor: $getOwnPropertyDescriptor, 2668 // 19.1.2.7 Object.getOwnPropertyNames(O) 2669 getOwnPropertyNames: $getOwnPropertyNames, 2670 // 19.1.2.8 Object.getOwnPropertySymbols(O) 2671 getOwnPropertySymbols: $getOwnPropertySymbols 2672 }); // 24.3.2 JSON.stringify(value [, replacer [, space]]) 2673 2674 $JSON && _export(_export.S + _export.F * (!USE_NATIVE || _fails(function () { 2675 var S = $Symbol(); // MS Edge converts symbol values to JSON as {} 2676 // WebKit converts symbol values to JSON as null 2677 // V8 throws on boxed symbols 2678 2679 return _stringify([S]) != '[null]' || _stringify({ 2680 a: S 2681 }) != '{}' || _stringify(Object(S)) != '{}'; 2682 })), 'JSON', { 2683 stringify: function stringify(it) { 2684 var args = [it]; 2685 var i = 1; 2686 var replacer, $replacer; 2687 2688 while (arguments.length > i) { 2689 args.push(arguments[i++]); 2690 } 2691 2692 $replacer = replacer = args[1]; 2693 if (!_isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined 2694 2695 if (!_isArray(replacer)) replacer = function replacer(key, value) { 2696 if (typeof $replacer == 'function') value = $replacer.call(this, key, value); 2697 if (!isSymbol(value)) return value; 2698 }; 2699 args[1] = replacer; 2700 return _stringify.apply($JSON, args); 2701 } 2702 }); // 19.4.3.4 Symbol.prototype[@@toPrimitive](hint) 2703 2704 $Symbol[PROTOTYPE$2][TO_PRIMITIVE] || _hide($Symbol[PROTOTYPE$2], TO_PRIMITIVE, $Symbol[PROTOTYPE$2].valueOf); // 19.4.3.5 Symbol.prototype[@@toStringTag] 2705 2706 _setToStringTag($Symbol, 'Symbol'); // 20.2.1.9 Math[@@toStringTag] 2707 2708 _setToStringTag(Math, 'Math', true); // 24.3.3 JSON[@@toStringTag] 2709 2710 _setToStringTag(_global.JSON, 'JSON', true); 2711 2712 // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) 2713 2714 2715 _export(_export.S, 'Object', { 2716 create: _objectCreate 2717 }); 2718 2719 // 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes) 2720 2721 2722 _export(_export.S + _export.F * !_descriptors, 'Object', { 2723 defineProperty: _objectDp.f 2724 }); 2725 2726 // 19.1.2.3 / 15.2.3.7 Object.defineProperties(O, Properties) 2727 2728 2729 _export(_export.S + _export.F * !_descriptors, 'Object', { 2730 defineProperties: _objectDps 2731 }); 2732 2733 // most Object methods by ES6 should accept primitives 2734 2735 2736 2737 2738 2739 2740 var _objectSap = function (KEY, exec) { 2741 var fn = (_core.Object || {})[KEY] || Object[KEY]; 2742 var exp = {}; 2743 exp[KEY] = exec(fn); 2744 _export(_export.S + _export.F * _fails(function () { 2745 fn(1); 2746 }), 'Object', exp); 2747 }; 2748 2749 // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P) 2750 2751 2752 var $getOwnPropertyDescriptor$1 = _objectGopd.f; 2753 2754 _objectSap('getOwnPropertyDescriptor', function () { 2755 return function getOwnPropertyDescriptor(it, key) { 2756 return $getOwnPropertyDescriptor$1(_toIobject(it), key); 2757 }; 2758 }); 2759 2760 // 7.1.13 ToObject(argument) 2761 2762 2763 var _toObject = function (it) { 2764 return Object(_defined(it)); 2765 }; 2766 2767 // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O) 2768 2769 2770 2771 2772 var IE_PROTO$2 = _sharedKey('IE_PROTO'); 2773 2774 var ObjectProto$1 = Object.prototype; 2775 2776 var _objectGpo = Object.getPrototypeOf || function (O) { 2777 O = _toObject(O); 2778 if (_has(O, IE_PROTO$2)) return O[IE_PROTO$2]; 2779 2780 if (typeof O.constructor == 'function' && O instanceof O.constructor) { 2781 return O.constructor.prototype; 2782 } 2783 2784 return O instanceof Object ? ObjectProto$1 : null; 2785 }; 2786 2787 // 19.1.2.9 Object.getPrototypeOf(O) 2788 2789 2790 2791 2792 _objectSap('getPrototypeOf', function () { 2793 return function getPrototypeOf(it) { 2794 return _objectGpo(_toObject(it)); 2795 }; 2796 }); 2797
vendor: 37,188 bytes, lines 2798-4260
2798 // 19.1.2.14 Object.keys(O) 2799 2800 2801 2802 2803 _objectSap('keys', function () { 2804 return function keys(it) { 2805 return _objectKeys(_toObject(it)); 2806 }; 2807 }); 2808 2809 // 19.1.2.7 Object.getOwnPropertyNames(O) 2810 _objectSap('getOwnPropertyNames', function () { 2811 return _objectGopnExt.f; 2812 }); 2813 2814 // 19.1.2.5 Object.freeze(O) 2815 2816 2817 var meta = _meta.onFreeze; 2818 2819 _objectSap('freeze', function ($freeze) { 2820 return function freeze(it) { 2821 return $freeze && _isObject(it) ? $freeze(meta(it)) : it; 2822 }; 2823 }); 2824 2825 // 19.1.2.17 Object.seal(O) 2826 2827 2828 var meta$1 = _meta.onFreeze; 2829 2830 _objectSap('seal', function ($seal) { 2831 return function seal(it) { 2832 return $seal && _isObject(it) ? $seal(meta$1(it)) : it; 2833 }; 2834 }); 2835 2836 // 19.1.2.15 Object.preventExtensions(O) 2837 2838 2839 var meta$2 = _meta.onFreeze; 2840 2841 _objectSap('preventExtensions', function ($preventExtensions) { 2842 return function preventExtensions(it) { 2843 return $preventExtensions && _isObject(it) ? $preventExtensions(meta$2(it)) : it; 2844 }; 2845 }); 2846 2847 // 19.1.2.12 Object.isFrozen(O) 2848 2849 2850 _objectSap('isFrozen', function ($isFrozen) { 2851 return function isFrozen(it) { 2852 return _isObject(it) ? $isFrozen ? $isFrozen(it) : false : true; 2853 }; 2854 }); 2855 2856 // 19.1.2.13 Object.isSealed(O) 2857 2858 2859 _objectSap('isSealed', function ($isSealed) { 2860 return function isSealed(it) { 2861 return _isObject(it) ? $isSealed ? $isSealed(it) : false : true; 2862 }; 2863 }); 2864 2865 // 19.1.2.11 Object.isExtensible(O) 2866 2867 2868 _objectSap('isExtensible', function ($isExtensible) { 2869 return function isExtensible(it) { 2870 return _isObject(it) ? $isExtensible ? $isExtensible(it) : true : false; 2871 }; 2872 }); 2873 2874 var $assign = Object.assign; // should work with symbols and should have deterministic property order (V8 bug) 2875 2876 var _objectAssign = !$assign || _fails(function () { 2877 var A = {}; 2878 var B = {}; // eslint-disable-next-line no-undef 2879 2880 var S = Symbol(); 2881 var K = 'abcdefghijklmnopqrst'; 2882 A[S] = 7; 2883 K.split('').forEach(function (k) { 2884 B[k] = k; 2885 }); 2886 return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K; 2887 }) ? function assign(target, source) { 2888 // eslint-disable-line no-unused-vars 2889 var T = _toObject(target); 2890 var aLen = arguments.length; 2891 var index = 1; 2892 var getSymbols = _objectGops.f; 2893 var isEnum = _objectPie.f; 2894 2895 while (aLen > index) { 2896 var S = _iobject(arguments[index++]); 2897 var keys = getSymbols ? _objectKeys(S).concat(getSymbols(S)) : _objectKeys(S); 2898 var length = keys.length; 2899 var j = 0; 2900 var key; 2901 2902 while (length > j) { 2903 if (isEnum.call(S, key = keys[j++])) T[key] = S[key]; 2904 } 2905 } 2906 2907 return T; 2908 } : $assign; 2909 2910 // 19.1.3.1 Object.assign(target, source) 2911 2912 2913 _export(_export.S + _export.F, 'Object', { 2914 assign: _objectAssign 2915 }); 2916 2917 // 7.2.9 SameValue(x, y) 2918 var _sameValue = Object.is || function is(x, y) { 2919 // eslint-disable-next-line no-self-compare 2920 return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y; 2921 }; 2922 2923 // 19.1.3.10 Object.is(value1, value2) 2924 2925 2926 _export(_export.S, 'Object', { 2927 is: _sameValue 2928 }); 2929 2930 // Works with __proto__ only. Old v8 can't work with null proto objects. 2931 2932 /* eslint-disable no-proto */ 2933 2934 2935 2936 2937 var check = function check(O, proto) { 2938 _anObject(O); 2939 if (!_isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!"); 2940 }; 2941 2942 var _setProto = { 2943 set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line 2944 function (test, buggy, set) { 2945 try { 2946 set = _ctx(Function.call, _objectGopd.f(Object.prototype, '__proto__').set, 2); 2947 set(test, []); 2948 buggy = !(test instanceof Array); 2949 } catch (e) { 2950 buggy = true; 2951 } 2952 2953 return function setPrototypeOf(O, proto) { 2954 check(O, proto); 2955 if (buggy) O.__proto__ = proto;else set(O, proto); 2956 return O; 2957 }; 2958 }({}, false) : undefined), 2959 check: check 2960 }; 2961 2962 // 19.1.3.19 Object.setPrototypeOf(O, proto) 2963 2964 2965 _export(_export.S, 'Object', { 2966 setPrototypeOf: _setProto.set 2967 }); 2968 2969 // getting tag from 19.1.3.6 Object.prototype.toString() 2970 2971 2972 var TAG$1 = _wks('toStringTag'); // ES3 wrong here 2973 2974 2975 var ARG = _cof(function () { 2976 return arguments; 2977 }()) == 'Arguments'; // fallback for IE11 Script Access Denied error 2978 2979 var tryGet = function tryGet(it, key) { 2980 try { 2981 return it[key]; 2982 } catch (e) { 2983 /* empty */ 2984 } 2985 }; 2986 2987 var _classof = function (it) { 2988 var O, T, B; 2989 return it === undefined ? 'Undefined' : it === null ? 'Null' // @@toStringTag case 2990 : typeof (T = tryGet(O = Object(it), TAG$1)) == 'string' ? T // builtinTag case 2991 : ARG ? _cof(O) // ES3 arguments fallback 2992 : (B = _cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B; 2993 }; 2994 2995 var test = {}; 2996 test[_wks('toStringTag')] = 'z'; 2997 2998 if (test + '' != '[object z]') { 2999 _redefine(Object.prototype, 'toString', function toString() { 3000 return '[object ' + _classof(this) + ']'; 3001 }, true); 3002 } 3003 3004 // fast apply, http://jsperf.lnkit.com/fast-apply/5 3005 var _invoke = function (fn, args, that) { 3006 var un = that === undefined; 3007 3008 switch (args.length) { 3009 case 0: 3010 return un ? fn() : fn.call(that); 3011 3012 case 1: 3013 return un ? fn(args[0]) : fn.call(that, args[0]); 3014 3015 case 2: 3016 return un ? fn(args[0], args[1]) : fn.call(that, args[0], args[1]); 3017 3018 case 3: 3019 return un ? fn(args[0], args[1], args[2]) : fn.call(that, args[0], args[1], args[2]); 3020 3021 case 4: 3022 return un ? fn(args[0], args[1], args[2], args[3]) : fn.call(that, args[0], args[1], args[2], args[3]); 3023 } 3024 3025 return fn.apply(that, args); 3026 }; 3027 3028 var arraySlice = [].slice; 3029 var factories = {}; 3030 3031 var construct = function construct(F, len, args) { 3032 if (!(len in factories)) { 3033 for (var n = [], i = 0; i < len; i++) { 3034 n[i] = 'a[' + i + ']'; 3035 } // eslint-disable-next-line no-new-func 3036 3037 3038 factories[len] = Function('F,a', 'return new F(' + n.join(',') + ')'); 3039 } 3040 3041 return factories[len](F, args); 3042 }; 3043 3044 var _bind = Function.bind || function bind(that 3045 /* , ...args */ 3046 ) { 3047 var fn = _aFunction(this); 3048 var partArgs = arraySlice.call(arguments, 1); 3049 3050 var bound = function bound() 3051 /* args... */ 3052 { 3053 var args = partArgs.concat(arraySlice.call(arguments)); 3054 return this instanceof bound ? construct(fn, args.length, args) : _invoke(fn, args, that); 3055 }; 3056 3057 if (_isObject(fn.prototype)) bound.prototype = fn.prototype; 3058 return bound; 3059 }; 3060 3061 // 19.2.3.2 / 15.3.4.5 Function.prototype.bind(thisArg, args...) 3062 3063 3064 _export(_export.P, 'Function', { 3065 bind: _bind 3066 }); 3067 3068 var dP$2 = _objectDp.f; 3069 3070 var FProto = Function.prototype; 3071 var nameRE = /^\s*function ([^ (]*)/; 3072 var NAME = 'name'; // 19.2.4.2 name 3073 3074 NAME in FProto || _descriptors && dP$2(FProto, NAME, { 3075 configurable: true, 3076 get: function get() { 3077 try { 3078 return ('' + this).match(nameRE)[1]; 3079 } catch (e) { 3080 return ''; 3081 } 3082 } 3083 }); 3084 3085 var HAS_INSTANCE = _wks('hasInstance'); 3086 3087 var FunctionProto = Function.prototype; // 19.2.3.6 Function.prototype[@@hasInstance](V) 3088 3089 if (!(HAS_INSTANCE in FunctionProto)) _objectDp.f(FunctionProto, HAS_INSTANCE, { 3090 value: function value(O) { 3091 if (typeof this != 'function' || !_isObject(O)) return false; 3092 if (!_isObject(this.prototype)) return O instanceof this; // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this: 3093 3094 while (O = _objectGpo(O)) { 3095 if (this.prototype === O) return true; 3096 } 3097 3098 return false; 3099 } 3100 }); 3101 3102 var _stringWs = "\t\n\x0B\f\r \xA0\u1680\u180E\u2000\u2001\u2002\u2003" + "\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF"; 3103 3104 var space = '[' + _stringWs + ']'; 3105 var non = "\u200B\x85"; 3106 var ltrim = RegExp('^' + space + space + '*'); 3107 var rtrim = RegExp(space + space + '*$'); 3108 3109 var exporter = function exporter(KEY, exec, ALIAS) { 3110 var exp = {}; 3111 var FORCE = _fails(function () { 3112 return !!_stringWs[KEY]() || non[KEY]() != non; 3113 }); 3114 var fn = exp[KEY] = FORCE ? exec(trim) : _stringWs[KEY]; 3115 if (ALIAS) exp[ALIAS] = fn; 3116 _export(_export.P + _export.F * FORCE, 'String', exp); 3117 }; // 1 -> String#trimLeft 3118 // 2 -> String#trimRight 3119 // 3 -> String#trim 3120 3121 3122 var trim = exporter.trim = function (string, TYPE) { 3123 string = String(_defined(string)); 3124 if (TYPE & 1) string = string.replace(ltrim, ''); 3125 if (TYPE & 2) string = string.replace(rtrim, ''); 3126 return string; 3127 }; 3128 3129 var _stringTrim = exporter; 3130 3131 var $parseInt = _global.parseInt; 3132 3133 var $trim = _stringTrim.trim; 3134 3135 3136 3137 var hex = /^[-+]?0[xX]/; 3138 var _parseInt = $parseInt(_stringWs + '08') !== 8 || $parseInt(_stringWs + '0x16') !== 22 ? function parseInt(str, radix) { 3139 var string = $trim(String(str), 3); 3140 return $parseInt(string, radix >>> 0 || (hex.test(string) ? 16 : 10)); 3141 } : $parseInt; 3142 3143 // 18.2.5 parseInt(string, radix) 3144 3145 3146 _export(_export.G + _export.F * (parseInt != _parseInt), { 3147 parseInt: _parseInt 3148 }); 3149 3150 var $parseFloat = _global.parseFloat; 3151 3152 var $trim$1 = _stringTrim.trim; 3153 3154 var _parseFloat = 1 / $parseFloat(_stringWs + '-0') !== -Infinity ? function parseFloat(str) { 3155 var string = $trim$1(String(str), 3); 3156 var result = $parseFloat(string); 3157 return result === 0 && string.charAt(0) == '-' ? -0 : result; 3158 } : $parseFloat; 3159 3160 // 18.2.4 parseFloat(string) 3161 3162 3163 _export(_export.G + _export.F * (parseFloat != _parseFloat), { 3164 parseFloat: _parseFloat 3165 }); 3166 3167 var setPrototypeOf = _setProto.set; 3168 3169 var _inheritIfRequired = function (that, target, C) { 3170 var S = target.constructor; 3171 var P; 3172 3173 if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && _isObject(P) && setPrototypeOf) { 3174 setPrototypeOf(that, P); 3175 } 3176 3177 return that; 3178 }; 3179 3180 var gOPN$2 = _objectGopn.f; 3181 3182 var gOPD$2 = _objectGopd.f; 3183 3184 var dP$3 = _objectDp.f; 3185 3186 var $trim$2 = _stringTrim.trim; 3187 3188 var NUMBER = 'Number'; 3189 var $Number = _global[NUMBER]; 3190 var Base = $Number; 3191 var proto = $Number.prototype; // Opera ~12 has broken Object#toString 3192 3193 var BROKEN_COF = _cof(_objectCreate(proto)) == NUMBER; 3194 var TRIM = 'trim' in String.prototype; // 7.1.3 ToNumber(argument) 3195 3196 var toNumber = function toNumber(argument) { 3197 var it = _toPrimitive(argument, false); 3198 3199 if (typeof it == 'string' && it.length > 2) { 3200 it = TRIM ? it.trim() : $trim$2(it, 3); 3201 var first = it.charCodeAt(0); 3202 var third, radix, maxCode; 3203 3204 if (first === 43 || first === 45) { 3205 third = it.charCodeAt(2); 3206 if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix 3207 } else if (first === 48) { 3208 switch (it.charCodeAt(1)) { 3209 case 66: 3210 case 98: 3211 radix = 2; 3212 maxCode = 49; 3213 break; 3214 // fast equal /^0b[01]+$/i 3215 3216 case 79: 3217 case 111: 3218 radix = 8; 3219 maxCode = 55; 3220 break; 3221 // fast equal /^0o[0-7]+$/i 3222 3223 default: 3224 return +it; 3225 } 3226 3227 for (var digits = it.slice(2), i = 0, l = digits.length, code; i < l; i++) { 3228 code = digits.charCodeAt(i); // parseInt parses a string to a first unavailable symbol 3229 // but ToNumber should return NaN if a string contains unavailable symbols 3230 3231 if (code < 48 || code > maxCode) return NaN; 3232 } 3233 3234 return parseInt(digits, radix); 3235 } 3236 } 3237 3238 return +it; 3239 }; 3240 3241 if (!$Number(' 0o1') || !$Number('0b1') || $Number('+0x1')) { 3242 $Number = function Number(value) { 3243 var it = arguments.length < 1 ? 0 : value; 3244 var that = this; 3245 return that instanceof $Number // check on 1..constructor(foo) case 3246 && (BROKEN_COF ? _fails(function () { 3247 proto.valueOf.call(that); 3248 }) : _cof(that) != NUMBER) ? _inheritIfRequired(new Base(toNumber(it)), that, $Number) : toNumber(it); 3249 }; 3250 3251 for (var keys = _descriptors ? gOPN$2(Base) : ( // ES3: 3252 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + // ES6 (in case, if modules with ES6 Number statics required before): 3253 'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' + 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger').split(','), j$1 = 0, key; keys.length > j$1; j$1++) { 3254 if (_has(Base, key = keys[j$1]) && !_has($Number, key)) { 3255 dP$3($Number, key, gOPD$2(Base, key)); 3256 } 3257 } 3258 3259 $Number.prototype = proto; 3260 proto.constructor = $Number; 3261 3262 _redefine(_global, NUMBER, $Number); 3263 } 3264 3265 var _aNumberValue = function (it, msg) { 3266 if (typeof it != 'number' && _cof(it) != 'Number') throw TypeError(msg); 3267 return +it; 3268 }; 3269 3270 var _stringRepeat = function repeat(count) { 3271 var str = String(_defined(this)); 3272 var res = ''; 3273 var n = _toInteger(count); 3274 if (n < 0 || n == Infinity) throw RangeError("Count can't be negative"); 3275 3276 for (; n > 0; (n >>>= 1) && (str += str)) { 3277 if (n & 1) res += str; 3278 } 3279 3280 return res; 3281 }; 3282 3283 var $toFixed = 1.0.toFixed; 3284 var floor$1 = Math.floor; 3285 var data = [0, 0, 0, 0, 0, 0]; 3286 var ERROR = 'Number.toFixed: incorrect invocation!'; 3287 var ZERO = '0'; 3288 3289 var multiply = function multiply(n, c) { 3290 var i = -1; 3291 var c2 = c; 3292 3293 while (++i < 6) { 3294 c2 += n * data[i]; 3295 data[i] = c2 % 1e7; 3296 c2 = floor$1(c2 / 1e7); 3297 } 3298 }; 3299 3300 var divide = function divide(n) { 3301 var i = 6; 3302 var c = 0; 3303 3304 while (--i >= 0) { 3305 c += data[i]; 3306 data[i] = floor$1(c / n); 3307 c = c % n * 1e7; 3308 } 3309 }; 3310 3311 var numToString = function numToString() { 3312 var i = 6; 3313 var s = ''; 3314 3315 while (--i >= 0) { 3316 if (s !== '' || i === 0 || data[i] !== 0) { 3317 var t = String(data[i]); 3318 s = s === '' ? t : s + _stringRepeat.call(ZERO, 7 - t.length) + t; 3319 } 3320 } 3321 3322 return s; 3323 }; 3324 3325 var pow = function pow(x, n, acc) { 3326 return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc); 3327 }; 3328 3329 var log = function log(x) { 3330 var n = 0; 3331 var x2 = x; 3332 3333 while (x2 >= 4096) { 3334 n += 12; 3335 x2 /= 4096; 3336 } 3337 3338 while (x2 >= 2) { 3339 n += 1; 3340 x2 /= 2; 3341 } 3342 3343 return n; 3344 }; 3345 3346 _export(_export.P + _export.F * (!!$toFixed && (0.00008.toFixed(3) !== '0.000' || 0.9.toFixed(0) !== '1' || 1.255.toFixed(2) !== '1.25' || 1000000000000000128.0.toFixed(0) !== '1000000000000000128') || !_fails(function () { 3347 // V8 ~ Android 4.3- 3348 $toFixed.call({}); 3349 })), 'Number', { 3350 toFixed: function toFixed(fractionDigits) { 3351 var x = _aNumberValue(this, ERROR); 3352 var f = _toInteger(fractionDigits); 3353 var s = ''; 3354 var m = ZERO; 3355 var e, z, j, k; 3356 if (f < 0 || f > 20) throw RangeError(ERROR); // eslint-disable-next-line no-self-compare 3357 3358 if (x != x) return 'NaN'; 3359 if (x <= -1e21 || x >= 1e21) return String(x); 3360 3361 if (x < 0) { 3362 s = '-'; 3363 x = -x; 3364 } 3365 3366 if (x > 1e-21) { 3367 e = log(x * pow(2, 69, 1)) - 69; 3368 z = e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1); 3369 z *= 0x10000000000000; 3370 e = 52 - e; 3371 3372 if (e > 0) { 3373 multiply(0, z); 3374 j = f; 3375 3376 while (j >= 7) { 3377 multiply(1e7, 0); 3378 j -= 7; 3379 } 3380 3381 multiply(pow(10, j, 1), 0); 3382 j = e - 1; 3383 3384 while (j >= 23) { 3385 divide(1 << 23); 3386 j -= 23; 3387 } 3388 3389 divide(1 << j); 3390 multiply(1, 1); 3391 divide(2); 3392 m = numToString(); 3393 } else { 3394 multiply(0, z); 3395 multiply(1 << -e, 0); 3396 m = numToString() + _stringRepeat.call(ZERO, f); 3397 } 3398 } 3399 3400 if (f > 0) { 3401 k = m.length; 3402 m = s + (k <= f ? '0.' + _stringRepeat.call(ZERO, f - k) + m : m.slice(0, k - f) + '.' + m.slice(k - f)); 3403 } else { 3404 m = s + m; 3405 } 3406 3407 return m; 3408 } 3409 }); 3410 3411 var $toPrecision = 1.0.toPrecision; 3412 _export(_export.P + _export.F * (_fails(function () { 3413 // IE7- 3414 return $toPrecision.call(1, undefined) !== '1'; 3415 }) || !_fails(function () { 3416 // V8 ~ Android 4.3- 3417 $toPrecision.call({}); 3418 })), 'Number', { 3419 toPrecision: function toPrecision(precision) { 3420 var that = _aNumberValue(this, 'Number#toPrecision: incorrect invocation!'); 3421 return precision === undefined ? $toPrecision.call(that) : $toPrecision.call(that, precision); 3422 } 3423 }); 3424 3425 // 20.1.2.1 Number.EPSILON 3426 3427 3428 _export(_export.S, 'Number', { 3429 EPSILON: Math.pow(2, -52) 3430 }); 3431 3432 // 20.1.2.2 Number.isFinite(number) 3433 3434 3435 var _isFinite = _global.isFinite; 3436 3437 _export(_export.S, 'Number', { 3438 isFinite: function isFinite(it) { 3439 return typeof it == 'number' && _isFinite(it); 3440 } 3441 }); 3442 3443 // 20.1.2.3 Number.isInteger(number) 3444 3445 3446 var floor$2 = Math.floor; 3447 3448 var _isInteger = function isInteger(it) { 3449 return !_isObject(it) && isFinite(it) && floor$2(it) === it; 3450 }; 3451 3452 // 20.1.2.3 Number.isInteger(number) 3453 3454 3455 _export(_export.S, 'Number', { 3456 isInteger: _isInteger 3457 }); 3458 3459 // 20.1.2.4 Number.isNaN(number) 3460 3461 3462 _export(_export.S, 'Number', { 3463 isNaN: function isNaN(number) { 3464 // eslint-disable-next-line no-self-compare 3465 return number != number; 3466 } 3467 }); 3468 3469 // 20.1.2.5 Number.isSafeInteger(number) 3470 3471 3472 3473 3474 var abs = Math.abs; 3475 _export(_export.S, 'Number', { 3476 isSafeInteger: function isSafeInteger(number) { 3477 return _isInteger(number) && abs(number) <= 0x1fffffffffffff; 3478 } 3479 }); 3480 3481 // 20.1.2.6 Number.MAX_SAFE_INTEGER 3482 3483 3484 _export(_export.S, 'Number', { 3485 MAX_SAFE_INTEGER: 0x1fffffffffffff 3486 }); 3487 3488 // 20.1.2.10 Number.MIN_SAFE_INTEGER 3489 3490 3491 _export(_export.S, 'Number', { 3492 MIN_SAFE_INTEGER: -0x1fffffffffffff 3493 }); 3494 3495 // 20.1.2.12 Number.parseFloat(string) 3496 3497 3498 _export(_export.S + _export.F * (Number.parseFloat != _parseFloat), 'Number', { 3499 parseFloat: _parseFloat 3500 }); 3501 3502 // 20.1.2.13 Number.parseInt(string, radix) 3503 3504 3505 _export(_export.S + _export.F * (Number.parseInt != _parseInt), 'Number', { 3506 parseInt: _parseInt 3507 }); 3508 3509 // 20.2.2.20 Math.log1p(x) 3510 var _mathLog1p = Math.log1p || function log1p(x) { 3511 return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : Math.log(1 + x); 3512 }; 3513 3514 // 20.2.2.3 Math.acosh(x) 3515 3516 3517 3518 3519 var sqrt = Math.sqrt; 3520 var $acosh = Math.acosh; 3521 _export(_export.S + _export.F * !($acosh // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509 3522 && Math.floor($acosh(Number.MAX_VALUE)) == 710 // Tor Browser bug: Math.acosh(Infinity) -> NaN 3523 && $acosh(Infinity) == Infinity), 'Math', { 3524 acosh: function acosh(x) { 3525 return (x = +x) < 1 ? NaN : x > 94906265.62425156 ? Math.log(x) + Math.LN2 : _mathLog1p(x - 1 + sqrt(x - 1) * sqrt(x + 1)); 3526 } 3527 }); 3528 3529 // 20.2.2.5 Math.asinh(x) 3530 3531 3532 var $asinh = Math.asinh; 3533 3534 function asinh(x) { 3535 return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : Math.log(x + Math.sqrt(x * x + 1)); 3536 } // Tor Browser bug: Math.asinh(0) -> -0 3537 3538 3539 _export(_export.S + _export.F * !($asinh && 1 / $asinh(0) > 0), 'Math', { 3540 asinh: asinh 3541 }); 3542 3543 // 20.2.2.7 Math.atanh(x) 3544 3545 3546 var $atanh = Math.atanh; // Tor Browser bug: Math.atanh(-0) -> 0 3547 3548 _export(_export.S + _export.F * !($atanh && 1 / $atanh(-0) < 0), 'Math', { 3549 atanh: function atanh(x) { 3550 return (x = +x) == 0 ? x : Math.log((1 + x) / (1 - x)) / 2; 3551 } 3552 }); 3553 3554 // 20.2.2.28 Math.sign(x) 3555 var _mathSign = Math.sign || function sign(x) { 3556 // eslint-disable-next-line no-self-compare 3557 return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1; 3558 }; 3559 3560 // 20.2.2.9 Math.cbrt(x) 3561 3562 3563 3564 3565 _export(_export.S, 'Math', { 3566 cbrt: function cbrt(x) { 3567 return _mathSign(x = +x) * Math.pow(Math.abs(x), 1 / 3); 3568 } 3569 }); 3570 3571 // 20.2.2.11 Math.clz32(x) 3572 3573 3574 _export(_export.S, 'Math', { 3575 clz32: function clz32(x) { 3576 return (x >>>= 0) ? 31 - Math.floor(Math.log(x + 0.5) * Math.LOG2E) : 32; 3577 } 3578 }); 3579 3580 // 20.2.2.12 Math.cosh(x) 3581 3582 3583 var exp = Math.exp; 3584 _export(_export.S, 'Math', { 3585 cosh: function cosh(x) { 3586 return (exp(x = +x) + exp(-x)) / 2; 3587 } 3588 }); 3589 3590 // 20.2.2.14 Math.expm1(x) 3591 var $expm1 = Math.expm1; 3592 var _mathExpm1 = !$expm1 // Old FF bug 3593 || $expm1(10) > 22025.465794806719 || $expm1(10) < 22025.4657948067165168 // Tor Browser bug 3594 || $expm1(-2e-17) != -2e-17 ? function expm1(x) { 3595 return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1; 3596 } : $expm1; 3597 3598 // 20.2.2.14 Math.expm1(x) 3599 3600 3601 3602 3603 _export(_export.S + _export.F * (_mathExpm1 != Math.expm1), 'Math', { 3604 expm1: _mathExpm1 3605 }); 3606 3607 // 20.2.2.16 Math.fround(x) 3608 3609 3610 var pow$1 = Math.pow; 3611 var EPSILON = pow$1(2, -52); 3612 var EPSILON32 = pow$1(2, -23); 3613 var MAX32 = pow$1(2, 127) * (2 - EPSILON32); 3614 var MIN32 = pow$1(2, -126); 3615 3616 var roundTiesToEven = function roundTiesToEven(n) { 3617 return n + 1 / EPSILON - 1 / EPSILON; 3618 }; 3619 3620 var _mathFround = Math.fround || function fround(x) { 3621 var $abs = Math.abs(x); 3622 var $sign = _mathSign(x); 3623 var a, result; 3624 if ($abs < MIN32) return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32; 3625 a = (1 + EPSILON32 / EPSILON) * $abs; 3626 result = a - (a - $abs); // eslint-disable-next-line no-self-compare 3627 3628 if (result > MAX32 || result != result) return $sign * Infinity; 3629 return $sign * result; 3630 }; 3631 3632 // 20.2.2.16 Math.fround(x) 3633 3634 3635 _export(_export.S, 'Math', { 3636 fround: _mathFround 3637 }); 3638 3639 // 20.2.2.17 Math.hypot([value1[, value2[, ... ]]]) 3640 3641 3642 var abs$1 = Math.abs; 3643 _export(_export.S, 'Math', { 3644 hypot: function hypot(value1, value2) { 3645 // eslint-disable-line no-unused-vars 3646 var sum = 0; 3647 var i = 0; 3648 var aLen = arguments.length; 3649 var larg = 0; 3650 var arg, div; 3651 3652 while (i < aLen) { 3653 arg = abs$1(arguments[i++]); 3654 3655 if (larg < arg) { 3656 div = larg / arg; 3657 sum = sum * div * div + 1; 3658 larg = arg; 3659 } else if (arg > 0) { 3660 div = arg / larg; 3661 sum += div * div; 3662 } else sum += arg; 3663 } 3664 3665 return larg === Infinity ? Infinity : larg * Math.sqrt(sum); 3666 } 3667 }); 3668 3669 // 20.2.2.18 Math.imul(x, y) 3670 3671 3672 var $imul = Math.imul; // some WebKit versions fails with big numbers, some has wrong arity 3673 3674 _export(_export.S + _export.F * _fails(function () { 3675 return $imul(0xffffffff, 5) != -5 || $imul.length != 2; 3676 }), 'Math', { 3677 imul: function imul(x, y) { 3678 var UINT16 = 0xffff; 3679 var xn = +x; 3680 var yn = +y; 3681 var xl = UINT16 & xn; 3682 var yl = UINT16 & yn; 3683 return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0); 3684 } 3685 }); 3686 3687 // 20.2.2.21 Math.log10(x) 3688 3689 3690 _export(_export.S, 'Math', { 3691 log10: function log10(x) { 3692 return Math.log(x) * Math.LOG10E; 3693 } 3694 }); 3695 3696 // 20.2.2.20 Math.log1p(x) 3697 3698 3699 _export(_export.S, 'Math', { 3700 log1p: _mathLog1p 3701 }); 3702 3703 // 20.2.2.22 Math.log2(x) 3704 3705 3706 _export(_export.S, 'Math', { 3707 log2: function log2(x) { 3708 return Math.log(x) / Math.LN2; 3709 } 3710 }); 3711 3712 // 20.2.2.28 Math.sign(x) 3713 3714 3715 _export(_export.S, 'Math', { 3716 sign: _mathSign 3717 }); 3718 3719 // 20.2.2.30 Math.sinh(x) 3720 3721 3722 3723 3724 var exp$1 = Math.exp; // V8 near Chromium 38 has a problem with very small numbers 3725 3726 _export(_export.S + _export.F * _fails(function () { 3727 return !Math.sinh(-2e-17) != -2e-17; 3728 }), 'Math', { 3729 sinh: function sinh(x) { 3730 return Math.abs(x = +x) < 1 ? (_mathExpm1(x) - _mathExpm1(-x)) / 2 : (exp$1(x - 1) - exp$1(-x - 1)) * (Math.E / 2); 3731 } 3732 }); 3733 3734 // 20.2.2.33 Math.tanh(x) 3735 3736 3737 3738 3739 var exp$2 = Math.exp; 3740 _export(_export.S, 'Math', { 3741 tanh: function tanh(x) { 3742 var a = _mathExpm1(x = +x); 3743 var b = _mathExpm1(-x); 3744 return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp$2(x) + exp$2(-x)); 3745 } 3746 }); 3747 3748 // 20.2.2.34 Math.trunc(x) 3749 3750 3751 _export(_export.S, 'Math', { 3752 trunc: function trunc(it) { 3753 return (it > 0 ? Math.floor : Math.ceil)(it); 3754 } 3755 }); 3756 3757 var fromCharCode = String.fromCharCode; 3758 var $fromCodePoint = String.fromCodePoint; // length should be 1, old FF problem 3759 3760 _export(_export.S + _export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', { 3761 // 21.1.2.2 String.fromCodePoint(...codePoints) 3762 fromCodePoint: function fromCodePoint(x) { 3763 // eslint-disable-line no-unused-vars 3764 var res = []; 3765 var aLen = arguments.length; 3766 var i = 0; 3767 var code; 3768 3769 while (aLen > i) { 3770 code = +arguments[i++]; 3771 if (_toAbsoluteIndex(code, 0x10ffff) !== code) throw RangeError(code + ' is not a valid code point'); 3772 res.push(code < 0x10000 ? fromCharCode(code) : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00)); 3773 } 3774 3775 return res.join(''); 3776 } 3777 }); 3778 3779 _export(_export.S, 'String', { 3780 // 21.1.2.4 String.raw(callSite, ...substitutions) 3781 raw: function raw(callSite) { 3782 var tpl = _toIobject(callSite.raw); 3783 var len = _toLength(tpl.length); 3784 var aLen = arguments.length; 3785 var res = []; 3786 var i = 0; 3787 3788 while (len > i) { 3789 res.push(String(tpl[i++])); 3790 if (i < aLen) res.push(String(arguments[i])); 3791 } 3792 3793 return res.join(''); 3794 } 3795 }); 3796 3797 _stringTrim('trim', function ($trim) { 3798 return function trim() { 3799 return $trim(this, 3); 3800 }; 3801 }); 3802 3803 // true -> String#at 3804 // false -> String#codePointAt 3805 3806 3807 var _stringAt = function (TO_STRING) { 3808 return function (that, pos) { 3809 var s = String(_defined(that)); 3810 var i = _toInteger(pos); 3811 var l = s.length; 3812 var a, b; 3813 if (i < 0 || i >= l) return TO_STRING ? '' : undefined; 3814 a = s.charCodeAt(i); 3815 return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff ? TO_STRING ? s.charAt(i) : a : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000; 3816 }; 3817 }; 3818 3819 var _iterators = {}; 3820 3821 var IteratorPrototype = {}; // 25.1.2.1.1 %IteratorPrototype%[@@iterator]() 3822 3823 _hide(IteratorPrototype, _wks('iterator'), function () { 3824 return this; 3825 }); 3826 3827 var _iterCreate = function (Constructor, NAME, next) { 3828 Constructor.prototype = _objectCreate(IteratorPrototype, { 3829 next: _propertyDesc(1, next) 3830 }); 3831 _setToStringTag(Constructor, NAME + ' Iterator'); 3832 }; 3833 3834 var ITERATOR = _wks('iterator'); 3835 3836 var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next` 3837 3838 var FF_ITERATOR = '@@iterator'; 3839 var KEYS = 'keys'; 3840 var VALUES = 'values'; 3841 3842 var returnThis = function returnThis() { 3843 return this; 3844 }; 3845 3846 var _iterDefine = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) { 3847 _iterCreate(Constructor, NAME, next); 3848 3849 var getMethod = function getMethod(kind) { 3850 if (!BUGGY && kind in proto) return proto[kind]; 3851 3852 switch (kind) { 3853 case KEYS: 3854 return function keys() { 3855 return new Constructor(this, kind); 3856 }; 3857 3858 case VALUES: 3859 return function values() { 3860 return new Constructor(this, kind); 3861 }; 3862 } 3863 3864 return function entries() { 3865 return new Constructor(this, kind); 3866 }; 3867 }; 3868 3869 var TAG = NAME + ' Iterator'; 3870 var DEF_VALUES = DEFAULT == VALUES; 3871 var VALUES_BUG = false; 3872 var proto = Base.prototype; 3873 var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]; 3874 var $default = $native || getMethod(DEFAULT); 3875 var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined; 3876 var $anyNative = NAME == 'Array' ? proto.entries || $native : $native; 3877 var methods, key, IteratorPrototype; // Fix native 3878 3879 if ($anyNative) { 3880 IteratorPrototype = _objectGpo($anyNative.call(new Base())); 3881 3882 if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) { 3883 // Set @@toStringTag to native iterators 3884 _setToStringTag(IteratorPrototype, TAG, true); // fix for some old engines 3885 3886 if (typeof IteratorPrototype[ITERATOR] != 'function') _hide(IteratorPrototype, ITERATOR, returnThis); 3887 } 3888 } // fix Array#{values, @@iterator}.name in V8 / FF 3889 3890 3891 if (DEF_VALUES && $native && $native.name !== VALUES) { 3892 VALUES_BUG = true; 3893 3894 $default = function values() { 3895 return $native.call(this); 3896 }; 3897 } // Define iterator 3898 3899 3900 if (BUGGY || VALUES_BUG || !proto[ITERATOR]) { 3901 _hide(proto, ITERATOR, $default); 3902 } // Plug for library 3903 3904 3905 _iterators[NAME] = $default; 3906 _iterators[TAG] = returnThis; 3907 3908 if (DEFAULT) { 3909 methods = { 3910 values: DEF_VALUES ? $default : getMethod(VALUES), 3911 keys: IS_SET ? $default : getMethod(KEYS), 3912 entries: $entries 3913 }; 3914 if (FORCED) for (key in methods) { 3915 if (!(key in proto)) _redefine(proto, key, methods[key]); 3916 } else _export(_export.P + _export.F * (BUGGY || VALUES_BUG), NAME, methods); 3917 } 3918 3919 return methods; 3920 }; 3921 3922 var $at = _stringAt(true); // 21.1.3.27 String.prototype[@@iterator]() 3923 3924 3925 _iterDefine(String, 'String', function (iterated) { 3926 this._t = String(iterated); // target 3927 3928 this._i = 0; // next index 3929 // 21.1.5.2.1 %StringIteratorPrototype%.next() 3930 }, function () { 3931 var O = this._t; 3932 var index = this._i; 3933 var point; 3934 if (index >= O.length) return { 3935 value: undefined, 3936 done: true 3937 }; 3938 point = $at(O, index); 3939 this._i += point.length; 3940 return { 3941 value: point, 3942 done: false 3943 }; 3944 }); 3945 3946 var $at$1 = _stringAt(false); 3947 3948 _export(_export.P, 'String', { 3949 // 21.1.3.3 String.prototype.codePointAt(pos) 3950 codePointAt: function codePointAt(pos) { 3951 return $at$1(this, pos); 3952 } 3953 }); 3954 3955 // 7.2.8 IsRegExp(argument) 3956 3957 3958 3959 3960 var MATCH = _wks('match'); 3961 3962 var _isRegexp = function (it) { 3963 var isRegExp; 3964 return _isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : _cof(it) == 'RegExp'); 3965 }; 3966 3967 // helper for String#{startsWith, endsWith, includes} 3968 3969 3970 3971 3972 var _stringContext = function (that, searchString, NAME) { 3973 if (_isRegexp(searchString)) throw TypeError('String#' + NAME + " doesn't accept regex!"); 3974 return String(_defined(that)); 3975 }; 3976 3977 var MATCH$1 = _wks('match'); 3978 3979 var _failsIsRegexp = function (KEY) { 3980 var re = /./; 3981 3982 try { 3983 '/./'[KEY](re); 3984 } catch (e) { 3985 try { 3986 re[MATCH$1] = false; 3987 return !'/./'[KEY](re); 3988 } catch (f) { 3989 /* empty */ 3990 } 3991 } 3992 3993 return true; 3994 }; 3995 3996 var ENDS_WITH = 'endsWith'; 3997 var $endsWith = ''[ENDS_WITH]; 3998 _export(_export.P + _export.F * _failsIsRegexp(ENDS_WITH), 'String', { 3999 endsWith: function endsWith(searchString 4000 /* , endPosition = @length */ 4001 ) { 4002 var that = _stringContext(this, searchString, ENDS_WITH); 4003 var endPosition = arguments.length > 1 ? arguments[1] : undefined; 4004 var len = _toLength(that.length); 4005 var end = endPosition === undefined ? len : Math.min(_toLength(endPosition), len); 4006 var search = String(searchString); 4007 return $endsWith ? $endsWith.call(that, search, end) : that.slice(end - search.length, end) === search; 4008 } 4009 }); 4010 4011 var INCLUDES = 'includes'; 4012 _export(_export.P + _export.F * _failsIsRegexp(INCLUDES), 'String', { 4013 includes: function includes(searchString 4014 /* , position = 0 */ 4015 ) { 4016 return !!~_stringContext(this, searchString, INCLUDES).indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined); 4017 } 4018 }); 4019 4020 _export(_export.P, 'String', { 4021 // 21.1.3.13 String.prototype.repeat(count) 4022 repeat: _stringRepeat 4023 }); 4024 4025 var STARTS_WITH = 'startsWith'; 4026 var $startsWith = ''[STARTS_WITH]; 4027 _export(_export.P + _export.F * _failsIsRegexp(STARTS_WITH), 'String', { 4028 startsWith: function startsWith(searchString 4029 /* , position = 0 */ 4030 ) { 4031 var that = _stringContext(this, searchString, STARTS_WITH); 4032 var index = _toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length)); 4033 var search = String(searchString); 4034 return $startsWith ? $startsWith.call(that, search, index) : that.slice(index, index + search.length) === search; 4035 } 4036 }); 4037 4038 var quot = /"/g; // B.2.3.2.1 CreateHTML(string, tag, attribute, value) 4039 4040 var createHTML = function createHTML(string, tag, attribute, value) { 4041 var S = String(_defined(string)); 4042 var p1 = '<' + tag; 4043 if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '"') + '"'; 4044 return p1 + '>' + S + '</' + tag + '>'; 4045 }; 4046 4047 var _stringHtml = function (NAME, exec) { 4048 var O = {}; 4049 O[NAME] = exec(createHTML); 4050 _export(_export.P + _export.F * _fails(function () { 4051 var test = ''[NAME]('"'); 4052 return test !== test.toLowerCase() || test.split('"').length > 3; 4053 }), 'String', O); 4054 }; 4055 4056 _stringHtml('anchor', function (createHTML) { 4057 return function anchor(name) { 4058 return createHTML(this, 'a', 'name', name); 4059 }; 4060 }); 4061 4062 _stringHtml('big', function (createHTML) { 4063 return function big() { 4064 return createHTML(this, 'big', '', ''); 4065 }; 4066 }); 4067 4068 _stringHtml('blink', function (createHTML) { 4069 return function blink() { 4070 return createHTML(this, 'blink', '', ''); 4071 }; 4072 }); 4073 4074 _stringHtml('bold', function (createHTML) { 4075 return function bold() { 4076 return createHTML(this, 'b', '', ''); 4077 }; 4078 }); 4079 4080 _stringHtml('fixed', function (createHTML) { 4081 return function fixed() { 4082 return createHTML(this, 'tt', '', ''); 4083 }; 4084 }); 4085 4086 _stringHtml('fontcolor', function (createHTML) { 4087 return function fontcolor(color) { 4088 return createHTML(this, 'font', 'color', color); 4089 }; 4090 }); 4091 4092 _stringHtml('fontsize', function (createHTML) { 4093 return function fontsize(size) { 4094 return createHTML(this, 'font', 'size', size); 4095 }; 4096 }); 4097 4098 _stringHtml('italics', function (createHTML) { 4099 return function italics() { 4100 return createHTML(this, 'i', '', ''); 4101 }; 4102 }); 4103 4104 _stringHtml('link', function (createHTML) { 4105 return function link(url) { 4106 return createHTML(this, 'a', 'href', url); 4107 }; 4108 }); 4109 4110 _stringHtml('small', function (createHTML) { 4111 return function small() { 4112 return createHTML(this, 'small', '', ''); 4113 }; 4114 }); 4115 4116 _stringHtml('strike', function (createHTML) { 4117 return function strike() { 4118 return createHTML(this, 'strike', '', ''); 4119 }; 4120 }); 4121 4122 _stringHtml('sub', function (createHTML) { 4123 return function sub() { 4124 return createHTML(this, 'sub', '', ''); 4125 }; 4126 }); 4127 4128 _stringHtml('sup', function (createHTML) { 4129 return function sup() { 4130 return createHTML(this, 'sup', '', ''); 4131 }; 4132 }); 4133 4134 // 20.3.3.1 / 15.9.4.4 Date.now() 4135 4136 4137 _export(_export.S, 'Date', { 4138 now: function now() { 4139 return new Date().getTime(); 4140 } 4141 }); 4142 4143 _export(_export.P + _export.F * _fails(function () { 4144 return new Date(NaN).toJSON() !== null || Date.prototype.toJSON.call({ 4145 toISOString: function toISOString() { 4146 return 1; 4147 } 4148 }) !== 1; 4149 }), 'Date', { 4150 // eslint-disable-next-line no-unused-vars 4151 toJSON: function toJSON(key) { 4152 var O = _toObject(this); 4153 var pv = _toPrimitive(O); 4154 return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString(); 4155 } 4156 }); 4157 4158 var getTime = Date.prototype.getTime; 4159 var $toISOString = Date.prototype.toISOString; 4160 4161 var lz = function lz(num) { 4162 return num > 9 ? num : '0' + num; 4163 }; // PhantomJS / old WebKit has a broken implementations 4164 4165 4166 var _dateToIsoString = _fails(function () { 4167 return $toISOString.call(new Date(-5e13 - 1)) != '0385-07-25T07:06:39.999Z'; 4168 }) || !_fails(function () { 4169 $toISOString.call(new Date(NaN)); 4170 }) ? function toISOString() { 4171 if (!isFinite(getTime.call(this))) throw RangeError('Invalid time value'); 4172 var d = this; 4173 var y = d.getUTCFullYear(); 4174 var m = d.getUTCMilliseconds(); 4175 var s = y < 0 ? '-' : y > 9999 ? '+' : ''; 4176 return s + ('00000' + Math.abs(y)).slice(s ? -6 : -4) + '-' + lz(d.getUTCMonth() + 1) + '-' + lz(d.getUTCDate()) + 'T' + lz(d.getUTCHours()) + ':' + lz(d.getUTCMinutes()) + ':' + lz(d.getUTCSeconds()) + '.' + (m > 99 ? m : '0' + lz(m)) + 'Z'; 4177 } : $toISOString; 4178 4179 // 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString() 4180 4181 4182 // PhantomJS / old WebKit has a broken implementations 4183 4184 4185 _export(_export.P + _export.F * (Date.prototype.toISOString !== _dateToIsoString), 'Date', { 4186 toISOString: _dateToIsoString 4187 }); 4188 4189 var DateProto = Date.prototype; 4190 var INVALID_DATE = 'Invalid Date'; 4191 var TO_STRING = 'toString'; 4192 var $toString = DateProto[TO_STRING]; 4193 var getTime$1 = DateProto.getTime; 4194 4195 if (new Date(NaN) + '' != INVALID_DATE) { 4196 _redefine(DateProto, TO_STRING, function toString() { 4197 var value = getTime$1.call(this); // eslint-disable-next-line no-self-compare 4198 4199 return value === value ? $toString.call(this) : INVALID_DATE; 4200 }); 4201 } 4202 4203 var NUMBER$1 = 'number'; 4204 4205 var _dateToPrimitive = function (hint) { 4206 if (hint !== 'string' && hint !== NUMBER$1 && hint !== 'default') throw TypeError('Incorrect hint'); 4207 return _toPrimitive(_anObject(this), hint != NUMBER$1); 4208 }; 4209 4210 var TO_PRIMITIVE$1 = _wks('toPrimitive'); 4211 4212 var proto$1 = Date.prototype; 4213 if (!(TO_PRIMITIVE$1 in proto$1)) _hide(proto$1, TO_PRIMITIVE$1, _dateToPrimitive); 4214 4215 // 22.1.2.2 / 15.4.3.2 Array.isArray(arg) 4216 4217 4218 _export(_export.S, 'Array', { 4219 isArray: _isArray 4220 }); 4221 4222 // call something on iterator step with safe closing on error 4223 4224 4225 var _iterCall = function (iterator, fn, value, entries) { 4226 try { 4227 return entries ? fn(_anObject(value)[0], value[1]) : fn(value); // 7.4.6 IteratorClose(iterator, completion) 4228 } catch (e) { 4229 var ret = iterator['return']; 4230 if (ret !== undefined) _anObject(ret.call(iterator)); 4231 throw e; 4232 } 4233 }; 4234 4235 // check on default Array iterator 4236 4237 4238 var ITERATOR$1 = _wks('iterator'); 4239 4240 var ArrayProto = Array.prototype; 4241 4242 var _isArrayIter = function (it) { 4243 return it !== undefined && (_iterators.Array === it || ArrayProto[ITERATOR$1] === it); 4244 }; 4245 4246 var _createProperty = function (object, index, value) { 4247 if (index in object) _objectDp.f(object, index, _propertyDesc(0, value));else object[index] = value; 4248 }; 4249 4250 var ITERATOR$2 = _wks('iterator'); 4251 4252 4253 4254 var core_getIteratorMethod = _core.getIteratorMethod = function (it) { 4255 if (it != undefined) return it[ITERATOR$2] || it['@@iterator'] || _iterators[_classof(it)]; 4256 }; 4257 4258 var ITERATOR$3 = _wks('iterator'); 4259 4260 var SAFE_CLOSING = false;
vendor: 12,581 bytes, lines 4261-4727
4261 4262 try { 4263 var riter = [7][ITERATOR$3](); 4264 4265 riter['return'] = function () { 4266 SAFE_CLOSING = true; 4267 }; // eslint-disable-next-line no-throw-literal 4268 } catch (e) { 4269 /* empty */ 4270 } 4271 4272 var _iterDetect = function (exec, skipClosing) { 4273 if (!skipClosing && !SAFE_CLOSING) return false; 4274 var safe = false; 4275 4276 try { 4277 var arr = [7]; 4278 var iter = arr[ITERATOR$3](); 4279 4280 iter.next = function () { 4281 return { 4282 done: safe = true 4283 }; 4284 }; 4285 4286 arr[ITERATOR$3] = function () { 4287 return iter; 4288 }; 4289 4290 exec(arr); 4291 } catch (e) { 4292 /* empty */ 4293 } 4294 4295 return safe; 4296 }; 4297 4298 _export(_export.S + _export.F * !_iterDetect(function (iter) { 4299 }), 'Array', { 4300 // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined) 4301 from: function from(arrayLike 4302 /* , mapfn = undefined, thisArg = undefined */ 4303 ) { 4304 var O = _toObject(arrayLike); 4305 var C = typeof this == 'function' ? this : Array; 4306 var aLen = arguments.length; 4307 var mapfn = aLen > 1 ? arguments[1] : undefined; 4308 var mapping = mapfn !== undefined; 4309 var index = 0; 4310 var iterFn = core_getIteratorMethod(O); 4311 var length, result, step, iterator; 4312 if (mapping) mapfn = _ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2); // if object isn't iterable or it's array with default iterator - use simple case 4313 4314 if (iterFn != undefined && !(C == Array && _isArrayIter(iterFn))) { 4315 for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) { 4316 _createProperty(result, index, mapping ? _iterCall(iterator, mapfn, [step.value, index], true) : step.value); 4317 } 4318 } else { 4319 length = _toLength(O.length); 4320 4321 for (result = new C(length); length > index; index++) { 4322 _createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]); 4323 } 4324 } 4325 4326 result.length = index; 4327 return result; 4328 } 4329 }); 4330 4331 // WebKit Array.of isn't generic 4332 4333 4334 _export(_export.S + _export.F * _fails(function () { 4335 function F() { 4336 /* empty */ 4337 } 4338 4339 return !(Array.of.call(F) instanceof F); 4340 }), 'Array', { 4341 // 22.1.2.3 Array.of( ...items) 4342 of: function of() 4343 /* ...args */ 4344 { 4345 var index = 0; 4346 var aLen = arguments.length; 4347 var result = new (typeof this == 'function' ? this : Array)(aLen); 4348 4349 while (aLen > index) { 4350 _createProperty(result, index, arguments[index++]); 4351 } 4352 4353 result.length = aLen; 4354 return result; 4355 } 4356 }); 4357 4358 var _strictMethod = function (method, arg) { 4359 return !!method && _fails(function () { 4360 // eslint-disable-next-line no-useless-call 4361 arg ? method.call(null, function () { 4362 /* empty */ 4363 }, 1) : method.call(null); 4364 }); 4365 }; 4366 4367 var arrayJoin = [].join; // fallback for not array-like strings 4368 4369 _export(_export.P + _export.F * (_iobject != Object || !_strictMethod(arrayJoin)), 'Array', { 4370 join: function join(separator) { 4371 return arrayJoin.call(_toIobject(this), separator === undefined ? ',' : separator); 4372 } 4373 }); 4374 4375 var arraySlice$1 = [].slice; // fallback for not array-like ES3 strings and DOM objects 4376 4377 _export(_export.P + _export.F * _fails(function () { 4378 if (_html) arraySlice$1.call(_html); 4379 }), 'Array', { 4380 slice: function slice(begin, end) { 4381 var len = _toLength(this.length); 4382 var klass = _cof(this); 4383 end = end === undefined ? len : end; 4384 if (klass == 'Array') return arraySlice$1.call(this, begin, end); 4385 var start = _toAbsoluteIndex(begin, len); 4386 var upTo = _toAbsoluteIndex(end, len); 4387 var size = _toLength(upTo - start); 4388 var cloned = new Array(size); 4389 var i = 0; 4390 4391 for (; i < size; i++) { 4392 cloned[i] = klass == 'String' ? this.charAt(start + i) : this[start + i]; 4393 } 4394 4395 return cloned; 4396 } 4397 }); 4398 4399 var $sort = [].sort; 4400 var test$1 = [1, 2, 3]; 4401 _export(_export.P + _export.F * (_fails(function () { 4402 // IE8- 4403 test$1.sort(undefined); 4404 }) || !_fails(function () { 4405 // V8 bug 4406 test$1.sort(null); // Old WebKit 4407 }) || !_strictMethod($sort)), 'Array', { 4408 // 22.1.3.25 Array.prototype.sort(comparefn) 4409 sort: function sort(comparefn) { 4410 return comparefn === undefined ? $sort.call(_toObject(this)) : $sort.call(_toObject(this), _aFunction(comparefn)); 4411 } 4412 }); 4413 4414 var SPECIES = _wks('species'); 4415 4416 var _arraySpeciesConstructor = function (original) { 4417 var C; 4418 4419 if (_isArray(original)) { 4420 C = original.constructor; // cross-realm fallback 4421 4422 if (typeof C == 'function' && (C === Array || _isArray(C.prototype))) C = undefined; 4423 4424 if (_isObject(C)) { 4425 C = C[SPECIES]; 4426 if (C === null) C = undefined; 4427 } 4428 } 4429 4430 return C === undefined ? Array : C; 4431 }; 4432 4433 // 9.4.2.3 ArraySpeciesCreate(originalArray, length) 4434 4435 4436 var _arraySpeciesCreate = function (original, length) { 4437 return new (_arraySpeciesConstructor(original))(length); 4438 }; 4439 4440 // 0 -> Array#forEach 4441 // 1 -> Array#map 4442 // 2 -> Array#filter 4443 // 3 -> Array#some 4444 // 4 -> Array#every 4445 // 5 -> Array#find 4446 // 6 -> Array#findIndex 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 var _arrayMethods = function (TYPE, $create) { 4458 var IS_MAP = TYPE == 1; 4459 var IS_FILTER = TYPE == 2; 4460 var IS_SOME = TYPE == 3; 4461 var IS_EVERY = TYPE == 4; 4462 var IS_FIND_INDEX = TYPE == 6; 4463 var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; 4464 var create = $create || _arraySpeciesCreate; 4465 return function ($this, callbackfn, that) { 4466 var O = _toObject($this); 4467 var self = _iobject(O); 4468 var f = _ctx(callbackfn, that, 3); 4469 var length = _toLength(self.length); 4470 var index = 0; 4471 var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined; 4472 var val, res; 4473 4474 for (; length > index; index++) { 4475 if (NO_HOLES || index in self) { 4476 val = self[index]; 4477 res = f(val, index, O); 4478 4479 if (TYPE) { 4480 if (IS_MAP) result[index] = res; // map 4481 else if (res) switch (TYPE) { 4482 case 3: 4483 return true; 4484 // some 4485 4486 case 5: 4487 return val; 4488 // find 4489 4490 case 6: 4491 return index; 4492 // findIndex 4493 4494 case 2: 4495 result.push(val); 4496 // filter 4497 } else if (IS_EVERY) return false; // every 4498 } 4499 } 4500 } 4501 4502 return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result; 4503 }; 4504 }; 4505 4506 var $forEach = _arrayMethods(0); 4507 4508 var STRICT = _strictMethod([].forEach, true); 4509 4510 _export(_export.P + _export.F * !STRICT, 'Array', { 4511 // 22.1.3.10 / 15.4.4.18 Array.prototype.forEach(callbackfn [, thisArg]) 4512 forEach: function forEach(callbackfn 4513 /* , thisArg */ 4514 ) { 4515 return $forEach(this, callbackfn, arguments[1]); 4516 } 4517 }); 4518 4519 var $map = _arrayMethods(1); 4520 4521 _export(_export.P + _export.F * !_strictMethod([].map, true), 'Array', { 4522 // 22.1.3.15 / 15.4.4.19 Array.prototype.map(callbackfn [, thisArg]) 4523 map: function map(callbackfn 4524 /* , thisArg */ 4525 ) { 4526 return $map(this, callbackfn, arguments[1]); 4527 } 4528 }); 4529 4530 var $filter = _arrayMethods(2); 4531 4532 _export(_export.P + _export.F * !_strictMethod([].filter, true), 'Array', { 4533 // 22.1.3.7 / 15.4.4.20 Array.prototype.filter(callbackfn [, thisArg]) 4534 filter: function filter(callbackfn 4535 /* , thisArg */ 4536 ) { 4537 return $filter(this, callbackfn, arguments[1]); 4538 } 4539 }); 4540 4541 var $some = _arrayMethods(3); 4542 4543 _export(_export.P + _export.F * !_strictMethod([].some, true), 'Array', { 4544 // 22.1.3.23 / 15.4.4.17 Array.prototype.some(callbackfn [, thisArg]) 4545 some: function some(callbackfn 4546 /* , thisArg */ 4547 ) { 4548 return $some(this, callbackfn, arguments[1]); 4549 } 4550 }); 4551 4552 var $every = _arrayMethods(4); 4553 4554 _export(_export.P + _export.F * !_strictMethod([].every, true), 'Array', { 4555 // 22.1.3.5 / 15.4.4.16 Array.prototype.every(callbackfn [, thisArg]) 4556 every: function every(callbackfn 4557 /* , thisArg */ 4558 ) { 4559 return $every(this, callbackfn, arguments[1]); 4560 } 4561 }); 4562 4563 var _arrayReduce = function (that, callbackfn, aLen, memo, isRight) { 4564 _aFunction(callbackfn); 4565 var O = _toObject(that); 4566 var self = _iobject(O); 4567 var length = _toLength(O.length); 4568 var index = isRight ? length - 1 : 0; 4569 var i = isRight ? -1 : 1; 4570 if (aLen < 2) for (;;) { 4571 if (index in self) { 4572 memo = self[index]; 4573 index += i; 4574 break; 4575 } 4576 4577 index += i; 4578 4579 if (isRight ? index < 0 : length <= index) { 4580 throw TypeError('Reduce of empty array with no initial value'); 4581 } 4582 } 4583 4584 for (; isRight ? index >= 0 : length > index; index += i) { 4585 if (index in self) { 4586 memo = callbackfn(memo, self[index], index, O); 4587 } 4588 } 4589 4590 return memo; 4591 }; 4592 4593 _export(_export.P + _export.F * !_strictMethod([].reduce, true), 'Array', { 4594 // 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue]) 4595 reduce: function reduce(callbackfn 4596 /* , initialValue */ 4597 ) { 4598 return _arrayReduce(this, callbackfn, arguments.length, arguments[1], false); 4599 } 4600 }); 4601 4602 _export(_export.P + _export.F * !_strictMethod([].reduceRight, true), 'Array', { 4603 // 22.1.3.19 / 15.4.4.22 Array.prototype.reduceRight(callbackfn [, initialValue]) 4604 reduceRight: function reduceRight(callbackfn 4605 /* , initialValue */ 4606 ) { 4607 return _arrayReduce(this, callbackfn, arguments.length, arguments[1], true); 4608 } 4609 }); 4610 4611 var $indexOf = _arrayIncludes(false); 4612 4613 var $native = [].indexOf; 4614 var NEGATIVE_ZERO = !!$native && 1 / [1].indexOf(1, -0) < 0; 4615 _export(_export.P + _export.F * (NEGATIVE_ZERO || !_strictMethod($native)), 'Array', { 4616 // 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex]) 4617 indexOf: function indexOf(searchElement 4618 /* , fromIndex = 0 */ 4619 ) { 4620 return NEGATIVE_ZERO // convert -0 to +0 4621 ? $native.apply(this, arguments) || 0 : $indexOf(this, searchElement, arguments[1]); 4622 } 4623 }); 4624 4625 var $native$1 = [].lastIndexOf; 4626 var NEGATIVE_ZERO$1 = !!$native$1 && 1 / [1].lastIndexOf(1, -0) < 0; 4627 _export(_export.P + _export.F * (NEGATIVE_ZERO$1 || !_strictMethod($native$1)), 'Array', { 4628 // 22.1.3.14 / 15.4.4.15 Array.prototype.lastIndexOf(searchElement [, fromIndex]) 4629 lastIndexOf: function lastIndexOf(searchElement 4630 /* , fromIndex = @[*-1] */ 4631 ) { 4632 // convert -0 to +0 4633 if (NEGATIVE_ZERO$1) return $native$1.apply(this, arguments) || 0; 4634 var O = _toIobject(this); 4635 var length = _toLength(O.length); 4636 var index = length - 1; 4637 if (arguments.length > 1) index = Math.min(index, _toInteger(arguments[1])); 4638 if (index < 0) index = length + index; 4639 4640 for (; index >= 0; index--) { 4641 if (index in O) if (O[index] === searchElement) return index || 0; 4642 } 4643 4644 return -1; 4645 } 4646 }); 4647 4648 var _arrayCopyWithin = [].copyWithin || function copyWithin(target 4649 /* = 0 */ 4650 , start 4651 /* = 0, end = @length */ 4652 ) { 4653 var O = _toObject(this); 4654 var len = _toLength(O.length); 4655 var to = _toAbsoluteIndex(target, len); 4656 var from = _toAbsoluteIndex(start, len); 4657 var end = arguments.length > 2 ? arguments[2] : undefined; 4658 var count = Math.min((end === undefined ? len : _toAbsoluteIndex(end, len)) - from, len - to); 4659 var inc = 1; 4660 4661 if (from < to && to < from + count) { 4662 inc = -1; 4663 from += count - 1; 4664 to += count - 1; 4665 } 4666 4667 while (count-- > 0) { 4668 if (from in O) O[to] = O[from];else delete O[to]; 4669 to += inc; 4670 from += inc; 4671 } 4672 4673 return O; 4674 }; 4675 4676 // 22.1.3.31 Array.prototype[@@unscopables] 4677 var UNSCOPABLES = _wks('unscopables'); 4678 4679 var ArrayProto$1 = Array.prototype; 4680 if (ArrayProto$1[UNSCOPABLES] == undefined) _hide(ArrayProto$1, UNSCOPABLES, {}); 4681 4682 var _addToUnscopables = function (key) { 4683 ArrayProto$1[UNSCOPABLES][key] = true; 4684 }; 4685 4686 // 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length) 4687 4688 4689 _export(_export.P, 'Array', { 4690 copyWithin: _arrayCopyWithin 4691 }); 4692 4693 _addToUnscopables('copyWithin'); 4694 4695 var _arrayFill = function fill(value 4696 /* , start = 0, end = @length */ 4697 ) { 4698 var O = _toObject(this); 4699 var length = _toLength(O.length); 4700 var aLen = arguments.length; 4701 var index = _toAbsoluteIndex(aLen > 1 ? arguments[1] : undefined, length); 4702 var end = aLen > 2 ? arguments[2] : undefined; 4703 var endPos = end === undefined ? length : _toAbsoluteIndex(end, length); 4704 4705 while (endPos > index) { 4706 O[index++] = value; 4707 } 4708 4709 return O; 4710 }; 4711 4712 // 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length) 4713 4714 4715 _export(_export.P, 'Array', { 4716 fill: _arrayFill 4717 }); 4718 4719 _addToUnscopables('fill'); 4720 4721 var $find = _arrayMethods(5); 4722 4723 var KEY = 'find'; 4724 var forced = true; // Shouldn't skip holes 4725 4726 if (KEY in []) Array(1)[KEY](function () { 4727 forced = false;
vendor: 14,207 bytes, lines 4728-5201
4728 }); 4729 _export(_export.P + _export.F * forced, 'Array', { 4730 find: function find(callbackfn 4731 /* , that = undefined */ 4732 ) { 4733 return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); 4734 } 4735 }); 4736 4737 _addToUnscopables(KEY); 4738 4739 var $find$1 = _arrayMethods(6); 4740 4741 var KEY$1 = 'findIndex'; 4742 var forced$1 = true; // Shouldn't skip holes 4743 4744 if (KEY$1 in []) Array(1)[KEY$1](function () { 4745 forced$1 = false; 4746 }); 4747 _export(_export.P + _export.F * forced$1, 'Array', { 4748 findIndex: function findIndex(callbackfn 4749 /* , that = undefined */ 4750 ) { 4751 return $find$1(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); 4752 } 4753 }); 4754 4755 _addToUnscopables(KEY$1); 4756 4757 var SPECIES$1 = _wks('species'); 4758 4759 var _setSpecies = function (KEY) { 4760 var C = _global[KEY]; 4761 if (_descriptors && C && !C[SPECIES$1]) _objectDp.f(C, SPECIES$1, { 4762 configurable: true, 4763 get: function get() { 4764 return this; 4765 } 4766 }); 4767 }; 4768 4769 _setSpecies('Array'); 4770 4771 var _iterStep = function (done, value) { 4772 return { 4773 value: value, 4774 done: !!done 4775 }; 4776 }; 4777 4778 // 22.1.3.4 Array.prototype.entries() 4779 // 22.1.3.13 Array.prototype.keys() 4780 // 22.1.3.29 Array.prototype.values() 4781 // 22.1.3.30 Array.prototype[@@iterator]() 4782 4783 4784 var es6_array_iterator = _iterDefine(Array, 'Array', function (iterated, kind) { 4785 this._t = _toIobject(iterated); // target 4786 4787 this._i = 0; // next index 4788 4789 this._k = kind; // kind 4790 // 22.1.5.2.1 %ArrayIteratorPrototype%.next() 4791 }, function () { 4792 var O = this._t; 4793 var kind = this._k; 4794 var index = this._i++; 4795 4796 if (!O || index >= O.length) { 4797 this._t = undefined; 4798 return _iterStep(1); 4799 } 4800 4801 if (kind == 'keys') return _iterStep(0, index); 4802 if (kind == 'values') return _iterStep(0, O[index]); 4803 return _iterStep(0, [index, O[index]]); 4804 }, 'values'); // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7) 4805 4806 _iterators.Arguments = _iterators.Array; 4807 _addToUnscopables('keys'); 4808 _addToUnscopables('values'); 4809 _addToUnscopables('entries'); 4810 4811 var _flags = function () { 4812 var that = _anObject(this); 4813 var result = ''; 4814 if (that.global) result += 'g'; 4815 if (that.ignoreCase) result += 'i'; 4816 if (that.multiline) result += 'm'; 4817 if (that.unicode) result += 'u'; 4818 if (that.sticky) result += 'y'; 4819 return result; 4820 }; 4821 4822 var dP$4 = _objectDp.f; 4823 4824 var gOPN$3 = _objectGopn.f; 4825 4826 4827 4828 4829 4830 var $RegExp = _global.RegExp; 4831 var Base$1 = $RegExp; 4832 var proto$2 = $RegExp.prototype; 4833 var re1 = /a/g; 4834 var re2 = /a/g; // "new" creates a new object, old webkit buggy here 4835 4836 var CORRECT_NEW = new $RegExp(re1) !== re1; 4837 4838 if (_descriptors && (!CORRECT_NEW || _fails(function () { 4839 re2[_wks('match')] = false; // RegExp constructor can alter flags and IsRegExp works correct with @@match 4840 4841 return $RegExp(re1) != re1 || $RegExp(re2) == re2 || $RegExp(re1, 'i') != '/a/i'; 4842 }))) { 4843 $RegExp = function RegExp(p, f) { 4844 var tiRE = this instanceof $RegExp; 4845 var piRE = _isRegexp(p); 4846 var fiU = f === undefined; 4847 return !tiRE && piRE && p.constructor === $RegExp && fiU ? p : _inheritIfRequired(CORRECT_NEW ? new Base$1(piRE && !fiU ? p.source : p, f) : Base$1((piRE = p instanceof $RegExp) ? p.source : p, piRE && fiU ? _flags.call(p) : f), tiRE ? this : proto$2, $RegExp); 4848 }; 4849 4850 var proxy = function proxy(key) { 4851 key in $RegExp || dP$4($RegExp, key, { 4852 configurable: true, 4853 get: function get() { 4854 return Base$1[key]; 4855 }, 4856 set: function set(it) { 4857 Base$1[key] = it; 4858 } 4859 }); 4860 }; 4861 4862 for (var keys$1 = gOPN$3(Base$1), i = 0; keys$1.length > i;) { 4863 proxy(keys$1[i++]); 4864 } 4865 4866 proto$2.constructor = $RegExp; 4867 $RegExp.prototype = proto$2; 4868 4869 _redefine(_global, 'RegExp', $RegExp); 4870 } 4871 4872 _setSpecies('RegExp'); 4873 4874 var nativeExec = RegExp.prototype.exec; // This always refers to the native implementation, because the 4875 // String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js, 4876 // which loads this file before patching the method. 4877 4878 var nativeReplace = String.prototype.replace; 4879 var patchedExec = nativeExec; 4880 var LAST_INDEX = 'lastIndex'; 4881 4882 var UPDATES_LAST_INDEX_WRONG = function () { 4883 var re1 = /a/, 4884 re2 = /b*/g; 4885 nativeExec.call(re1, 'a'); 4886 nativeExec.call(re2, 'a'); 4887 return re1[LAST_INDEX] !== 0 || re2[LAST_INDEX] !== 0; 4888 }(); // nonparticipating capturing group, copied from es5-shim's String#split patch. 4889 4890 4891 var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; 4892 var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED; 4893 4894 if (PATCH) { 4895 patchedExec = function exec(str) { 4896 var re = this; 4897 var lastIndex, reCopy, match, i; 4898 4899 if (NPCG_INCLUDED) { 4900 reCopy = new RegExp('^' + re.source + '$(?!\\s)', _flags.call(re)); 4901 } 4902 4903 if (UPDATES_LAST_INDEX_WRONG) lastIndex = re[LAST_INDEX]; 4904 match = nativeExec.call(re, str); 4905 4906 if (UPDATES_LAST_INDEX_WRONG && match) { 4907 re[LAST_INDEX] = re.global ? match.index + match[0].length : lastIndex; 4908 } 4909 4910 if (NPCG_INCLUDED && match && match.length > 1) { 4911 // Fix browsers whose `exec` methods don't consistently return `undefined` 4912 // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/ 4913 // eslint-disable-next-line no-loop-func 4914 nativeReplace.call(match[0], reCopy, function () { 4915 for (i = 1; i < arguments.length - 2; i++) { 4916 if (arguments[i] === undefined) match[i] = undefined; 4917 } 4918 }); 4919 } 4920 4921 return match; 4922 }; 4923 } 4924 4925 var _regexpExec = patchedExec; 4926 4927 _export({ 4928 target: 'RegExp', 4929 proto: true, 4930 forced: _regexpExec !== /./.exec 4931 }, { 4932 exec: _regexpExec 4933 }); 4934 4935 // 21.2.5.3 get RegExp.prototype.flags() 4936 if (_descriptors && /./g.flags != 'g') _objectDp.f(RegExp.prototype, 'flags', { 4937 configurable: true, 4938 get: _flags 4939 }); 4940 4941 var TO_STRING$1 = 'toString'; 4942 var $toString$1 = /./[TO_STRING$1]; 4943 4944 var define = function define(fn) { 4945 _redefine(RegExp.prototype, TO_STRING$1, fn, true); 4946 }; // 21.2.5.14 RegExp.prototype.toString() 4947 4948 4949 if (_fails(function () { 4950 return $toString$1.call({ 4951 source: 'a', 4952 flags: 'b' 4953 }) != '/a/b'; 4954 })) { 4955 define(function toString() { 4956 var R = _anObject(this); 4957 return '/'.concat(R.source, '/', 'flags' in R ? R.flags : !_descriptors && R instanceof RegExp ? _flags.call(R) : undefined); 4958 }); // FF44- RegExp#toString has a wrong name 4959 } else if ($toString$1.name != TO_STRING$1) { 4960 define(function toString() { 4961 return $toString$1.call(this); 4962 }); 4963 } 4964 4965 var at = _stringAt(true); // `AdvanceStringIndex` abstract operation 4966 // https://tc39.github.io/ecma262/#sec-advancestringindex 4967 4968 4969 var _advanceStringIndex = function (S, index, unicode) { 4970 return index + (unicode ? at(S, index).length : 1); 4971 }; 4972 4973 var builtinExec = RegExp.prototype.exec; // `RegExpExec` abstract operation 4974 // https://tc39.github.io/ecma262/#sec-regexpexec 4975 4976 var _regexpExecAbstract = function (R, S) { 4977 var exec = R.exec; 4978 4979 if (typeof exec === 'function') { 4980 var result = exec.call(R, S); 4981 4982 if (babelHelpers.typeof(result) !== 'object') { 4983 throw new TypeError('RegExp exec method returned something other than an Object or null'); 4984 } 4985 4986 return result; 4987 } 4988 4989 if (_classof(R) !== 'RegExp') { 4990 throw new TypeError('RegExp#exec called on incompatible receiver'); 4991 } 4992 4993 return builtinExec.call(R, S); 4994 }; 4995 4996 var SPECIES$2 = _wks('species'); 4997 var REPLACE_SUPPORTS_NAMED_GROUPS = !_fails(function () { 4998 // #replace needs built-in support for named groups. 4999 // #match works fine because it just return the exec results, even if it has 5000 // a "grops" property. 5001 var re = /./; 5002 5003 re.exec = function () { 5004 var result = []; 5005 result.groups = { 5006 a: '7' 5007 }; 5008 return result; 5009 }; 5010 5011 return ''.replace(re, '$<a>') !== '7'; 5012 }); 5013 5014 var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = function () { 5015 // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec 5016 var re = /(?:)/; 5017 var originalExec = re.exec; 5018 5019 re.exec = function () { 5020 return originalExec.apply(this, arguments); 5021 }; 5022 5023 var result = 'ab'.split(re); 5024 return result.length === 2 && result[0] === 'a' && result[1] === 'b'; 5025 }(); 5026 5027 var _fixReWks = function (KEY, length, exec) { 5028 var SYMBOL = _wks(KEY); 5029 var DELEGATES_TO_SYMBOL = !_fails(function () { 5030 // String methods call symbol-named RegEp methods 5031 var O = {}; 5032 5033 O[SYMBOL] = function () { 5034 return 7; 5035 }; 5036 5037 return ''[KEY](O) != 7; 5038 }); 5039 var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL ? !_fails(function () { 5040 // Symbol-named RegExp methods call .exec 5041 var execCalled = false; 5042 var re = /a/; 5043 5044 re.exec = function () { 5045 execCalled = true; 5046 return null; 5047 }; 5048 5049 if (KEY === 'split') { 5050 // RegExp[@@split] doesn't call the regex's exec method, but first creates 5051 // a new one. We need to return the patched regex when creating the new one. 5052 re.constructor = {}; 5053 5054 re.constructor[SPECIES$2] = function () { 5055 return re; 5056 }; 5057 } 5058 5059 re[SYMBOL](''); 5060 return !execCalled; 5061 }) : undefined; 5062 5063 if (!DELEGATES_TO_SYMBOL || !DELEGATES_TO_EXEC || KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS || KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC) { 5064 var nativeRegExpMethod = /./[SYMBOL]; 5065 var fns = exec(_defined, SYMBOL, ''[KEY], function maybeCallNative(nativeMethod, regexp, str, arg2, forceStringMethod) { 5066 if (regexp.exec === _regexpExec) { 5067 if (DELEGATES_TO_SYMBOL && !forceStringMethod) { 5068 // The native String method already delegates to @@method (this 5069 // polyfilled function), leasing to infinite recursion. 5070 // We avoid it by directly calling the native @@method method. 5071 return { 5072 done: true, 5073 value: nativeRegExpMethod.call(regexp, str, arg2) 5074 }; 5075 } 5076 5077 return { 5078 done: true, 5079 value: nativeMethod.call(str, regexp, arg2) 5080 }; 5081 } 5082 5083 return { 5084 done: false 5085 }; 5086 }); 5087 var strfn = fns[0]; 5088 var rxfn = fns[1]; 5089 _redefine(String.prototype, KEY, strfn); 5090 _hide(RegExp.prototype, SYMBOL, length == 2 // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue) 5091 // 21.2.5.11 RegExp.prototype[@@split](string, limit) 5092 ? function (string, arg) { 5093 return rxfn.call(string, this, arg); 5094 } // 21.2.5.6 RegExp.prototype[@@match](string) 5095 // 21.2.5.9 RegExp.prototype[@@search](string) 5096 : function (string) { 5097 return rxfn.call(string, this); 5098 }); 5099 } 5100 }; 5101 5102 // @@match logic 5103 5104 5105 _fixReWks('match', 1, function (defined, MATCH, $match, maybeCallNative) { 5106 return [// `String.prototype.match` method 5107 // https://tc39.github.io/ecma262/#sec-string.prototype.match 5108 function match(regexp) { 5109 var O = defined(this); 5110 var fn = regexp == undefined ? undefined : regexp[MATCH]; 5111 return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O)); 5112 }, // `RegExp.prototype[@@match]` method 5113 // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match 5114 function (regexp) { 5115 var res = maybeCallNative($match, regexp, this); 5116 if (res.done) return res.value; 5117 var rx = _anObject(regexp); 5118 var S = String(this); 5119 if (!rx.global) return _regexpExecAbstract(rx, S); 5120 var fullUnicode = rx.unicode; 5121 rx.lastIndex = 0; 5122 var A = []; 5123 var n = 0; 5124 var result; 5125 5126 while ((result = _regexpExecAbstract(rx, S)) !== null) { 5127 var matchStr = String(result[0]); 5128 A[n] = matchStr; 5129 if (matchStr === '') rx.lastIndex = _advanceStringIndex(S, _toLength(rx.lastIndex), fullUnicode); 5130 n++; 5131 } 5132 5133 return n === 0 ? null : A; 5134 }]; 5135 }); 5136 5137 var max$1 = Math.max; 5138 var min$2 = Math.min; 5139 var floor$3 = Math.floor; 5140 var SUBSTITUTION_SYMBOLS = /\$([$&`']|\d\d?|<[^>]*>)/g; 5141 var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&`']|\d\d?)/g; 5142 5143 var maybeToString = function maybeToString(it) { 5144 return it === undefined ? it : String(it); 5145 }; // @@replace logic 5146 5147 5148 _fixReWks('replace', 2, function (defined, REPLACE, $replace, maybeCallNative) { 5149 return [// `String.prototype.replace` method 5150 // https://tc39.github.io/ecma262/#sec-string.prototype.replace 5151 function replace(searchValue, replaceValue) { 5152 var O = defined(this); 5153 var fn = searchValue == undefined ? undefined : searchValue[REPLACE]; 5154 return fn !== undefined ? fn.call(searchValue, O, replaceValue) : $replace.call(String(O), searchValue, replaceValue); 5155 }, // `RegExp.prototype[@@replace]` method 5156 // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace 5157 function (regexp, replaceValue) { 5158 var res = maybeCallNative($replace, regexp, this, replaceValue); 5159 if (res.done) return res.value; 5160 var rx = _anObject(regexp); 5161 var S = String(this); 5162 var functionalReplace = typeof replaceValue === 'function'; 5163 if (!functionalReplace) replaceValue = String(replaceValue); 5164 var global = rx.global; 5165 5166 if (global) { 5167 var fullUnicode = rx.unicode; 5168 rx.lastIndex = 0; 5169 } 5170 5171 var results = []; 5172 5173 while (true) { 5174 var result = _regexpExecAbstract(rx, S); 5175 if (result === null) break; 5176 results.push(result); 5177 if (!global) break; 5178 var matchStr = String(result[0]); 5179 if (matchStr === '') rx.lastIndex = _advanceStringIndex(S, _toLength(rx.lastIndex), fullUnicode); 5180 } 5181 5182 var accumulatedResult = ''; 5183 var nextSourcePosition = 0; 5184 5185 for (var i = 0; i < results.length; i++) { 5186 result = results[i]; 5187 var matched = String(result[0]); 5188 var position = max$1(min$2(_toInteger(result.index), S.length), 0); 5189 var captures = []; // NOTE: This is equivalent to 5190 // captures = result.slice(1).map(maybeToString) 5191 // but for some reason `nativeSlice.call(result, 1, result.length)` (called in 5192 // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and 5193 // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. 5194 5195 for (var j = 1; j < result.length; j++) { 5196 captures.push(maybeToString(result[j])); 5197 } 5198 5199 var namedCaptures = result.groups; 5200 5201 if (functionalReplace) {
vendor: 6,187 bytes, lines 5202-5369
5202 var replacerArgs = [matched].concat(captures, position, S); 5203 if (namedCaptures !== undefined) replacerArgs.push(namedCaptures); 5204 var replacement = String(replaceValue.apply(undefined, replacerArgs)); 5205 } else { 5206 replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); 5207 } 5208 5209 if (position >= nextSourcePosition) { 5210 accumulatedResult += S.slice(nextSourcePosition, position) + replacement; 5211 nextSourcePosition = position + matched.length; 5212 } 5213 } 5214 5215 return accumulatedResult + S.slice(nextSourcePosition); 5216 }]; // https://tc39.github.io/ecma262/#sec-getsubstitution 5217 5218 function getSubstitution(matched, str, position, captures, namedCaptures, replacement) { 5219 var tailPos = position + matched.length; 5220 var m = captures.length; 5221 var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; 5222 5223 if (namedCaptures !== undefined) { 5224 namedCaptures = _toObject(namedCaptures); 5225 symbols = SUBSTITUTION_SYMBOLS; 5226 } 5227 5228 return $replace.call(replacement, symbols, function (match, ch) { 5229 var capture; 5230 5231 switch (ch.charAt(0)) { 5232 case '$': 5233 return '$'; 5234 5235 case '&': 5236 return matched; 5237 5238 case '`': 5239 return str.slice(0, position); 5240 5241 case "'": 5242 return str.slice(tailPos); 5243 5244 case '<': 5245 capture = namedCaptures[ch.slice(1, -1)]; 5246 break; 5247 5248 default: 5249 // \d\d? 5250 var n = +ch; 5251 if (n === 0) return match; 5252 5253 if (n > m) { 5254 var f = floor$3(n / 10); 5255 if (f === 0) return match; 5256 if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1); 5257 return match; 5258 } 5259 5260 capture = captures[n - 1]; 5261 } 5262 5263 return capture === undefined ? '' : capture; 5264 }); 5265 } 5266 }); 5267 5268 // @@search logic 5269 5270 5271 _fixReWks('search', 1, function (defined, SEARCH, $search, maybeCallNative) { 5272 return [// `String.prototype.search` method 5273 // https://tc39.github.io/ecma262/#sec-string.prototype.search 5274 function search(regexp) { 5275 var O = defined(this); 5276 var fn = regexp == undefined ? undefined : regexp[SEARCH]; 5277 return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O)); 5278 }, // `RegExp.prototype[@@search]` method 5279 // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@search 5280 function (regexp) { 5281 var res = maybeCallNative($search, regexp, this); 5282 if (res.done) return res.value; 5283 var rx = _anObject(regexp); 5284 var S = String(this); 5285 var previousLastIndex = rx.lastIndex; 5286 if (!_sameValue(previousLastIndex, 0)) rx.lastIndex = 0; 5287 var result = _regexpExecAbstract(rx, S); 5288 if (!_sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex; 5289 return result === null ? -1 : result.index; 5290 }]; 5291 }); 5292 5293 // 7.3.20 SpeciesConstructor(O, defaultConstructor) 5294 5295 5296 5297 5298 var SPECIES$3 = _wks('species'); 5299 5300 var _speciesConstructor = function (O, D) { 5301 var C = _anObject(O).constructor; 5302 var S; 5303 return C === undefined || (S = _anObject(C)[SPECIES$3]) == undefined ? D : _aFunction(S); 5304 }; 5305 5306 var $min = Math.min; 5307 var $push = [].push; 5308 var $SPLIT = 'split'; 5309 var LENGTH = 'length'; 5310 var LAST_INDEX$1 = 'lastIndex'; 5311 var MAX_UINT32 = 0xffffffff; // babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError 5312 5313 var SUPPORTS_Y = !_fails(function () { 5314 }); // @@split logic 5315 5316 _fixReWks('split', 2, function (defined, SPLIT, $split, maybeCallNative) { 5317 var internalSplit; 5318 5319 if ('abbc'[$SPLIT](/(b)*/)[1] == 'c' || 'test'[$SPLIT](/(?:)/, -1)[LENGTH] != 4 || 'ab'[$SPLIT](/(?:ab)*/)[LENGTH] != 2 || '.'[$SPLIT](/(.?)(.?)/)[LENGTH] != 4 || '.'[$SPLIT](/()()/)[LENGTH] > 1 || ''[$SPLIT](/.?/)[LENGTH]) { 5320 // based on es5-shim implementation, need to rework it 5321 internalSplit = function internalSplit(separator, limit) { 5322 var string = String(this); 5323 if (separator === undefined && limit === 0) return []; // If `separator` is not a regex, use native split 5324 5325 if (!_isRegexp(separator)) return $split.call(string, separator, limit); 5326 var output = []; 5327 var flags = (separator.ignoreCase ? 'i' : '') + (separator.multiline ? 'm' : '') + (separator.unicode ? 'u' : '') + (separator.sticky ? 'y' : ''); 5328 var lastLastIndex = 0; 5329 var splitLimit = limit === undefined ? MAX_UINT32 : limit >>> 0; // Make `global` and avoid `lastIndex` issues by working with a copy 5330 5331 var separatorCopy = new RegExp(separator.source, flags + 'g'); 5332 var match, lastIndex, lastLength; 5333 5334 while (match = _regexpExec.call(separatorCopy, string)) { 5335 lastIndex = separatorCopy[LAST_INDEX$1]; 5336 5337 if (lastIndex > lastLastIndex) { 5338 output.push(string.slice(lastLastIndex, match.index)); 5339 if (match[LENGTH] > 1 && match.index < string[LENGTH]) $push.apply(output, match.slice(1)); 5340 lastLength = match[0][LENGTH]; 5341 lastLastIndex = lastIndex; 5342 if (output[LENGTH] >= splitLimit) break; 5343 } 5344 5345 if (separatorCopy[LAST_INDEX$1] === match.index) separatorCopy[LAST_INDEX$1]++; // Avoid an infinite loop 5346 } 5347 5348 if (lastLastIndex === string[LENGTH]) { 5349 if (lastLength || !separatorCopy.test('')) output.push(''); 5350 } else output.push(string.slice(lastLastIndex)); 5351 5352 return output[LENGTH] > splitLimit ? output.slice(0, splitLimit) : output; 5353 }; // Chakra, V8 5354 5355 } else if ('0'[$SPLIT](undefined, 0)[LENGTH]) { 5356 internalSplit = function internalSplit(separator, limit) { 5357 return separator === undefined && limit === 0 ? [] : $split.call(this, separator, limit); 5358 }; 5359 } else { 5360 internalSplit = $split; 5361 } 5362 5363 return [// `String.prototype.split` method 5364 // https://tc39.github.io/ecma262/#sec-string.prototype.split 5365 function split(separator, limit) { 5366 var O = defined(this); 5367 var splitter = separator == undefined ? undefined : separator[SPLIT]; 5368 return splitter !== undefined ? splitter.call(separator, O, limit) : internalSplit.call(String(O), separator, limit); 5369 }
vendor: 70,404 bytes, lines 5369-7869
5369, // `RegExp.prototype[@@split]` method 5370 // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split 5371 // 5372 // NOTE: This cannot be properly polyfilled in engines that don't support 5373 // the 'y' flag. 5374 function (regexp, limit) { 5375 var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== $split); 5376 if (res.done) return res.value; 5377 var rx = _anObject(regexp); 5378 var S = String(this); 5379 var C = _speciesConstructor(rx, RegExp); 5380 var unicodeMatching = rx.unicode; 5381 var flags = (rx.ignoreCase ? 'i' : '') + (rx.multiline ? 'm' : '') + (rx.unicode ? 'u' : '') + (SUPPORTS_Y ? 'y' : 'g'); // ^(? + rx + ) is needed, in combination with some S slicing, to 5382 // simulate the 'y' flag. 5383 5384 var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags); 5385 var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; 5386 if (lim === 0) return []; 5387 if (S.length === 0) return _regexpExecAbstract(splitter, S) === null ? [S] : []; 5388 var p = 0; 5389 var q = 0; 5390 var A = []; 5391 5392 while (q < S.length) { 5393 splitter.lastIndex = SUPPORTS_Y ? q : 0; 5394 var z = _regexpExecAbstract(splitter, SUPPORTS_Y ? S : S.slice(q)); 5395 var e; 5396 5397 if (z === null || (e = $min(_toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p) { 5398 q = _advanceStringIndex(S, q, unicodeMatching); 5399 } else { 5400 A.push(S.slice(p, q)); 5401 if (A.length === lim) return A; 5402 5403 for (var i = 1; i <= z.length - 1; i++) { 5404 A.push(z[i]); 5405 if (A.length === lim) return A; 5406 } 5407 5408 q = p = e; 5409 } 5410 } 5411 5412 A.push(S.slice(p)); 5413 return A; 5414 }]; 5415 }); 5416 5417 var _anInstance = function (it, Constructor, name, forbiddenField) { 5418 if (!(it instanceof Constructor) || forbiddenField !== undefined && forbiddenField in it) { 5419 throw TypeError(name + ': incorrect invocation!'); 5420 } 5421 5422 return it; 5423 }; 5424 5425 var _forOf = createCommonjsModule(function (module) { 5426 var BREAK = {}; 5427 var RETURN = {}; 5428 5429 var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) { 5430 var iterFn = ITERATOR ? function () { 5431 return iterable; 5432 } : core_getIteratorMethod(iterable); 5433 var f = _ctx(fn, that, entries ? 2 : 1); 5434 var index = 0; 5435 var length, step, iterator, result; 5436 if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!'); // fast case for arrays with default iterator 5437 5438 if (_isArrayIter(iterFn)) for (length = _toLength(iterable.length); length > index; index++) { 5439 result = entries ? f(_anObject(step = iterable[index])[0], step[1]) : f(iterable[index]); 5440 if (result === BREAK || result === RETURN) return result; 5441 } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) { 5442 result = _iterCall(iterator, f, step.value, entries); 5443 if (result === BREAK || result === RETURN) return result; 5444 } 5445 }; 5446 5447 exports.BREAK = BREAK; 5448 exports.RETURN = RETURN; 5449 }); 5450 5451 var process = _global.process; 5452 var setTask = _global.setImmediate; 5453 var clearTask = _global.clearImmediate; 5454 var MessageChannel = _global.MessageChannel; 5455 var Dispatch = _global.Dispatch; 5456 var counter = 0; 5457 var queue = {}; 5458 var ONREADYSTATECHANGE = 'onreadystatechange'; 5459 var defer, channel, port; 5460 5461 var run = function run() { 5462 var id = +this; // eslint-disable-next-line no-prototype-builtins 5463 5464 if (queue.hasOwnProperty(id)) { 5465 var fn = queue[id]; 5466 delete queue[id]; 5467 fn(); 5468 } 5469 }; 5470 5471 var listener = function listener(event) { 5472 run.call(event.data); 5473 }; // Node.js 0.9+ & IE10+ has setImmediate, otherwise: 5474 5475 5476 if (!setTask || !clearTask) { 5477 setTask = function setImmediate(fn) { 5478 var args = []; 5479 var i = 1; 5480 5481 while (arguments.length > i) { 5482 args.push(arguments[i++]); 5483 } 5484 5485 queue[++counter] = function () { 5486 // eslint-disable-next-line no-new-func 5487 _invoke(typeof fn == 'function' ? fn : Function(fn), args); 5488 }; 5489 5490 defer(counter); 5491 return counter; 5492 }; 5493 5494 clearTask = function clearImmediate(id) { 5495 delete queue[id]; 5496 }; // Node.js 0.8- 5497 5498 5499 if (_cof(process) == 'process') { 5500 defer = function defer(id) { 5501 process.nextTick(_ctx(run, id, 1)); 5502 }; // Sphere (JS game engine) Dispatch API 5503 5504 } else if (Dispatch && Dispatch.now) { 5505 defer = function defer(id) { 5506 Dispatch.now(_ctx(run, id, 1)); 5507 }; // Browsers with MessageChannel, includes WebWorkers 5508 5509 } else if (MessageChannel) { 5510 channel = new MessageChannel(); 5511 port = channel.port2; 5512 channel.port1.onmessage = listener; 5513 defer = _ctx(port.postMessage, port, 1); // Browsers with postMessage, skip WebWorkers 5514 // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' 5515 } else if (_global.addEventListener && typeof postMessage == 'function' && !_global.importScripts) { 5516 defer = function defer(id) { 5517 _global.postMessage(id + '', '*'); 5518 }; 5519 5520 _global.addEventListener('message', listener, false); // IE8- 5521 } else if (ONREADYSTATECHANGE in _domCreate('script')) { 5522 defer = function defer(id) { 5523 _html.appendChild(_domCreate('script'))[ONREADYSTATECHANGE] = function () { 5524 _html.removeChild(this); 5525 run.call(id); 5526 }; 5527 }; // Rest old browsers 5528 5529 } else { 5530 defer = function defer(id) { 5531 setTimeout(_ctx(run, id, 1), 0); 5532 }; 5533 } 5534 } 5535 5536 var _task = { 5537 set: setTask, 5538 clear: clearTask 5539 }; 5540 5541 var macrotask = _task.set; 5542 5543 var Observer = _global.MutationObserver || _global.WebKitMutationObserver; 5544 var process$1 = _global.process; 5545 var Promise = _global.Promise; 5546 var isNode = _cof(process$1) == 'process'; 5547 5548 var _microtask = function () { 5549 var head, last, notify; 5550 5551 var flush = function flush() { 5552 var parent, fn; 5553 if (isNode && (parent = process$1.domain)) parent.exit(); 5554 5555 while (head) { 5556 fn = head.fn; 5557 head = head.next; 5558 5559 try { 5560 fn(); 5561 } catch (e) { 5562 if (head) notify();else last = undefined; 5563 throw e; 5564 } 5565 } 5566 5567 last = undefined; 5568 if (parent) parent.enter(); 5569 }; // Node.js 5570 5571 5572 if (isNode) { 5573 notify = function notify() { 5574 process$1.nextTick(flush); 5575 }; // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339 5576 5577 } else if (Observer && !(_global.navigator && _global.navigator.standalone)) { 5578 var toggle = true; 5579 var node = document.createTextNode(''); 5580 new Observer(flush).observe(node, { 5581 characterData: true 5582 }); // eslint-disable-line no-new 5583 5584 notify = function notify() { 5585 node.data = toggle = !toggle; 5586 }; // environments with maybe non-completely correct, but existent Promise 5587 5588 } else if (Promise && Promise.resolve) { 5589 // Promise.resolve without an argument throws an error in LG WebOS 2 5590 var promise = Promise.resolve(undefined); 5591 5592 notify = function notify() { 5593 promise.then(flush); 5594 }; // for other environments - macrotask based on: 5595 // - setImmediate 5596 // - MessageChannel 5597 // - window.postMessag 5598 // - onreadystatechange 5599 // - setTimeout 5600 5601 } else { 5602 notify = function notify() { 5603 // strange IE + webpack dev server bug - use .call(global) 5604 macrotask.call(_global, flush); 5605 }; 5606 } 5607 5608 return function (fn) { 5609 var task = { 5610 fn: fn, 5611 next: undefined 5612 }; 5613 if (last) last.next = task; 5614 5615 if (!head) { 5616 head = task; 5617 notify(); 5618 } 5619 5620 last = task; 5621 }; 5622 }; 5623 5624 function PromiseCapability(C) { 5625 var resolve, reject; 5626 this.promise = new C(function ($$resolve, $$reject) { 5627 if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor'); 5628 resolve = $$resolve; 5629 reject = $$reject; 5630 }); 5631 this.resolve = _aFunction(resolve); 5632 this.reject = _aFunction(reject); 5633 } 5634 5635 var f$7 = function (C) { 5636 return new PromiseCapability(C); 5637 }; 5638 5639 var _newPromiseCapability = { 5640 f: f$7 5641 }; 5642 5643 var _perform = function (exec) { 5644 try { 5645 return { 5646 e: false, 5647 v: exec() 5648 }; 5649 } catch (e) { 5650 return { 5651 e: true, 5652 v: e 5653 }; 5654 } 5655 }; 5656 5657 var navigator = _global.navigator; 5658 var _userAgent = navigator && navigator.userAgent || ''; 5659 5660 var _promiseResolve = function (C, x) { 5661 _anObject(C); 5662 if (_isObject(x) && x.constructor === C) return x; 5663 var promiseCapability = _newPromiseCapability.f(C); 5664 var resolve = promiseCapability.resolve; 5665 resolve(x); 5666 return promiseCapability.promise; 5667 }; 5668 5669 var _redefineAll = function (target, src, safe) { 5670 for (var key in src) { 5671 _redefine(target, key, src[key], safe); 5672 } 5673 5674 return target; 5675 }; 5676 5677 var task = _task.set; 5678 5679 var microtask = _microtask(); 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 var PROMISE = 'Promise'; 5690 var TypeError$1 = _global.TypeError; 5691 var process$2 = _global.process; 5692 var versions = process$2 && process$2.versions; 5693 var v8 = versions && versions.v8 || ''; 5694 var $Promise = _global[PROMISE]; 5695 var isNode$1 = _classof(process$2) == 'process'; 5696 5697 var empty = function empty() { 5698 /* empty */ 5699 }; 5700 5701 var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper; 5702 var newPromiseCapability = newGenericPromiseCapability = _newPromiseCapability.f; 5703 var USE_NATIVE$1 = !!function () { 5704 try { 5705 // correct subclassing with @@species support 5706 var promise = $Promise.resolve(1); 5707 5708 var FakePromise = (promise.constructor = {})[_wks('species')] = function (exec) { 5709 exec(empty, empty); 5710 }; // unhandled rejections tracking support, NodeJS Promise without it fails @@species test 5711 5712 5713 return (isNode$1 || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables 5714 // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 5715 // we can't detect it synchronously, so just check versions 5716 && v8.indexOf('6.6') !== 0 && _userAgent.indexOf('Chrome/66') === -1; 5717 } catch (e) { 5718 /* empty */ 5719 } 5720 }(); // helpers 5721 5722 var isThenable = function isThenable(it) { 5723 var then; 5724 return _isObject(it) && typeof (then = it.then) == 'function' ? then : false; 5725 }; 5726 5727 var notify = function notify(promise, isReject) { 5728 if (promise._n) return; 5729 promise._n = true; 5730 var chain = promise._c; 5731 microtask(function () { 5732 var value = promise._v; 5733 var ok = promise._s == 1; 5734 var i = 0; 5735 5736 var run = function run(reaction) { 5737 var handler = ok ? reaction.ok : reaction.fail; 5738 var resolve = reaction.resolve; 5739 var reject = reaction.reject; 5740 var domain = reaction.domain; 5741 var result, then, exited; 5742 5743 try { 5744 if (handler) { 5745 if (!ok) { 5746 if (promise._h == 2) onHandleUnhandled(promise); 5747 promise._h = 1; 5748 } 5749 5750 if (handler === true) result = value;else { 5751 if (domain) domain.enter(); 5752 result = handler(value); // may throw 5753 5754 if (domain) { 5755 domain.exit(); 5756 exited = true; 5757 } 5758 } 5759 5760 if (result === reaction.promise) { 5761 reject(TypeError$1('Promise-chain cycle')); 5762 } else if (then = isThenable(result)) { 5763 then.call(result, resolve, reject); 5764 } else resolve(result); 5765 } else reject(value); 5766 } catch (e) { 5767 if (domain && !exited) domain.exit(); 5768 reject(e); 5769 } 5770 }; 5771 5772 while (chain.length > i) { 5773 run(chain[i++]); 5774 } // variable length - can't use forEach 5775 5776 5777 promise._c = []; 5778 promise._n = false; 5779 if (isReject && !promise._h) onUnhandled(promise); 5780 }); 5781 }; 5782 5783 var onUnhandled = function onUnhandled(promise) { 5784 task.call(_global, function () { 5785 var value = promise._v; 5786 var unhandled = isUnhandled(promise); 5787 var result, handler, console; 5788 5789 if (unhandled) { 5790 result = _perform(function () { 5791 if (isNode$1) { 5792 process$2.emit('unhandledRejection', value, promise); 5793 } else if (handler = _global.onunhandledrejection) { 5794 handler({ 5795 promise: promise, 5796 reason: value 5797 }); 5798 } else if ((console = _global.console) && console.error) { 5799 console.error('Unhandled promise rejection', value); 5800 } 5801 }); // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should 5802 5803 promise._h = isNode$1 || isUnhandled(promise) ? 2 : 1; 5804 } 5805 5806 promise._a = undefined; 5807 if (unhandled && result.e) throw result.v; 5808 }); 5809 }; 5810 5811 var isUnhandled = function isUnhandled(promise) { 5812 return promise._h !== 1 && (promise._a || promise._c).length === 0; 5813 }; 5814 5815 var onHandleUnhandled = function onHandleUnhandled(promise) { 5816 task.call(_global, function () { 5817 var handler; 5818 5819 if (isNode$1) { 5820 process$2.emit('rejectionHandled', promise); 5821 } else if (handler = _global.onrejectionhandled) { 5822 handler({ 5823 promise: promise, 5824 reason: promise._v 5825 }); 5826 } 5827 }); 5828 }; 5829 5830 var $reject = function $reject(value) { 5831 var promise = this; 5832 if (promise._d) return; 5833 promise._d = true; 5834 promise = promise._w || promise; // unwrap 5835 5836 promise._v = value; 5837 promise._s = 2; 5838 if (!promise._a) promise._a = promise._c.slice(); 5839 notify(promise, true); 5840 }; 5841 5842 var $resolve = function $resolve(value) { 5843 var promise = this; 5844 var then; 5845 if (promise._d) return; 5846 promise._d = true; 5847 promise = promise._w || promise; // unwrap 5848 5849 try { 5850 if (promise === value) throw TypeError$1("Promise can't be resolved itself"); 5851 5852 if (then = isThenable(value)) { 5853 microtask(function () { 5854 var wrapper = { 5855 _w: promise, 5856 _d: false 5857 }; // wrap 5858 5859 try { 5860 then.call(value, _ctx($resolve, wrapper, 1), _ctx($reject, wrapper, 1)); 5861 } catch (e) { 5862 $reject.call(wrapper, e); 5863 } 5864 }); 5865 } else { 5866 promise._v = value; 5867 promise._s = 1; 5868 notify(promise, false); 5869 } 5870 } catch (e) { 5871 $reject.call({ 5872 _w: promise, 5873 _d: false 5874 }, e); // wrap 5875 } 5876 }; // constructor polyfill 5877 5878 5879 if (!USE_NATIVE$1) { 5880 // 25.4.3.1 Promise(executor) 5881 $Promise = function Promise(executor) { 5882 _anInstance(this, $Promise, PROMISE, '_h'); 5883 _aFunction(executor); 5884 Internal.call(this); 5885 5886 try { 5887 executor(_ctx($resolve, this, 1), _ctx($reject, this, 1)); 5888 } catch (err) { 5889 $reject.call(this, err); 5890 } 5891 }; // eslint-disable-next-line no-unused-vars 5892 5893 5894 Internal = function Promise(executor) { 5895 this._c = []; // <- awaiting reactions 5896 5897 this._a = undefined; // <- checked in isUnhandled reactions 5898 5899 this._s = 0; // <- state 5900 5901 this._d = false; // <- done 5902 5903 this._v = undefined; // <- value 5904 5905 this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled 5906 5907 this._n = false; // <- notify 5908 }; 5909 5910 Internal.prototype = _redefineAll($Promise.prototype, { 5911 // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected) 5912 then: function then(onFulfilled, onRejected) { 5913 var reaction = newPromiseCapability(_speciesConstructor(this, $Promise)); 5914 reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true; 5915 reaction.fail = typeof onRejected == 'function' && onRejected; 5916 reaction.domain = isNode$1 ? process$2.domain : undefined; 5917 5918 this._c.push(reaction); 5919 5920 if (this._a) this._a.push(reaction); 5921 if (this._s) notify(this, false); 5922 return reaction.promise; 5923 }, 5924 // 25.4.5.1 Promise.prototype.catch(onRejected) 5925 'catch': function _catch(onRejected) { 5926 return this.then(undefined, onRejected); 5927 } 5928 }); 5929 5930 OwnPromiseCapability = function OwnPromiseCapability() { 5931 var promise = new Internal(); 5932 this.promise = promise; 5933 this.resolve = _ctx($resolve, promise, 1); 5934 this.reject = _ctx($reject, promise, 1); 5935 }; 5936 5937 _newPromiseCapability.f = newPromiseCapability = function newPromiseCapability(C) { 5938 return C === $Promise || C === Wrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C); 5939 }; 5940 } 5941 5942 _export(_export.G + _export.W + _export.F * !USE_NATIVE$1, { 5943 Promise: $Promise 5944 }); 5945 5946 _setToStringTag($Promise, PROMISE); 5947 5948 _setSpecies(PROMISE); 5949 5950 Wrapper = _core[PROMISE]; // statics 5951 5952 _export(_export.S + _export.F * !USE_NATIVE$1, PROMISE, { 5953 // 25.4.4.5 Promise.reject(r) 5954 reject: function reject(r) { 5955 var capability = newPromiseCapability(this); 5956 var $$reject = capability.reject; 5957 $$reject(r); 5958 return capability.promise; 5959 } 5960 }); 5961 _export(_export.S + _export.F * (_library || !USE_NATIVE$1), PROMISE, { 5962 // 25.4.4.6 Promise.resolve(x) 5963 resolve: function resolve(x) { 5964 return _promiseResolve(_library && this === Wrapper ? $Promise : this, x); 5965 } 5966 }); 5967 _export(_export.S + _export.F * !(USE_NATIVE$1 && _iterDetect(function (iter) { 5968 $Promise.all(iter)['catch'](empty); 5969 })), PROMISE, { 5970 // 25.4.4.1 Promise.all(iterable) 5971 all: function all(iterable) { 5972 var C = this; 5973 var capability = newPromiseCapability(C); 5974 var resolve = capability.resolve; 5975 var reject = capability.reject; 5976 var result = _perform(function () { 5977 var values = []; 5978 var index = 0; 5979 var remaining = 1; 5980 _forOf(iterable, false, function (promise) { 5981 var $index = index++; 5982 var alreadyCalled = false; 5983 values.push(undefined); 5984 remaining++; 5985 C.resolve(promise).then(function (value) { 5986 if (alreadyCalled) return; 5987 alreadyCalled = true; 5988 values[$index] = value; 5989 --remaining || resolve(values); 5990 }, reject); 5991 }); 5992 --remaining || resolve(values); 5993 }); 5994 if (result.e) reject(result.v); 5995 return capability.promise; 5996 }, 5997 // 25.4.4.4 Promise.race(iterable) 5998 race: function race(iterable) { 5999 var C = this; 6000 var capability = newPromiseCapability(C); 6001 var reject = capability.reject; 6002 var result = _perform(function () { 6003 _forOf(iterable, false, function (promise) { 6004 C.resolve(promise).then(capability.resolve, reject); 6005 }); 6006 }); 6007 if (result.e) reject(result.v); 6008 return capability.promise; 6009 } 6010 }); 6011 6012 var _validateCollection = function (it, TYPE) { 6013 if (!_isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!'); 6014 return it; 6015 }; 6016 6017 var dP$5 = _objectDp.f; 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 var fastKey = _meta.fastKey; 6038 6039 6040 6041 var SIZE = _descriptors ? '_s' : 'size'; 6042 6043 var getEntry = function getEntry(that, key) { 6044 // fast case 6045 var index = fastKey(key); 6046 var entry; 6047 if (index !== 'F') return that._i[index]; // frozen object case 6048 6049 for (entry = that._f; entry; entry = entry.n) { 6050 if (entry.k == key) return entry; 6051 } 6052 }; 6053 6054 var _collectionStrong = { 6055 getConstructor: function getConstructor(wrapper, NAME, IS_MAP, ADDER) { 6056 var C = wrapper(function (that, iterable) { 6057 _anInstance(that, C, NAME, '_i'); 6058 that._t = NAME; // collection type 6059 6060 that._i = _objectCreate(null); // index 6061 6062 that._f = undefined; // first entry 6063 6064 that._l = undefined; // last entry 6065 6066 that[SIZE] = 0; // size 6067 6068 if (iterable != undefined) _forOf(iterable, IS_MAP, that[ADDER], that); 6069 }); 6070 _redefineAll(C.prototype, { 6071 // 23.1.3.1 Map.prototype.clear() 6072 // 23.2.3.2 Set.prototype.clear() 6073 clear: function clear() { 6074 for (var that = _validateCollection(this, NAME), data = that._i, entry = that._f; entry; entry = entry.n) { 6075 entry.r = true; 6076 if (entry.p) entry.p = entry.p.n = undefined; 6077 delete data[entry.i]; 6078 } 6079 6080 that._f = that._l = undefined; 6081 that[SIZE] = 0; 6082 }, 6083 // 23.1.3.3 Map.prototype.delete(key) 6084 // 23.2.3.4 Set.prototype.delete(value) 6085 'delete': function _delete(key) { 6086 var that = _validateCollection(this, NAME); 6087 var entry = getEntry(that, key); 6088 6089 if (entry) { 6090 var next = entry.n; 6091 var prev = entry.p; 6092 delete that._i[entry.i]; 6093 entry.r = true; 6094 if (prev) prev.n = next; 6095 if (next) next.p = prev; 6096 if (that._f == entry) that._f = next; 6097 if (that._l == entry) that._l = prev; 6098 that[SIZE]--; 6099 } 6100 6101 return !!entry; 6102 }, 6103 // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined) 6104 // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined) 6105 forEach: function forEach(callbackfn 6106 /* , that = undefined */ 6107 ) { 6108 _validateCollection(this, NAME); 6109 var f = _ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); 6110 var entry; 6111 6112 while (entry = entry ? entry.n : this._f) { 6113 f(entry.v, entry.k, this); // revert to the last existing entry 6114 6115 while (entry && entry.r) { 6116 entry = entry.p; 6117 } 6118 } 6119 }, 6120 // 23.1.3.7 Map.prototype.has(key) 6121 // 23.2.3.7 Set.prototype.has(value) 6122 has: function has(key) { 6123 return !!getEntry(_validateCollection(this, NAME), key); 6124 } 6125 }); 6126 if (_descriptors) dP$5(C.prototype, 'size', { 6127 get: function get() { 6128 return _validateCollection(this, NAME)[SIZE]; 6129 } 6130 }); 6131 return C; 6132 }, 6133 def: function def(that, key, value) { 6134 var entry = getEntry(that, key); 6135 var prev, index; // change existing entry 6136 6137 if (entry) { 6138 entry.v = value; // create new entry 6139 } else { 6140 that._l = entry = { 6141 i: index = fastKey(key, true), 6142 // <- index 6143 k: key, 6144 // <- key 6145 v: value, 6146 // <- value 6147 p: prev = that._l, 6148 // <- previous entry 6149 n: undefined, 6150 // <- next entry 6151 r: false // <- removed 6152 6153 }; 6154 if (!that._f) that._f = entry; 6155 if (prev) prev.n = entry; 6156 that[SIZE]++; // add to index 6157 6158 if (index !== 'F') that._i[index] = entry; 6159 } 6160 6161 return that; 6162 }, 6163 getEntry: getEntry, 6164 setStrong: function setStrong(C, NAME, IS_MAP) { 6165 // add .keys, .values, .entries, [@@iterator] 6166 // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11 6167 _iterDefine(C, NAME, function (iterated, kind) { 6168 this._t = _validateCollection(iterated, NAME); // target 6169 6170 this._k = kind; // kind 6171 6172 this._l = undefined; // previous 6173 }, function () { 6174 var that = this; 6175 var kind = that._k; 6176 var entry = that._l; // revert to the last existing entry 6177 6178 while (entry && entry.r) { 6179 entry = entry.p; 6180 } // get next entry 6181 6182 6183 if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) { 6184 // or finish the iteration 6185 that._t = undefined; 6186 return _iterStep(1); 6187 } // return step by kind 6188 6189 6190 if (kind == 'keys') return _iterStep(0, entry.k); 6191 if (kind == 'values') return _iterStep(0, entry.v); 6192 return _iterStep(0, [entry.k, entry.v]); 6193 }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); // add [@@species], 23.1.2.2, 23.2.2.2 6194 6195 _setSpecies(NAME); 6196 } 6197 }; 6198 6199 var _collection = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) { 6200 var Base = _global[NAME]; 6201 var C = Base; 6202 var ADDER = IS_MAP ? 'set' : 'add'; 6203 var proto = C && C.prototype; 6204 var O = {}; 6205 6206 var fixMethod = function fixMethod(KEY) { 6207 var fn = proto[KEY]; 6208 _redefine(proto, KEY, KEY == 'delete' ? function (a) { 6209 return IS_WEAK && !_isObject(a) ? false : fn.call(this, a === 0 ? 0 : a); 6210 } : KEY == 'has' ? function has(a) { 6211 return IS_WEAK && !_isObject(a) ? false : fn.call(this, a === 0 ? 0 : a); 6212 } : KEY == 'get' ? function get(a) { 6213 return IS_WEAK && !_isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a); 6214 } : KEY == 'add' ? function add(a) { 6215 fn.call(this, a === 0 ? 0 : a); 6216 return this; 6217 } : function set(a, b) { 6218 fn.call(this, a === 0 ? 0 : a, b); 6219 return this; 6220 }); 6221 }; 6222 6223 if (typeof C != 'function' || !(IS_WEAK || proto.forEach && !_fails(function () { 6224 new C().entries().next(); 6225 }))) { 6226 // create collection constructor 6227 C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER); 6228 _redefineAll(C.prototype, methods); 6229 _meta.NEED = true; 6230 } else { 6231 var instance = new C(); // early implementations not supports chaining 6232 6233 var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false 6234 6235 var THROWS_ON_PRIMITIVES = _fails(function () { 6236 instance.has(1); 6237 }); // most early implementations doesn't supports iterables, most modern - not close it correctly 6238 6239 var ACCEPT_ITERABLES = _iterDetect(function (iter) { 6240 new C(iter); 6241 }); // eslint-disable-line no-new 6242 // for early implementations -0 and +0 not the same 6243 6244 var BUGGY_ZERO = !IS_WEAK && _fails(function () { 6245 // V8 ~ Chromium 42- fails only with 5+ elements 6246 var $instance = new C(); 6247 var index = 5; 6248 6249 while (index--) { 6250 $instance[ADDER](index, index); 6251 } 6252 6253 return !$instance.has(-0); 6254 }); 6255 6256 if (!ACCEPT_ITERABLES) { 6257 C = wrapper(function (target, iterable) { 6258 _anInstance(target, C, NAME); 6259 var that = _inheritIfRequired(new Base(), target, C); 6260 if (iterable != undefined) _forOf(iterable, IS_MAP, that[ADDER], that); 6261 return that; 6262 }); 6263 C.prototype = proto; 6264 proto.constructor = C; 6265 } 6266 6267 if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { 6268 fixMethod('delete'); 6269 fixMethod('has'); 6270 IS_MAP && fixMethod('get'); 6271 } 6272 6273 if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); // weak collections should not contains .clear method 6274 6275 if (IS_WEAK && proto.clear) delete proto.clear; 6276 } 6277 6278 _setToStringTag(C, NAME); 6279 O[NAME] = C; 6280 _export(_export.G + _export.W + _export.F * (C != Base), O); 6281 if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP); 6282 return C; 6283 }; 6284 6285 var MAP = 'Map'; // 23.1 Map Objects 6286 6287 var es6_map = _collection(MAP, function (get) { 6288 return function Map() { 6289 return get(this, arguments.length > 0 ? arguments[0] : undefined); 6290 }; 6291 }, { 6292 // 23.1.3.6 Map.prototype.get(key) 6293 get: function get(key) { 6294 var entry = _collectionStrong.getEntry(_validateCollection(this, MAP), key); 6295 return entry && entry.v; 6296 }, 6297 // 23.1.3.9 Map.prototype.set(key, value) 6298 set: function set(key, value) { 6299 return _collectionStrong.def(_validateCollection(this, MAP), key === 0 ? 0 : key, value); 6300 } 6301 }, _collectionStrong, true); 6302 6303 var SET = 'Set'; // 23.2 Set Objects 6304 6305 var es6_set = _collection(SET, function (get) { 6306 return function Set() { 6307 return get(this, arguments.length > 0 ? arguments[0] : undefined); 6308 }; 6309 }, { 6310 // 23.2.3.1 Set.prototype.add(value) 6311 add: function add(value) { 6312 return _collectionStrong.def(_validateCollection(this, SET), value = value === 0 ? 0 : value, value); 6313 } 6314 }, _collectionStrong); 6315 6316 var getWeak = _meta.getWeak; 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 var arrayFind = _arrayMethods(5); 6333 var arrayFindIndex = _arrayMethods(6); 6334 var id$1 = 0; // fallback for uncaught frozen keys 6335 6336 var uncaughtFrozenStore = function uncaughtFrozenStore(that) { 6337 return that._l || (that._l = new UncaughtFrozenStore()); 6338 }; 6339 6340 var UncaughtFrozenStore = function UncaughtFrozenStore() { 6341 this.a = []; 6342 }; 6343 6344 var findUncaughtFrozen = function findUncaughtFrozen(store, key) { 6345 return arrayFind(store.a, function (it) { 6346 return it[0] === key; 6347 }); 6348 }; 6349 6350 UncaughtFrozenStore.prototype = { 6351 get: function get(key) { 6352 var entry = findUncaughtFrozen(this, key); 6353 if (entry) return entry[1]; 6354 }, 6355 has: function has(key) { 6356 return !!findUncaughtFrozen(this, key); 6357 }, 6358 set: function set(key, value) { 6359 var entry = findUncaughtFrozen(this, key); 6360 if (entry) entry[1] = value;else this.a.push([key, value]); 6361 }, 6362 'delete': function _delete(key) { 6363 var index = arrayFindIndex(this.a, function (it) { 6364 return it[0] === key; 6365 }); 6366 if (~index) this.a.splice(index, 1); 6367 return !!~index; 6368 } 6369 }; 6370 var _collectionWeak = { 6371 getConstructor: function getConstructor(wrapper, NAME, IS_MAP, ADDER) { 6372 var C = wrapper(function (that, iterable) { 6373 _anInstance(that, C, NAME, '_i'); 6374 that._t = NAME; // collection type 6375 6376 that._i = id$1++; // collection id 6377 6378 that._l = undefined; // leak store for uncaught frozen objects 6379 6380 if (iterable != undefined) _forOf(iterable, IS_MAP, that[ADDER], that); 6381 }); 6382 _redefineAll(C.prototype, { 6383 // 23.3.3.2 WeakMap.prototype.delete(key) 6384 // 23.4.3.3 WeakSet.prototype.delete(value) 6385 'delete': function _delete(key) { 6386 if (!_isObject(key)) return false; 6387 var data = getWeak(key); 6388 if (data === true) return uncaughtFrozenStore(_validateCollection(this, NAME))['delete'](key); 6389 return data && _has(data, this._i) && delete data[this._i]; 6390 }, 6391 // 23.3.3.4 WeakMap.prototype.has(key) 6392 // 23.4.3.4 WeakSet.prototype.has(value) 6393 has: function has(key) { 6394 if (!_isObject(key)) return false; 6395 var data = getWeak(key); 6396 if (data === true) return uncaughtFrozenStore(_validateCollection(this, NAME)).has(key); 6397 return data && _has(data, this._i); 6398 } 6399 }); 6400 return C; 6401 }, 6402 def: function def(that, key, value) { 6403 var data = getWeak(_anObject(key), true); 6404 if (data === true) uncaughtFrozenStore(that).set(key, value);else data[that._i] = value; 6405 return that; 6406 }, 6407 ufstore: uncaughtFrozenStore 6408 }; 6409 6410 var es6_weakMap = createCommonjsModule(function (module) { 6411 6412 var each = _arrayMethods(0); 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 var WEAK_MAP = 'WeakMap'; 6429 var getWeak = _meta.getWeak; 6430 var isExtensible = Object.isExtensible; 6431 var uncaughtFrozenStore = _collectionWeak.ufstore; 6432 var tmp = {}; 6433 var InternalMap; 6434 6435 var wrapper = function wrapper(get) { 6436 return function WeakMap() { 6437 return get(this, arguments.length > 0 ? arguments[0] : undefined); 6438 }; 6439 }; 6440 6441 var methods = { 6442 // 23.3.3.3 WeakMap.prototype.get(key) 6443 get: function get(key) { 6444 if (_isObject(key)) { 6445 var data = getWeak(key); 6446 if (data === true) return uncaughtFrozenStore(_validateCollection(this, WEAK_MAP)).get(key); 6447 return data ? data[this._i] : undefined; 6448 } 6449 }, 6450 // 23.3.3.5 WeakMap.prototype.set(key, value) 6451 set: function set(key, value) { 6452 return _collectionWeak.def(_validateCollection(this, WEAK_MAP), key, value); 6453 } 6454 }; // 23.3 WeakMap Objects 6455 6456 var $WeakMap = module.exports = _collection(WEAK_MAP, wrapper, methods, _collectionWeak, true, true); // IE11 WeakMap frozen keys fix 6457 6458 6459 if (_fails(function () { 6460 return new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7; 6461 })) { 6462 InternalMap = _collectionWeak.getConstructor(wrapper, WEAK_MAP); 6463 _objectAssign(InternalMap.prototype, methods); 6464 _meta.NEED = true; 6465 each(['delete', 'has', 'get', 'set'], function (key) { 6466 var proto = $WeakMap.prototype; 6467 var method = proto[key]; 6468 _redefine(proto, key, function (a, b) { 6469 // store frozen objects on internal weakmap shim 6470 if (_isObject(a) && !isExtensible(a)) { 6471 if (!this._f) this._f = new InternalMap(); 6472 6473 var result = this._f[key](a, b); 6474 6475 return key == 'set' ? this : result; // store all the rest on native weakmap 6476 } 6477 6478 return method.call(this, a, b); 6479 }); 6480 }); 6481 } 6482 }); 6483 6484 var WEAK_SET = 'WeakSet'; // 23.4 WeakSet Objects 6485 6486 _collection(WEAK_SET, function (get) { 6487 return function WeakSet() { 6488 return get(this, arguments.length > 0 ? arguments[0] : undefined); 6489 }; 6490 }, { 6491 // 23.4.3.1 WeakSet.prototype.add(value) 6492 add: function add(value) { 6493 return _collectionWeak.def(_validateCollection(this, WEAK_SET), value, true); 6494 } 6495 }, _collectionWeak, false, true); 6496 6497 var TYPED = _uid('typed_array'); 6498 var VIEW = _uid('view'); 6499 var ABV = !!(_global.ArrayBuffer && _global.DataView); 6500 var CONSTR = ABV; 6501 var i$1 = 0; 6502 var l = 9; 6503 var Typed; 6504 var TypedArrayConstructors = 'Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array'.split(','); 6505 6506 while (i$1 < l) { 6507 if (Typed = _global[TypedArrayConstructors[i$1++]]) { 6508 _hide(Typed.prototype, TYPED, true); 6509 _hide(Typed.prototype, VIEW, true); 6510 } else CONSTR = false; 6511 } 6512 6513 var _typed = { 6514 ABV: ABV, 6515 CONSTR: CONSTR, 6516 TYPED: TYPED, 6517 VIEW: VIEW 6518 }; 6519 6520 // https://tc39.github.io/ecma262/#sec-toindex 6521 6522 6523 6524 6525 var _toIndex = function (it) { 6526 if (it === undefined) return 0; 6527 var number = _toInteger(it); 6528 var length = _toLength(number); 6529 if (number !== length) throw RangeError('Wrong length!'); 6530 return length; 6531 }; 6532 6533 var _typedBuffer = createCommonjsModule(function (module, exports) { 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 var gOPN = _objectGopn.f; 6558 6559 var dP = _objectDp.f; 6560 6561 6562 6563 6564 6565 var ARRAY_BUFFER = 'ArrayBuffer'; 6566 var DATA_VIEW = 'DataView'; 6567 var PROTOTYPE = 'prototype'; 6568 var WRONG_LENGTH = 'Wrong length!'; 6569 var WRONG_INDEX = 'Wrong index!'; 6570 var $ArrayBuffer = _global[ARRAY_BUFFER]; 6571 var $DataView = _global[DATA_VIEW]; 6572 var Math = _global.Math; 6573 var RangeError = _global.RangeError; // eslint-disable-next-line no-shadow-restricted-names 6574 6575 var Infinity = _global.Infinity; 6576 var BaseBuffer = $ArrayBuffer; 6577 var abs = Math.abs; 6578 var pow = Math.pow; 6579 var floor = Math.floor; 6580 var log = Math.log; 6581 var LN2 = Math.LN2; 6582 var BUFFER = 'buffer'; 6583 var BYTE_LENGTH = 'byteLength'; 6584 var BYTE_OFFSET = 'byteOffset'; 6585 var $BUFFER = _descriptors ? '_b' : BUFFER; 6586 var $LENGTH = _descriptors ? '_l' : BYTE_LENGTH; 6587 var $OFFSET = _descriptors ? '_o' : BYTE_OFFSET; // IEEE754 conversions based on https://github.com/feross/ieee754 6588 6589 function packIEEE754(value, mLen, nBytes) { 6590 var buffer = new Array(nBytes); 6591 var eLen = nBytes * 8 - mLen - 1; 6592 var eMax = (1 << eLen) - 1; 6593 var eBias = eMax >> 1; 6594 var rt = mLen === 23 ? pow(2, -24) - pow(2, -77) : 0; 6595 var i = 0; 6596 var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0; 6597 var e, m, c; 6598 value = abs(value); // eslint-disable-next-line no-self-compare 6599 6600 if (value != value || value === Infinity) { 6601 // eslint-disable-next-line no-self-compare 6602 m = value != value ? 1 : 0; 6603 e = eMax; 6604 } else { 6605 e = floor(log(value) / LN2); 6606 6607 if (value * (c = pow(2, -e)) < 1) { 6608 e--; 6609 c *= 2; 6610 } 6611 6612 if (e + eBias >= 1) { 6613 value += rt / c; 6614 } else { 6615 value += rt * pow(2, 1 - eBias); 6616 } 6617 6618 if (value * c >= 2) { 6619 e++; 6620 c /= 2; 6621 } 6622 6623 if (e + eBias >= eMax) { 6624 m = 0; 6625 e = eMax; 6626 } else if (e + eBias >= 1) { 6627 m = (value * c - 1) * pow(2, mLen); 6628 e = e + eBias; 6629 } else { 6630 m = value * pow(2, eBias - 1) * pow(2, mLen); 6631 e = 0; 6632 } 6633 } 6634 6635 for (; mLen >= 8; buffer[i++] = m & 255, m /= 256, mLen -= 8) { 6636 } 6637 6638 e = e << mLen | m; 6639 eLen += mLen; 6640 6641 for (; eLen > 0; buffer[i++] = e & 255, e /= 256, eLen -= 8) { 6642 } 6643 6644 buffer[--i] |= s * 128; 6645 return buffer; 6646 } 6647 6648 function unpackIEEE754(buffer, mLen, nBytes) { 6649 var eLen = nBytes * 8 - mLen - 1; 6650 var eMax = (1 << eLen) - 1; 6651 var eBias = eMax >> 1; 6652 var nBits = eLen - 7; 6653 var i = nBytes - 1; 6654 var s = buffer[i--]; 6655 var e = s & 127; 6656 var m; 6657 s >>= 7; 6658 6659 for (; nBits > 0; e = e * 256 + buffer[i], i--, nBits -= 8) { 6660 } 6661 6662 m = e & (1 << -nBits) - 1; 6663 e >>= -nBits; 6664 nBits += mLen; 6665 6666 for (; nBits > 0; m = m * 256 + buffer[i], i--, nBits -= 8) { 6667 } 6668 6669 if (e === 0) { 6670 e = 1 - eBias; 6671 } else if (e === eMax) { 6672 return m ? NaN : s ? -Infinity : Infinity; 6673 } else { 6674 m = m + pow(2, mLen); 6675 e = e - eBias; 6676 } 6677 6678 return (s ? -1 : 1) * m * pow(2, e - mLen); 6679 } 6680 6681 function unpackI32(bytes) { 6682 return bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0]; 6683 } 6684 6685 function packI8(it) { 6686 return [it & 0xff]; 6687 } 6688 6689 function packI16(it) { 6690 return [it & 0xff, it >> 8 & 0xff]; 6691 } 6692 6693 function packI32(it) { 6694 return [it & 0xff, it >> 8 & 0xff, it >> 16 & 0xff, it >> 24 & 0xff]; 6695 } 6696 6697 function packF64(it) { 6698 return packIEEE754(it, 52, 8); 6699 } 6700 6701 function packF32(it) { 6702 return packIEEE754(it, 23, 4); 6703 } 6704 6705 function addGetter(C, key, internal) { 6706 dP(C[PROTOTYPE], key, { 6707 get: function get() { 6708 return this[internal]; 6709 } 6710 }); 6711 } 6712 6713 function get(view, bytes, index, isLittleEndian) { 6714 var numIndex = +index; 6715 var intIndex = _toIndex(numIndex); 6716 if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX); 6717 var store = view[$BUFFER]._b; 6718 var start = intIndex + view[$OFFSET]; 6719 var pack = store.slice(start, start + bytes); 6720 return isLittleEndian ? pack : pack.reverse(); 6721 } 6722 6723 function set(view, bytes, index, conversion, value, isLittleEndian) { 6724 var numIndex = +index; 6725 var intIndex = _toIndex(numIndex); 6726 if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX); 6727 var store = view[$BUFFER]._b; 6728 var start = intIndex + view[$OFFSET]; 6729 var pack = conversion(+value); 6730 6731 for (var i = 0; i < bytes; i++) { 6732 store[start + i] = pack[isLittleEndian ? i : bytes - i - 1]; 6733 } 6734 } 6735 6736 if (!_typed.ABV) { 6737 $ArrayBuffer = function ArrayBuffer(length) { 6738 _anInstance(this, $ArrayBuffer, ARRAY_BUFFER); 6739 var byteLength = _toIndex(length); 6740 this._b = _arrayFill.call(new Array(byteLength), 0); 6741 this[$LENGTH] = byteLength; 6742 }; 6743 6744 $DataView = function DataView(buffer, byteOffset, byteLength) { 6745 _anInstance(this, $DataView, DATA_VIEW); 6746 _anInstance(buffer, $ArrayBuffer, DATA_VIEW); 6747 var bufferLength = buffer[$LENGTH]; 6748 var offset = _toInteger(byteOffset); 6749 if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset!'); 6750 byteLength = byteLength === undefined ? bufferLength - offset : _toLength(byteLength); 6751 if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH); 6752 this[$BUFFER] = buffer; 6753 this[$OFFSET] = offset; 6754 this[$LENGTH] = byteLength; 6755 }; 6756 6757 if (_descriptors) { 6758 addGetter($ArrayBuffer, BYTE_LENGTH, '_l'); 6759 addGetter($DataView, BUFFER, '_b'); 6760 addGetter($DataView, BYTE_LENGTH, '_l'); 6761 addGetter($DataView, BYTE_OFFSET, '_o'); 6762 } 6763 6764 _redefineAll($DataView[PROTOTYPE], { 6765 getInt8: function getInt8(byteOffset) { 6766 return get(this, 1, byteOffset)[0] << 24 >> 24; 6767 }, 6768 getUint8: function getUint8(byteOffset) { 6769 return get(this, 1, byteOffset)[0]; 6770 }, 6771 getInt16: function getInt16(byteOffset 6772 /* , littleEndian */ 6773 ) { 6774 var bytes = get(this, 2, byteOffset, arguments[1]); 6775 return (bytes[1] << 8 | bytes[0]) << 16 >> 16; 6776 }, 6777 getUint16: function getUint16(byteOffset 6778 /* , littleEndian */ 6779 ) { 6780 var bytes = get(this, 2, byteOffset, arguments[1]); 6781 return bytes[1] << 8 | bytes[0]; 6782 }, 6783 getInt32: function getInt32(byteOffset 6784 /* , littleEndian */ 6785 ) { 6786 return unpackI32(get(this, 4, byteOffset, arguments[1])); 6787 }, 6788 getUint32: function getUint32(byteOffset 6789 /* , littleEndian */ 6790 ) { 6791 return unpackI32(get(this, 4, byteOffset, arguments[1])) >>> 0; 6792 }, 6793 getFloat32: function getFloat32(byteOffset 6794 /* , littleEndian */ 6795 ) { 6796 return unpackIEEE754(get(this, 4, byteOffset, arguments[1]), 23, 4); 6797 }, 6798 getFloat64: function getFloat64(byteOffset 6799 /* , littleEndian */ 6800 ) { 6801 return unpackIEEE754(get(this, 8, byteOffset, arguments[1]), 52, 8); 6802 }, 6803 setInt8: function setInt8(byteOffset, value) { 6804 set(this, 1, byteOffset, packI8, value); 6805 }, 6806 setUint8: function setUint8(byteOffset, value) { 6807 set(this, 1, byteOffset, packI8, value); 6808 }, 6809 setInt16: function setInt16(byteOffset, value 6810 /* , littleEndian */ 6811 ) { 6812 set(this, 2, byteOffset, packI16, value, arguments[2]); 6813 }, 6814 setUint16: function setUint16(byteOffset, value 6815 /* , littleEndian */ 6816 ) { 6817 set(this, 2, byteOffset, packI16, value, arguments[2]); 6818 }, 6819 setInt32: function setInt32(byteOffset, value 6820 /* , littleEndian */ 6821 ) { 6822 set(this, 4, byteOffset, packI32, value, arguments[2]); 6823 }, 6824 setUint32: function setUint32(byteOffset, value 6825 /* , littleEndian */ 6826 ) { 6827 set(this, 4, byteOffset, packI32, value, arguments[2]); 6828 }, 6829 setFloat32: function setFloat32(byteOffset, value 6830 /* , littleEndian */ 6831 ) { 6832 set(this, 4, byteOffset, packF32, value, arguments[2]); 6833 }, 6834 setFloat64: function setFloat64(byteOffset, value 6835 /* , littleEndian */ 6836 ) { 6837 set(this, 8, byteOffset, packF64, value, arguments[2]); 6838 } 6839 }); 6840 } else { 6841 if (!_fails(function () { 6842 $ArrayBuffer(1); 6843 }) || !_fails(function () { 6844 new $ArrayBuffer(-1); // eslint-disable-line no-new 6845 }) || _fails(function () { 6846 new $ArrayBuffer(); // eslint-disable-line no-new 6847 6848 new $ArrayBuffer(1.5); // eslint-disable-line no-new 6849 6850 new $ArrayBuffer(NaN); // eslint-disable-line no-new 6851 6852 return $ArrayBuffer.name != ARRAY_BUFFER; 6853 })) { 6854 $ArrayBuffer = function ArrayBuffer(length) { 6855 _anInstance(this, $ArrayBuffer); 6856 return new BaseBuffer(_toIndex(length)); 6857 }; 6858 6859 var ArrayBufferProto = $ArrayBuffer[PROTOTYPE] = BaseBuffer[PROTOTYPE]; 6860 6861 for (var keys = gOPN(BaseBuffer), j = 0, key; keys.length > j;) { 6862 if (!((key = keys[j++]) in $ArrayBuffer)) _hide($ArrayBuffer, key, BaseBuffer[key]); 6863 } 6864 6865 ArrayBufferProto.constructor = $ArrayBuffer; 6866 } // iOS Safari 7.x bug 6867 6868 6869 var view = new $DataView(new $ArrayBuffer(2)); 6870 var $setInt8 = $DataView[PROTOTYPE].setInt8; 6871 view.setInt8(0, 2147483648); 6872 view.setInt8(1, 2147483649); 6873 if (view.getInt8(0) || !view.getInt8(1)) _redefineAll($DataView[PROTOTYPE], { 6874 setInt8: function setInt8(byteOffset, value) { 6875 $setInt8.call(this, byteOffset, value << 24 >> 24); 6876 }, 6877 setUint8: function setUint8(byteOffset, value) { 6878 $setInt8.call(this, byteOffset, value << 24 >> 24); 6879 } 6880 }, true); 6881 } 6882 6883 _setToStringTag($ArrayBuffer, ARRAY_BUFFER); 6884 _setToStringTag($DataView, DATA_VIEW); 6885 _hide($DataView[PROTOTYPE], _typed.VIEW, true); 6886 exports[ARRAY_BUFFER] = $ArrayBuffer; 6887 exports[DATA_VIEW] = $DataView; 6888 }); 6889 6890 var ArrayBuffer = _global.ArrayBuffer; 6891 6892 6893 6894 var $ArrayBuffer = _typedBuffer.ArrayBuffer; 6895 var $DataView = _typedBuffer.DataView; 6896 var $isView = _typed.ABV && ArrayBuffer.isView; 6897 var $slice = $ArrayBuffer.prototype.slice; 6898 var VIEW$1 = _typed.VIEW; 6899 var ARRAY_BUFFER = 'ArrayBuffer'; 6900 _export(_export.G + _export.W + _export.F * (ArrayBuffer !== $ArrayBuffer), { 6901 ArrayBuffer: $ArrayBuffer 6902 }); 6903 _export(_export.S + _export.F * !_typed.CONSTR, ARRAY_BUFFER, { 6904 // 24.1.3.1 ArrayBuffer.isView(arg) 6905 isView: function isView(it) { 6906 return $isView && $isView(it) || _isObject(it) && VIEW$1 in it; 6907 } 6908 }); 6909 _export(_export.P + _export.U + _export.F * _fails(function () { 6910 return !new $ArrayBuffer(2).slice(1, undefined).byteLength; 6911 }), ARRAY_BUFFER, { 6912 // 24.1.4.3 ArrayBuffer.prototype.slice(start, end) 6913 slice: function slice(start, end) { 6914 if ($slice !== undefined && end === undefined) return $slice.call(_anObject(this), start); // FF fix 6915 6916 var len = _anObject(this).byteLength; 6917 var first = _toAbsoluteIndex(start, len); 6918 var fin = _toAbsoluteIndex(end === undefined ? len : end, len); 6919 var result = new (_speciesConstructor(this, $ArrayBuffer))(_toLength(fin - first)); 6920 var viewS = new $DataView(this); 6921 var viewT = new $DataView(result); 6922 var index = 0; 6923 6924 while (first < fin) { 6925 viewT.setUint8(index++, viewS.getUint8(first++)); 6926 } 6927 6928 return result; 6929 } 6930 }); 6931 6932 _setSpecies(ARRAY_BUFFER); 6933 6934 _export(_export.G + _export.W + _export.F * !_typed.ABV, { 6935 DataView: _typedBuffer.DataView 6936 }); 6937 6938 var _typedArray = createCommonjsModule(function (module) { 6939 6940 if (_descriptors) { 6941 6942 var global = _global; 6943 6944 var fails = _fails; 6945 6946 var $export = _export; 6947 6948 var $typed = _typed; 6949 6950 var $buffer = _typedBuffer; 6951 6952 var ctx = _ctx; 6953 6954 var anInstance = _anInstance; 6955 6956 var propertyDesc = _propertyDesc; 6957 6958 var hide = _hide; 6959 6960 var redefineAll = _redefineAll; 6961 6962 var toInteger = _toInteger; 6963 6964 var toLength = _toLength; 6965 6966 var toIndex = _toIndex; 6967 6968 var toAbsoluteIndex = _toAbsoluteIndex; 6969 6970 var toPrimitive = _toPrimitive; 6971 6972 var has = _has; 6973 6974 var classof = _classof; 6975 6976 var isObject = _isObject; 6977 6978 var toObject = _toObject; 6979 6980 var isArrayIter = _isArrayIter; 6981 6982 var create = _objectCreate; 6983 6984 var getPrototypeOf = _objectGpo; 6985 6986 var gOPN = _objectGopn.f; 6987 6988 var getIterFn = core_getIteratorMethod; 6989 6990 var uid = _uid; 6991 6992 var wks = _wks; 6993 6994 var createArrayMethod = _arrayMethods; 6995 6996 var createArrayIncludes = _arrayIncludes; 6997 6998 var speciesConstructor = _speciesConstructor; 6999 7000 var ArrayIterators = es6_array_iterator; 7001 7002 var Iterators = _iterators; 7003 7004 var $iterDetect = _iterDetect; 7005 7006 var setSpecies = _setSpecies; 7007 7008 var arrayFill = _arrayFill; 7009 7010 var arrayCopyWithin = _arrayCopyWithin; 7011 7012 var $DP = _objectDp; 7013 7014 var $GOPD = _objectGopd; 7015 7016 var dP = $DP.f; 7017 var gOPD = $GOPD.f; 7018 var RangeError = global.RangeError; 7019 var TypeError = global.TypeError; 7020 var Uint8Array = global.Uint8Array; 7021 var ARRAY_BUFFER = 'ArrayBuffer'; 7022 var SHARED_BUFFER = 'Shared' + ARRAY_BUFFER; 7023 var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT'; 7024 var PROTOTYPE = 'prototype'; 7025 var ArrayProto = Array[PROTOTYPE]; 7026 var $ArrayBuffer = $buffer.ArrayBuffer; 7027 var $DataView = $buffer.DataView; 7028 var arrayForEach = createArrayMethod(0); 7029 var arrayFilter = createArrayMethod(2); 7030 var arraySome = createArrayMethod(3); 7031 var arrayEvery = createArrayMethod(4); 7032 var arrayFind = createArrayMethod(5); 7033 var arrayFindIndex = createArrayMethod(6); 7034 var arrayIncludes = createArrayIncludes(true); 7035 var arrayIndexOf = createArrayIncludes(false); 7036 var arrayValues = ArrayIterators.values; 7037 var arrayKeys = ArrayIterators.keys; 7038 var arrayEntries = ArrayIterators.entries; 7039 var arrayLastIndexOf = ArrayProto.lastIndexOf; 7040 var arrayReduce = ArrayProto.reduce; 7041 var arrayReduceRight = ArrayProto.reduceRight; 7042 var arrayJoin = ArrayProto.join; 7043 var arraySort = ArrayProto.sort; 7044 var arraySlice = ArrayProto.slice; 7045 var arrayToString = ArrayProto.toString; 7046 var arrayToLocaleString = ArrayProto.toLocaleString; 7047 var ITERATOR = wks('iterator'); 7048 var TAG = wks('toStringTag'); 7049 var TYPED_CONSTRUCTOR = uid('typed_constructor'); 7050 var DEF_CONSTRUCTOR = uid('def_constructor'); 7051 var ALL_CONSTRUCTORS = $typed.CONSTR; 7052 var TYPED_ARRAY = $typed.TYPED; 7053 var VIEW = $typed.VIEW; 7054 var WRONG_LENGTH = 'Wrong length!'; 7055 var $map = createArrayMethod(1, function (O, length) { 7056 return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length); 7057 }); 7058 var LITTLE_ENDIAN = fails(function () { 7059 // eslint-disable-next-line no-undef 7060 return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1; 7061 }); 7062 var FORCED_SET = !!Uint8Array && !!Uint8Array[PROTOTYPE].set && fails(function () { 7063 new Uint8Array(1).set({}); 7064 }); 7065 7066 var toOffset = function toOffset(it, BYTES) { 7067 var offset = toInteger(it); 7068 if (offset < 0 || offset % BYTES) throw RangeError('Wrong offset!'); 7069 return offset; 7070 }; 7071 7072 var validate = function validate(it) { 7073 if (isObject(it) && TYPED_ARRAY in it) return it; 7074 throw TypeError(it + ' is not a typed array!'); 7075 }; 7076 7077 var allocate = function allocate(C, length) { 7078 if (!(isObject(C) && TYPED_CONSTRUCTOR in C)) { 7079 throw TypeError('It is not a typed array constructor!'); 7080 } 7081 7082 return new C(length); 7083 }; 7084 7085 var speciesFromList = function speciesFromList(O, list) { 7086 return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list); 7087 }; 7088 7089 var fromList = function fromList(C, list) { 7090 var index = 0; 7091 var length = list.length; 7092 var result = allocate(C, length); 7093 7094 while (length > index) { 7095 result[index] = list[index++]; 7096 } 7097 7098 return result; 7099 }; 7100 7101 var addGetter = function addGetter(it, key, internal) { 7102 dP(it, key, { 7103 get: function get() { 7104 return this._d[internal]; 7105 } 7106 }); 7107 }; 7108 7109 var $from = function from(source 7110 /* , mapfn, thisArg */ 7111 ) { 7112 var O = toObject(source); 7113 var aLen = arguments.length; 7114 var mapfn = aLen > 1 ? arguments[1] : undefined; 7115 var mapping = mapfn !== undefined; 7116 var iterFn = getIterFn(O); 7117 var i, length, values, result, step, iterator; 7118 7119 if (iterFn != undefined && !isArrayIter(iterFn)) { 7120 for (iterator = iterFn.call(O), values = [], i = 0; !(step = iterator.next()).done; i++) { 7121 values.push(step.value); 7122 } 7123 7124 O = values; 7125 } 7126 7127 if (mapping && aLen > 2) mapfn = ctx(mapfn, arguments[2], 2); 7128 7129 for (i = 0, length = toLength(O.length), result = allocate(this, length); length > i; i++) { 7130 result[i] = mapping ? mapfn(O[i], i) : O[i]; 7131 } 7132 7133 return result; 7134 }; 7135 7136 var $of = function of() 7137 /* ...items */ 7138 { 7139 var index = 0; 7140 var length = arguments.length; 7141 var result = allocate(this, length); 7142 7143 while (length > index) { 7144 result[index] = arguments[index++]; 7145 } 7146 7147 return result; 7148 }; // iOS Safari 6.x fails here 7149 7150 7151 var TO_LOCALE_BUG = !!Uint8Array && fails(function () { 7152 arrayToLocaleString.call(new Uint8Array(1)); 7153 }); 7154 7155 var $toLocaleString = function toLocaleString() { 7156 return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this), arguments); 7157 }; 7158 7159 var proto = { 7160 copyWithin: function copyWithin(target, start 7161 /* , end */ 7162 ) { 7163 return arrayCopyWithin.call(validate(this), target, start, arguments.length > 2 ? arguments[2] : undefined); 7164 }, 7165 every: function every(callbackfn 7166 /* , thisArg */ 7167 ) { 7168 return arrayEvery(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); 7169 }, 7170 fill: function fill(value 7171 /* , start, end */ 7172 ) { 7173 // eslint-disable-line no-unused-vars 7174 return arrayFill.apply(validate(this), arguments); 7175 }, 7176 filter: function filter(callbackfn 7177 /* , thisArg */ 7178 ) { 7179 return speciesFromList(this, arrayFilter(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined)); 7180 }, 7181 find: function find(predicate 7182 /* , thisArg */ 7183 ) { 7184 return arrayFind(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined); 7185 }, 7186 findIndex: function findIndex(predicate 7187 /* , thisArg */ 7188 ) { 7189 return arrayFindIndex(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined); 7190 }, 7191 forEach: function forEach(callbackfn 7192 /* , thisArg */ 7193 ) { 7194 arrayForEach(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); 7195 }, 7196 indexOf: function indexOf(searchElement 7197 /* , fromIndex */ 7198 ) { 7199 return arrayIndexOf(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); 7200 }, 7201 includes: function includes(searchElement 7202 /* , fromIndex */ 7203 ) { 7204 return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); 7205 }, 7206 join: function join(separator) { 7207 // eslint-disable-line no-unused-vars 7208 return arrayJoin.apply(validate(this), arguments); 7209 }, 7210 lastIndexOf: function lastIndexOf(searchElement 7211 /* , fromIndex */ 7212 ) { 7213 // eslint-disable-line no-unused-vars 7214 return arrayLastIndexOf.apply(validate(this), arguments); 7215 }, 7216 map: function map(mapfn 7217 /* , thisArg */ 7218 ) { 7219 return $map(validate(this), mapfn, arguments.length > 1 ? arguments[1] : undefined); 7220 }, 7221 reduce: function reduce(callbackfn 7222 /* , initialValue */ 7223 ) { 7224 // eslint-disable-line no-unused-vars 7225 return arrayReduce.apply(validate(this), arguments); 7226 }, 7227 reduceRight: function reduceRight(callbackfn 7228 /* , initialValue */ 7229 ) { 7230 // eslint-disable-line no-unused-vars 7231 return arrayReduceRight.apply(validate(this), arguments); 7232 }, 7233 reverse: function reverse() { 7234 var that = this; 7235 var length = validate(that).length; 7236 var middle = Math.floor(length / 2); 7237 var index = 0; 7238 var value; 7239 7240 while (index < middle) { 7241 value = that[index]; 7242 that[index++] = that[--length]; 7243 that[length] = value; 7244 } 7245 7246 return that; 7247 }, 7248 some: function some(callbackfn 7249 /* , thisArg */ 7250 ) { 7251 return arraySome(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); 7252 }, 7253 sort: function sort(comparefn) { 7254 return arraySort.call(validate(this), comparefn); 7255 }, 7256 subarray: function subarray(begin, end) { 7257 var O = validate(this); 7258 var length = O.length; 7259 var $begin = toAbsoluteIndex(begin, length); 7260 return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(O.buffer, O.byteOffset + $begin * O.BYTES_PER_ELEMENT, toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - $begin)); 7261 } 7262 }; 7263 7264 var $slice = function slice(start, end) { 7265 return speciesFromList(this, arraySlice.call(validate(this), start, end)); 7266 }; 7267 7268 var $set = function set(arrayLike 7269 /* , offset */ 7270 ) { 7271 validate(this); 7272 var offset = toOffset(arguments[1], 1); 7273 var length = this.length; 7274 var src = toObject(arrayLike); 7275 var len = toLength(src.length); 7276 var index = 0; 7277 if (len + offset > length) throw RangeError(WRONG_LENGTH); 7278 7279 while (index < len) { 7280 this[offset + index] = src[index++]; 7281 } 7282 }; 7283 7284 var $iterators = { 7285 entries: function entries() { 7286 return arrayEntries.call(validate(this)); 7287 }, 7288 keys: function keys() { 7289 return arrayKeys.call(validate(this)); 7290 }, 7291 values: function values() { 7292 return arrayValues.call(validate(this)); 7293 } 7294 }; 7295 7296 var isTAIndex = function isTAIndex(target, key) { 7297 return isObject(target) && target[TYPED_ARRAY] && babelHelpers.typeof(key) != 'symbol' && key in target && String(+key) == String(key); 7298 }; 7299 7300 var $getDesc = function getOwnPropertyDescriptor(target, key) { 7301 return isTAIndex(target, key = toPrimitive(key, true)) ? propertyDesc(2, target[key]) : gOPD(target, key); 7302 }; 7303 7304 var $setDesc = function defineProperty(target, key, desc) { 7305 if (isTAIndex(target, key = toPrimitive(key, true)) && isObject(desc) && has(desc, 'value') && !has(desc, 'get') && !has(desc, 'set') // TODO: add validation descriptor w/o calling accessors 7306 && !desc.configurable && (!has(desc, 'writable') || desc.writable) && (!has(desc, 'enumerable') || desc.enumerable)) { 7307 target[key] = desc.value; 7308 return target; 7309 } 7310 7311 return dP(target, key, desc); 7312 }; 7313 7314 if (!ALL_CONSTRUCTORS) { 7315 $GOPD.f = $getDesc; 7316 $DP.f = $setDesc; 7317 } 7318 7319 $export($export.S + $export.F * !ALL_CONSTRUCTORS, 'Object', { 7320 getOwnPropertyDescriptor: $getDesc, 7321 defineProperty: $setDesc 7322 }); 7323 7324 if (fails(function () { 7325 arrayToString.call({}); 7326 })) { 7327 arrayToString = arrayToLocaleString = function toString() { 7328 return arrayJoin.call(this); 7329 }; 7330 } 7331 7332 var $TypedArrayPrototype$ = redefineAll({}, proto); 7333 redefineAll($TypedArrayPrototype$, $iterators); 7334 hide($TypedArrayPrototype$, ITERATOR, $iterators.values); 7335 redefineAll($TypedArrayPrototype$, { 7336 slice: $slice, 7337 set: $set, 7338 constructor: function constructor() { 7339 /* noop */ 7340 }, 7341 toString: arrayToString, 7342 toLocaleString: $toLocaleString 7343 }); 7344 addGetter($TypedArrayPrototype$, 'buffer', 'b'); 7345 addGetter($TypedArrayPrototype$, 'byteOffset', 'o'); 7346 addGetter($TypedArrayPrototype$, 'byteLength', 'l'); 7347 addGetter($TypedArrayPrototype$, 'length', 'e'); 7348 dP($TypedArrayPrototype$, TAG, { 7349 get: function get() { 7350 return this[TYPED_ARRAY]; 7351 } 7352 }); // eslint-disable-next-line max-statements 7353 7354 module.exports = function (KEY, BYTES, wrapper, CLAMPED) { 7355 CLAMPED = !!CLAMPED; 7356 var NAME = KEY + (CLAMPED ? 'Clamped' : '') + 'Array'; 7357 var GETTER = 'get' + KEY; 7358 var SETTER = 'set' + KEY; 7359 var TypedArray = global[NAME]; 7360 var Base = TypedArray || {}; 7361 var TAC = TypedArray && getPrototypeOf(TypedArray); 7362 var FORCED = !TypedArray || !$typed.ABV; 7363 var O = {}; 7364 var TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE]; 7365 7366 var getter = function getter(that, index) { 7367 var data = that._d; 7368 return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN); 7369 }; 7370 7371 var setter = function setter(that, index, value) { 7372 var data = that._d; 7373 if (CLAMPED) value = (value = Math.round(value)) < 0 ? 0 : value > 0xff ? 0xff : value & 0xff; 7374 data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN); 7375 }; 7376 7377 var addElement = function addElement(that, index) { 7378 dP(that, index, { 7379 get: function get() { 7380 return getter(this, index); 7381 }, 7382 set: function set(value) { 7383 return setter(this, index, value); 7384 }, 7385 enumerable: true 7386 }); 7387 }; 7388 7389 if (FORCED) { 7390 TypedArray = wrapper(function (that, data, $offset, $length) { 7391 anInstance(that, TypedArray, NAME, '_d'); 7392 var index = 0; 7393 var offset = 0; 7394 var buffer, byteLength, length, klass; 7395 7396 if (!isObject(data)) { 7397 length = toIndex(data); 7398 byteLength = length * BYTES; 7399 buffer = new $ArrayBuffer(byteLength); 7400 } else if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) { 7401 buffer = data; 7402 offset = toOffset($offset, BYTES); 7403 var $len = data.byteLength; 7404 7405 if ($length === undefined) { 7406 if ($len % BYTES) throw RangeError(WRONG_LENGTH); 7407 byteLength = $len - offset; 7408 if (byteLength < 0) throw RangeError(WRONG_LENGTH); 7409 } else { 7410 byteLength = toLength($length) * BYTES; 7411 if (byteLength + offset > $len) throw RangeError(WRONG_LENGTH); 7412 } 7413 7414 length = byteLength / BYTES; 7415 } else if (TYPED_ARRAY in data) { 7416 return fromList(TypedArray, data); 7417 } else { 7418 return $from.call(TypedArray, data); 7419 } 7420 7421 hide(that, '_d', { 7422 b: buffer, 7423 o: offset, 7424 l: byteLength, 7425 e: length, 7426 v: new $DataView(buffer) 7427 }); 7428 7429 while (index < length) { 7430 addElement(that, index++); 7431 } 7432 }); 7433 TypedArrayPrototype = TypedArray[PROTOTYPE] = create($TypedArrayPrototype$); 7434 hide(TypedArrayPrototype, 'constructor', TypedArray); 7435 } else if (!fails(function () { 7436 TypedArray(1); 7437 }) || !fails(function () { 7438 new TypedArray(-1); // eslint-disable-line no-new 7439 }) || !$iterDetect(function (iter) { 7440 new TypedArray(); // eslint-disable-line no-new 7441 7442 new TypedArray(null); // eslint-disable-line no-new 7443 7444 new TypedArray(1.5); // eslint-disable-line no-new 7445 7446 new TypedArray(iter); // eslint-disable-line no-new 7447 }, true)) { 7448 TypedArray = wrapper(function (that, data, $offset, $length) { 7449 anInstance(that, TypedArray, NAME); 7450 var klass; // `ws` module bug, temporarily remove validation length for Uint8Array 7451 // https://github.com/websockets/ws/pull/645 7452 7453 if (!isObject(data)) return new Base(toIndex(data)); 7454 7455 if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) { 7456 return $length !== undefined ? new Base(data, toOffset($offset, BYTES), $length) : $offset !== undefined ? new Base(data, toOffset($offset, BYTES)) : new Base(data); 7457 } 7458 7459 if (TYPED_ARRAY in data) return fromList(TypedArray, data); 7460 return $from.call(TypedArray, data); 7461 }); 7462 arrayForEach(TAC !== Function.prototype ? gOPN(Base).concat(gOPN(TAC)) : gOPN(Base), function (key) { 7463 if (!(key in TypedArray)) hide(TypedArray, key, Base[key]); 7464 }); 7465 TypedArray[PROTOTYPE] = TypedArrayPrototype; 7466 TypedArrayPrototype.constructor = TypedArray; 7467 } 7468 7469 var $nativeIterator = TypedArrayPrototype[ITERATOR]; 7470 var CORRECT_ITER_NAME = !!$nativeIterator && ($nativeIterator.name == 'values' || $nativeIterator.name == undefined); 7471 var $iterator = $iterators.values; 7472 hide(TypedArray, TYPED_CONSTRUCTOR, true); 7473 hide(TypedArrayPrototype, TYPED_ARRAY, NAME); 7474 hide(TypedArrayPrototype, VIEW, true); 7475 hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray); 7476 7477 if (CLAMPED ? new TypedArray(1)[TAG] != NAME : !(TAG in TypedArrayPrototype)) { 7478 dP(TypedArrayPrototype, TAG, { 7479 get: function get() { 7480 return NAME; 7481 } 7482 }); 7483 } 7484 7485 O[NAME] = TypedArray; 7486 $export($export.G + $export.W + $export.F * (TypedArray != Base), O); 7487 $export($export.S, NAME, { 7488 BYTES_PER_ELEMENT: BYTES 7489 }); 7490 $export($export.S + $export.F * fails(function () { 7491 Base.of.call(TypedArray, 1); 7492 }), NAME, { 7493 from: $from, 7494 of: $of 7495 }); 7496 if (!(BYTES_PER_ELEMENT in TypedArrayPrototype)) hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES); 7497 $export($export.P, NAME, proto); 7498 setSpecies(NAME); 7499 $export($export.P + $export.F * FORCED_SET, NAME, { 7500 set: $set 7501 }); 7502 $export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators); 7503 if (TypedArrayPrototype.toString != arrayToString) TypedArrayPrototype.toString = arrayToString; 7504 $export($export.P + $export.F * fails(function () { 7505 new TypedArray(1).slice(); 7506 }), NAME, { 7507 slice: $slice 7508 }); 7509 $export($export.P + $export.F * (fails(function () { 7510 return [1, 2].toLocaleString() != new TypedArray([1, 2]).toLocaleString(); 7511 }) || !fails(function () { 7512 TypedArrayPrototype.toLocaleString.call([1, 2]); 7513 })), NAME, { 7514 toLocaleString: $toLocaleString 7515 }); 7516 Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator; 7517 if (!CORRECT_ITER_NAME) hide(TypedArrayPrototype, ITERATOR, $iterator); 7518 }; 7519 } else module.exports = function () { 7520 /* empty */ 7521 }; 7522 }); 7523 7524 _typedArray('Int8', 1, function (init) { 7525 return function Int8Array(data, byteOffset, length) { 7526 return init(this, data, byteOffset, length); 7527 }; 7528 }); 7529 7530 _typedArray('Uint8', 1, function (init) { 7531 return function Uint8Array(data, byteOffset, length) { 7532 return init(this, data, byteOffset, length); 7533 }; 7534 }); 7535 7536 _typedArray('Uint8', 1, function (init) { 7537 return function Uint8ClampedArray(data, byteOffset, length) { 7538 return init(this, data, byteOffset, length); 7539 }; 7540 }, true); 7541 7542 _typedArray('Int16', 2, function (init) { 7543 return function Int16Array(data, byteOffset, length) { 7544 return init(this, data, byteOffset, length); 7545 }; 7546 }); 7547 7548 _typedArray('Uint16', 2, function (init) { 7549 return function Uint16Array(data, byteOffset, length) { 7550 return init(this, data, byteOffset, length); 7551 }; 7552 }); 7553 7554 _typedArray('Int32', 4, function (init) { 7555 return function Int32Array(data, byteOffset, length) { 7556 return init(this, data, byteOffset, length); 7557 }; 7558 }); 7559 7560 _typedArray('Uint32', 4, function (init) { 7561 return function Uint32Array(data, byteOffset, length) { 7562 return init(this, data, byteOffset, length); 7563 }; 7564 }); 7565 7566 _typedArray('Float32', 4, function (init) { 7567 return function Float32Array(data, byteOffset, length) { 7568 return init(this, data, byteOffset, length); 7569 }; 7570 }); 7571 7572 _typedArray('Float64', 8, function (init) { 7573 return function Float64Array(data, byteOffset, length) { 7574 return init(this, data, byteOffset, length); 7575 }; 7576 }); 7577 7578 // 26.1.1 Reflect.apply(target, thisArgument, argumentsList) 7579 7580 7581 7582 7583 7584 7585 var rApply = (_global.Reflect || {}).apply; 7586 var fApply = Function.apply; // MS Edge argumentsList argument is optional 7587 7588 _export(_export.S + _export.F * !_fails(function () { 7589 rApply(function () { 7590 /* empty */ 7591 }); 7592 }), 'Reflect', { 7593 apply: function apply(target, thisArgument, argumentsList) { 7594 var T = _aFunction(target); 7595 var L = _anObject(argumentsList); 7596 return rApply ? rApply(T, thisArgument, L) : fApply.call(T, thisArgument, L); 7597 } 7598 }); 7599 7600 // 26.1.2 Reflect.construct(target, argumentsList [, newTarget]) 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 var rConstruct = (_global.Reflect || {}).construct; // MS Edge supports only 2 arguments and argumentsList argument is optional 7616 // FF Nightly sets third argument as `new.target`, but does not create `this` from it 7617 7618 var NEW_TARGET_BUG = _fails(function () { 7619 function F() { 7620 /* empty */ 7621 } 7622 7623 return !(rConstruct(function () { 7624 /* empty */ 7625 }, [], F) instanceof F); 7626 }); 7627 var ARGS_BUG = !_fails(function () { 7628 rConstruct(function () { 7629 /* empty */ 7630 }); 7631 }); 7632 _export(_export.S + _export.F * (NEW_TARGET_BUG || ARGS_BUG), 'Reflect', { 7633 construct: function construct(Target, args 7634 /* , newTarget */ 7635 ) { 7636 _aFunction(Target); 7637 _anObject(args); 7638 var newTarget = arguments.length < 3 ? Target : _aFunction(arguments[2]); 7639 if (ARGS_BUG && !NEW_TARGET_BUG) return rConstruct(Target, args, newTarget); 7640 7641 if (Target == newTarget) { 7642 // w/o altered newTarget, optimization for 0-4 arguments 7643 switch (args.length) { 7644 case 0: 7645 return new Target(); 7646 7647 case 1: 7648 return new Target(args[0]); 7649 7650 case 2: 7651 return new Target(args[0], args[1]); 7652 7653 case 3: 7654 return new Target(args[0], args[1], args[2]); 7655 7656 case 4: 7657 return new Target(args[0], args[1], args[2], args[3]); 7658 } // w/o altered newTarget, lot of arguments case 7659 7660 7661 var $args = [null]; 7662 $args.push.apply($args, args); 7663 return new (_bind.apply(Target, $args))(); 7664 } // with altered newTarget, not support built-in constructors 7665 7666 7667 var proto = newTarget.prototype; 7668 var instance = _objectCreate(_isObject(proto) ? proto : Object.prototype); 7669 var result = Function.apply.call(Target, instance, args); 7670 return _isObject(result) ? result : instance; 7671 } 7672 }); 7673 7674 // 26.1.3 Reflect.defineProperty(target, propertyKey, attributes) 7675 7676 7677 7678 7679 7680 7681 // MS Edge has broken Reflect.defineProperty - throwing instead of returning false 7682 7683 7684 _export(_export.S + _export.F * _fails(function () { 7685 // eslint-disable-next-line no-undef 7686 Reflect.defineProperty(_objectDp.f({}, 1, { 7687 value: 1 7688 }), 1, { 7689 value: 2 7690 }); 7691 }), 'Reflect', { 7692 defineProperty: function defineProperty(target, propertyKey, attributes) { 7693 _anObject(target); 7694 propertyKey = _toPrimitive(propertyKey, true); 7695 _anObject(attributes); 7696 7697 try { 7698 _objectDp.f(target, propertyKey, attributes); 7699 return true; 7700 } catch (e) { 7701 return false; 7702 } 7703 } 7704 }); 7705 7706 // 26.1.4 Reflect.deleteProperty(target, propertyKey) 7707 7708 7709 var gOPD$3 = _objectGopd.f; 7710 7711 7712 7713 _export(_export.S, 'Reflect', { 7714 deleteProperty: function deleteProperty(target, propertyKey) { 7715 var desc = gOPD$3(_anObject(target), propertyKey); 7716 return desc && !desc.configurable ? false : delete target[propertyKey]; 7717 } 7718 }); 7719 7720 var Enumerate = function Enumerate(iterated) { 7721 this._t = _anObject(iterated); // target 7722 7723 this._i = 0; // next index 7724 7725 var keys = this._k = []; // keys 7726 7727 var key; 7728 7729 for (key in iterated) { 7730 keys.push(key); 7731 } 7732 }; 7733 7734 _iterCreate(Enumerate, 'Object', function () { 7735 var that = this; 7736 var keys = that._k; 7737 var key; 7738 7739 do { 7740 if (that._i >= keys.length) return { 7741 value: undefined, 7742 done: true 7743 }; 7744 } while (!((key = keys[that._i++]) in that._t)); 7745 7746 return { 7747 value: key, 7748 done: false 7749 }; 7750 }); 7751 7752 _export(_export.S, 'Reflect', { 7753 enumerate: function enumerate(target) { 7754 return new Enumerate(target); 7755 } 7756 }); 7757 7758 // 26.1.6 Reflect.get(target, propertyKey [, receiver]) 7759 7760 7761 7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 function get(target, propertyKey 7772 /* , receiver */ 7773 ) { 7774 var receiver = arguments.length < 3 ? target : arguments[2]; 7775 var desc, proto; 7776 if (_anObject(target) === receiver) return target[propertyKey]; 7777 if (desc = _objectGopd.f(target, propertyKey)) return _has(desc, 'value') ? desc.value : desc.get !== undefined ? desc.get.call(receiver) : undefined; 7778 if (_isObject(proto = _objectGpo(target))) return get(proto, propertyKey, receiver); 7779 } 7780 7781 _export(_export.S, 'Reflect', { 7782 get: get 7783 }); 7784 7785 // 26.1.7 Reflect.getOwnPropertyDescriptor(target, propertyKey) 7786 7787 7788 7789 7790 7791 7792 _export(_export.S, 'Reflect', { 7793 getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) { 7794 return _objectGopd.f(_anObject(target), propertyKey); 7795 } 7796 }); 7797 7798 // 26.1.8 Reflect.getPrototypeOf(target) 7799 7800 7801 7802 7803 7804 7805 _export(_export.S, 'Reflect', { 7806 getPrototypeOf: function getPrototypeOf(target) { 7807 return _objectGpo(_anObject(target)); 7808 } 7809 }); 7810 7811 // 26.1.9 Reflect.has(target, propertyKey) 7812 7813 7814 _export(_export.S, 'Reflect', { 7815 has: function has(target, propertyKey) { 7816 return propertyKey in target; 7817 } 7818 }); 7819 7820 // 26.1.10 Reflect.isExtensible(target) 7821 7822 7823 7824 7825 var $isExtensible = Object.isExtensible; 7826 _export(_export.S, 'Reflect', { 7827 isExtensible: function isExtensible(target) { 7828 _anObject(target); 7829 return $isExtensible ? $isExtensible(target) : true; 7830 } 7831 }); 7832 7833 // all object keys, includes non-enumerable and symbols 7834 7835 7836 7837 7838 7839 7840 var Reflect$1 = _global.Reflect; 7841 7842 var _ownKeys = Reflect$1 && Reflect$1.ownKeys || function ownKeys(it) { 7843 var keys = _objectGopn.f(_anObject(it)); 7844 var getSymbols = _objectGops.f; 7845 return getSymbols ? keys.concat(getSymbols(it)) : keys; 7846 }; 7847 7848 // 26.1.11 Reflect.ownKeys(target) 7849 7850 7851 _export(_export.S, 'Reflect', { 7852 ownKeys: _ownKeys 7853 }); 7854 7855 // 26.1.12 Reflect.preventExtensions(target) 7856 7857 7858 7859 7860 var $preventExtensions = Object.preventExtensions; 7861 _export(_export.S, 'Reflect', { 7862 preventExtensions: function preventExtensions(target) { 7863 _anObject(target); 7864 7865 try { 7866 if ($preventExtensions) $preventExtensions(target); 7867 return true; 7868 } catch (e) { 7869 return false;
vendor: 17,344 bytes, lines 7870-8568
7870 } 7871 } 7872 }); 7873 7874 // 26.1.13 Reflect.set(target, propertyKey, V [, receiver]) 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889 7890 7891 function set(target, propertyKey, V 7892 /* , receiver */ 7893 ) { 7894 var receiver = arguments.length < 4 ? target : arguments[3]; 7895 var ownDesc = _objectGopd.f(_anObject(target), propertyKey); 7896 var existingDescriptor, proto; 7897 7898 if (!ownDesc) { 7899 if (_isObject(proto = _objectGpo(target))) { 7900 return set(proto, propertyKey, V, receiver); 7901 } 7902 7903 ownDesc = _propertyDesc(0); 7904 } 7905 7906 if (_has(ownDesc, 'value')) { 7907 if (ownDesc.writable === false || !_isObject(receiver)) return false; 7908 7909 if (existingDescriptor = _objectGopd.f(receiver, propertyKey)) { 7910 if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false; 7911 existingDescriptor.value = V; 7912 _objectDp.f(receiver, propertyKey, existingDescriptor); 7913 } else _objectDp.f(receiver, propertyKey, _propertyDesc(0, V)); 7914 7915 return true; 7916 } 7917 7918 return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true); 7919 } 7920 7921 _export(_export.S, 'Reflect', { 7922 set: set 7923 }); 7924 7925 // 26.1.14 Reflect.setPrototypeOf(target, proto) 7926 7927 7928 7929 7930 if (_setProto) _export(_export.S, 'Reflect', { 7931 setPrototypeOf: function setPrototypeOf(target, proto) { 7932 _setProto.check(target, proto); 7933 7934 try { 7935 _setProto.set(target, proto); 7936 return true; 7937 } catch (e) { 7938 return false; 7939 } 7940 } 7941 }); 7942 7943 var $includes = _arrayIncludes(true); 7944 7945 _export(_export.P, 'Array', { 7946 includes: function includes(el 7947 /* , fromIndex = 0 */ 7948 ) { 7949 return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); 7950 } 7951 }); 7952 7953 _addToUnscopables('includes'); 7954 7955 var IS_CONCAT_SPREADABLE = _wks('isConcatSpreadable'); 7956 7957 function flattenIntoArray(target, original, source, sourceLen, start, depth, mapper, thisArg) { 7958 var targetIndex = start; 7959 var sourceIndex = 0; 7960 var mapFn = mapper ? _ctx(mapper, thisArg, 3) : false; 7961 var element, spreadable; 7962 7963 while (sourceIndex < sourceLen) { 7964 if (sourceIndex in source) { 7965 element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex]; 7966 spreadable = false; 7967 7968 if (_isObject(element)) { 7969 spreadable = element[IS_CONCAT_SPREADABLE]; 7970 spreadable = spreadable !== undefined ? !!spreadable : _isArray(element); 7971 } 7972 7973 if (spreadable && depth > 0) { 7974 targetIndex = flattenIntoArray(target, original, element, _toLength(element.length), targetIndex, depth - 1) - 1; 7975 } else { 7976 if (targetIndex >= 0x1fffffffffffff) throw TypeError(); 7977 target[targetIndex] = element; 7978 } 7979 7980 targetIndex++; 7981 } 7982 7983 sourceIndex++; 7984 } 7985 7986 return targetIndex; 7987 } 7988 7989 var _flattenIntoArray = flattenIntoArray; 7990 7991 _export(_export.P, 'Array', { 7992 flatMap: function flatMap(callbackfn 7993 /* , thisArg */ 7994 ) { 7995 var O = _toObject(this); 7996 var sourceLen, A; 7997 _aFunction(callbackfn); 7998 sourceLen = _toLength(O.length); 7999 A = _arraySpeciesCreate(O, 0); 8000 _flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments[1]); 8001 return A; 8002 } 8003 }); 8004 8005 _addToUnscopables('flatMap'); 8006 8007 _export(_export.P, 'Array', { 8008 flatten: function flatten() 8009 /* depthArg = 1 */ 8010 { 8011 var depthArg = arguments[0]; 8012 var O = _toObject(this); 8013 var sourceLen = _toLength(O.length); 8014 var A = _arraySpeciesCreate(O, 0); 8015 _flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : _toInteger(depthArg)); 8016 return A; 8017 } 8018 }); 8019 8020 _addToUnscopables('flatten'); 8021 8022 var $at$2 = _stringAt(true); 8023 8024 _export(_export.P, 'String', { 8025 at: function at(pos) { 8026 return $at$2(this, pos); 8027 } 8028 }); 8029 8030 // https://github.com/tc39/proposal-string-pad-start-end 8031 8032 8033 8034 8035 8036 8037 var _stringPad = function (that, maxLength, fillString, left) { 8038 var S = String(_defined(that)); 8039 var stringLength = S.length; 8040 var fillStr = fillString === undefined ? ' ' : String(fillString); 8041 var intMaxLength = _toLength(maxLength); 8042 if (intMaxLength <= stringLength || fillStr == '') return S; 8043 var fillLen = intMaxLength - stringLength; 8044 var stringFiller = _stringRepeat.call(fillStr, Math.ceil(fillLen / fillStr.length)); 8045 if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen); 8046 return left ? stringFiller + S : S + stringFiller; 8047 }; 8048 8049 // https://github.com/zloirock/core-js/issues/280 8050 8051 8052 _export(_export.P + _export.F * /Version\/10\.\d+(\.\d+)? Safari\//.test(_userAgent), 'String', { 8053 padStart: function padStart(maxLength 8054 /* , fillString = ' ' */ 8055 ) { 8056 return _stringPad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true); 8057 } 8058 }); 8059 8060 // https://github.com/zloirock/core-js/issues/280 8061 8062 8063 _export(_export.P + _export.F * /Version\/10\.\d+(\.\d+)? Safari\//.test(_userAgent), 'String', { 8064 padEnd: function padEnd(maxLength 8065 /* , fillString = ' ' */ 8066 ) { 8067 return _stringPad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false); 8068 } 8069 }); 8070 8071 _stringTrim('trimLeft', function ($trim) { 8072 return function trimLeft() { 8073 return $trim(this, 1); 8074 }; 8075 }, 'trimStart'); 8076 8077 _stringTrim('trimRight', function ($trim) { 8078 return function trimRight() { 8079 return $trim(this, 2); 8080 }; 8081 }, 'trimEnd'); 8082 8083 var RegExpProto = RegExp.prototype; 8084 8085 var $RegExpStringIterator = function $RegExpStringIterator(regexp, string) { 8086 this._r = regexp; 8087 this._s = string; 8088 }; 8089 8090 _iterCreate($RegExpStringIterator, 'RegExp String', function next() { 8091 var match = this._r.exec(this._s); 8092 8093 return { 8094 value: match, 8095 done: match === null 8096 }; 8097 }); 8098 8099 _export(_export.P, 'String', { 8100 matchAll: function matchAll(regexp) { 8101 _defined(this); 8102 if (!_isRegexp(regexp)) throw TypeError(regexp + ' is not a regexp!'); 8103 var S = String(this); 8104 var flags = 'flags' in RegExpProto ? String(regexp.flags) : _flags.call(regexp); 8105 var rx = new RegExp(regexp.source, ~flags.indexOf('g') ? flags : 'g' + flags); 8106 rx.lastIndex = _toLength(regexp.lastIndex); 8107 return new $RegExpStringIterator(rx, S); 8108 } 8109 }); 8110 8111 _wksDefine('asyncIterator'); 8112 8113 _wksDefine('observable'); 8114 8115 // https://github.com/tc39/proposal-object-getownpropertydescriptors 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126 _export(_export.S, 'Object', { 8127 getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) { 8128 var O = _toIobject(object); 8129 var getDesc = _objectGopd.f; 8130 var keys = _ownKeys(O); 8131 var result = {}; 8132 var i = 0; 8133 var key, desc; 8134 8135 while (keys.length > i) { 8136 desc = getDesc(O, key = keys[i++]); 8137 if (desc !== undefined) _createProperty(result, key, desc); 8138 } 8139 8140 return result; 8141 } 8142 }); 8143 8144 var isEnum$1 = _objectPie.f; 8145 8146 var _objectToArray = function (isEntries) { 8147 return function (it) { 8148 var O = _toIobject(it); 8149 var keys = _objectKeys(O); 8150 var length = keys.length; 8151 var i = 0; 8152 var result = []; 8153 var key; 8154 8155 while (length > i) { 8156 if (isEnum$1.call(O, key = keys[i++])) { 8157 result.push(isEntries ? [key, O[key]] : O[key]); 8158 } 8159 } 8160 8161 return result; 8162 }; 8163 }; 8164 8165 // https://github.com/tc39/proposal-object-values-entries 8166 8167 8168 var $values = _objectToArray(false); 8169 8170 _export(_export.S, 'Object', { 8171 values: function values(it) { 8172 return $values(it); 8173 } 8174 }); 8175 8176 // https://github.com/tc39/proposal-object-values-entries 8177 8178 8179 var $entries = _objectToArray(true); 8180 8181 _export(_export.S, 'Object', { 8182 entries: function entries(it) { 8183 return $entries(it); 8184 } 8185 }); 8186 8187 var _objectForcedPam = !_fails(function () { 8188 var K = Math.random(); // In FF throws only define methods 8189 // eslint-disable-next-line no-undef, no-useless-call 8190 8191 __defineSetter__.call(null, K, function () { 8192 /* empty */ 8193 }); 8194 8195 delete _global[K]; 8196 }); 8197 8198 // B.2.2.2 Object.prototype.__defineGetter__(P, getter) 8199 8200 8201 _descriptors && _export(_export.P + _objectForcedPam, 'Object', { 8202 __defineGetter__: function __defineGetter__(P, getter) { 8203 _objectDp.f(_toObject(this), P, { 8204 get: _aFunction(getter), 8205 enumerable: true, 8206 configurable: true 8207 }); 8208 } 8209 }); 8210 8211 // B.2.2.3 Object.prototype.__defineSetter__(P, setter) 8212 8213 8214 _descriptors && _export(_export.P + _objectForcedPam, 'Object', { 8215 __defineSetter__: function __defineSetter__(P, setter) { 8216 _objectDp.f(_toObject(this), P, { 8217 set: _aFunction(setter), 8218 enumerable: true, 8219 configurable: true 8220 }); 8221 } 8222 }); 8223 8224 var getOwnPropertyDescriptor = _objectGopd.f; // B.2.2.4 Object.prototype.__lookupGetter__(P) 8225 8226 8227 _descriptors && _export(_export.P + _objectForcedPam, 'Object', { 8228 __lookupGetter__: function __lookupGetter__(P) { 8229 var O = _toObject(this); 8230 var K = _toPrimitive(P, true); 8231 var D; 8232 8233 do { 8234 if (D = getOwnPropertyDescriptor(O, K)) return D.get; 8235 } while (O = _objectGpo(O)); 8236 } 8237 }); 8238 8239 var getOwnPropertyDescriptor$1 = _objectGopd.f; // B.2.2.5 Object.prototype.__lookupSetter__(P) 8240 8241 8242 _descriptors && _export(_export.P + _objectForcedPam, 'Object', { 8243 __lookupSetter__: function __lookupSetter__(P) { 8244 var O = _toObject(this); 8245 var K = _toPrimitive(P, true); 8246 var D; 8247 8248 do { 8249 if (D = getOwnPropertyDescriptor$1(O, K)) return D.set; 8250 } while (O = _objectGpo(O)); 8251 } 8252 }); 8253 8254 var _arrayFromIterable = function (iter, ITERATOR) { 8255 var result = []; 8256 _forOf(iter, false, result.push, result, ITERATOR); 8257 return result; 8258 }; 8259 8260 // https://github.com/DavidBruant/Map-Set.prototype.toJSON 8261 8262 8263 8264 8265 var _collectionToJson = function (NAME) { 8266 return function toJSON() { 8267 if (_classof(this) != NAME) throw TypeError(NAME + "#toJSON isn't generic"); 8268 return _arrayFromIterable(this); 8269 }; 8270 }; 8271 8272 // https://github.com/DavidBruant/Map-Set.prototype.toJSON 8273 8274 8275 _export(_export.P + _export.R, 'Map', { 8276 toJSON: _collectionToJson('Map') 8277 }); 8278 8279 // https://github.com/DavidBruant/Map-Set.prototype.toJSON 8280 8281 8282 _export(_export.P + _export.R, 'Set', { 8283 toJSON: _collectionToJson('Set') 8284 }); 8285 8286 var _setCollectionOf = function (COLLECTION) { 8287 _export(_export.S, COLLECTION, { 8288 of: function of() { 8289 var length = arguments.length; 8290 var A = new Array(length); 8291 8292 while (length--) { 8293 A[length] = arguments[length]; 8294 } 8295 8296 return new this(A); 8297 } 8298 }); 8299 }; 8300 8301 // https://tc39.github.io/proposal-setmap-offrom/#sec-map.of 8302 _setCollectionOf('Map'); 8303 8304 // https://tc39.github.io/proposal-setmap-offrom/#sec-set.of 8305 _setCollectionOf('Set'); 8306 8307 // https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of 8308 _setCollectionOf('WeakMap'); 8309 8310 // https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.of 8311 _setCollectionOf('WeakSet'); 8312 8313 var _setCollectionFrom = function (COLLECTION) { 8314 _export(_export.S, COLLECTION, { 8315 from: function from(source 8316 /* , mapFn, thisArg */ 8317 ) { 8318 var mapFn = arguments[1]; 8319 var mapping, A, n, cb; 8320 _aFunction(this); 8321 mapping = mapFn !== undefined; 8322 if (mapping) _aFunction(mapFn); 8323 if (source == undefined) return new this(); 8324 A = []; 8325 8326 if (mapping) { 8327 n = 0; 8328 cb = _ctx(mapFn, arguments[2], 2); 8329 _forOf(source, false, function (nextItem) { 8330 A.push(cb(nextItem, n++)); 8331 }); 8332 } else { 8333 _forOf(source, false, A.push, A); 8334 } 8335 8336 return new this(A); 8337 } 8338 }); 8339 }; 8340 8341 // https://tc39.github.io/proposal-setmap-offrom/#sec-map.from 8342 _setCollectionFrom('Map'); 8343 8344 // https://tc39.github.io/proposal-setmap-offrom/#sec-set.from 8345 _setCollectionFrom('Set'); 8346 8347 // https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from 8348 _setCollectionFrom('WeakMap'); 8349 8350 // https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.from 8351 _setCollectionFrom('WeakSet'); 8352 8353 // https://github.com/tc39/proposal-global 8354 8355 8356 _export(_export.G, { 8357 global: _global 8358 }); 8359 8360 // https://github.com/tc39/proposal-global 8361 8362 8363 _export(_export.S, 'System', { 8364 global: _global 8365 }); 8366 8367 // https://github.com/ljharb/proposal-is-error 8368 8369 8370 8371 8372 _export(_export.S, 'Error', { 8373 isError: function isError(it) { 8374 return _cof(it) === 'Error'; 8375 } 8376 }); 8377 8378 // https://rwaldron.github.io/proposal-math-extensions/ 8379 8380 8381 _export(_export.S, 'Math', { 8382 clamp: function clamp(x, lower, upper) { 8383 return Math.min(upper, Math.max(lower, x)); 8384 } 8385 }); 8386 8387 // https://rwaldron.github.io/proposal-math-extensions/ 8388 8389 8390 _export(_export.S, 'Math', { 8391 DEG_PER_RAD: Math.PI / 180 8392 }); 8393 8394 // https://rwaldron.github.io/proposal-math-extensions/ 8395 8396 8397 var RAD_PER_DEG = 180 / Math.PI; 8398 _export(_export.S, 'Math', { 8399 degrees: function degrees(radians) { 8400 return radians * RAD_PER_DEG; 8401 } 8402 }); 8403 8404 // https://rwaldron.github.io/proposal-math-extensions/ 8405 var _mathScale = Math.scale || function scale(x, inLow, inHigh, outLow, outHigh) { 8406 if (arguments.length === 0 // eslint-disable-next-line no-self-compare 8407 || x != x // eslint-disable-next-line no-self-compare 8408 || inLow != inLow // eslint-disable-next-line no-self-compare 8409 || inHigh != inHigh // eslint-disable-next-line no-self-compare 8410 || outLow != outLow // eslint-disable-next-line no-self-compare 8411 || outHigh != outHigh) return NaN; 8412 if (x === Infinity || x === -Infinity) return x; 8413 return (x - inLow) * (outHigh - outLow) / (inHigh - inLow) + outLow; 8414 }; 8415 8416 // https://rwaldron.github.io/proposal-math-extensions/ 8417 8418 8419 8420 8421 8422 8423 _export(_export.S, 'Math', { 8424 fscale: function fscale(x, inLow, inHigh, outLow, outHigh) { 8425 return _mathFround(_mathScale(x, inLow, inHigh, outLow, outHigh)); 8426 } 8427 }); 8428 8429 // https://gist.github.com/BrendanEich/4294d5c212a6d2254703 8430 8431 8432 _export(_export.S, 'Math', { 8433 iaddh: function iaddh(x0, x1, y0, y1) { 8434 var $x0 = x0 >>> 0; 8435 var $x1 = x1 >>> 0; 8436 var $y0 = y0 >>> 0; 8437 return $x1 + (y1 >>> 0) + (($x0 & $y0 | ($x0 | $y0) & ~($x0 + $y0 >>> 0)) >>> 31) | 0; 8438 } 8439 }); 8440 8441 // https://gist.github.com/BrendanEich/4294d5c212a6d2254703 8442 8443 8444 _export(_export.S, 'Math', { 8445 isubh: function isubh(x0, x1, y0, y1) { 8446 var $x0 = x0 >>> 0; 8447 var $x1 = x1 >>> 0; 8448 var $y0 = y0 >>> 0; 8449 return $x1 - (y1 >>> 0) - ((~$x0 & $y0 | ~($x0 ^ $y0) & $x0 - $y0 >>> 0) >>> 31) | 0; 8450 } 8451 }); 8452 8453 // https://gist.github.com/BrendanEich/4294d5c212a6d2254703 8454 8455 8456 _export(_export.S, 'Math', { 8457 imulh: function imulh(u, v) { 8458 var UINT16 = 0xffff; 8459 var $u = +u; 8460 var $v = +v; 8461 var u0 = $u & UINT16; 8462 var v0 = $v & UINT16; 8463 var u1 = $u >> 16; 8464 var v1 = $v >> 16; 8465 var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16); 8466 return u1 * v1 + (t >> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >> 16); 8467 } 8468 }); 8469 8470 // https://rwaldron.github.io/proposal-math-extensions/ 8471 8472 8473 _export(_export.S, 'Math', { 8474 RAD_PER_DEG: 180 / Math.PI 8475 }); 8476 8477 // https://rwaldron.github.io/proposal-math-extensions/ 8478 8479 8480 var DEG_PER_RAD = Math.PI / 180; 8481 _export(_export.S, 'Math', { 8482 radians: function radians(degrees) { 8483 return degrees * DEG_PER_RAD; 8484 } 8485 }); 8486 8487 // https://rwaldron.github.io/proposal-math-extensions/ 8488 8489 8490 _export(_export.S, 'Math', { 8491 scale: _mathScale 8492 }); 8493 8494 // https://gist.github.com/BrendanEich/4294d5c212a6d2254703 8495 8496 8497 _export(_export.S, 'Math', { 8498 umulh: function umulh(u, v) { 8499 var UINT16 = 0xffff; 8500 var $u = +u; 8501 var $v = +v; 8502 var u0 = $u & UINT16; 8503 var v0 = $v & UINT16; 8504 var u1 = $u >>> 16; 8505 var v1 = $v >>> 16; 8506 var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16); 8507 return u1 * v1 + (t >>> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >>> 16); 8508 } 8509 }); 8510 8511 // http://jfbastien.github.io/papers/Math.signbit.html 8512 8513 8514 _export(_export.S, 'Math', { 8515 signbit: function signbit(x) { 8516 // eslint-disable-next-line no-self-compare 8517 return (x = +x) != x ? x : x == 0 ? 1 / x == Infinity : x > 0; 8518 } 8519 }); 8520 8521 _export(_export.S, 'Promise', { 8522 'try': function _try(callbackfn) { 8523 var promiseCapability = _newPromiseCapability.f(this); 8524 var result = _perform(callbackfn); 8525 (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v); 8526 return promiseCapability.promise; 8527 } 8528 }); 8529 8530 var shared$1 = _shared('metadata'); 8531 8532 var store = shared$1.store || (shared$1.store = new (es6_weakMap)()); 8533 8534 var getOrCreateMetadataMap = function getOrCreateMetadataMap(target, targetKey, create) { 8535 var targetMetadata = store.get(target); 8536 8537 if (!targetMetadata) { 8538 if (!create) return undefined; 8539 store.set(target, targetMetadata = new es6_map()); 8540 } 8541 8542 var keyMetadata = targetMetadata.get(targetKey); 8543 8544 if (!keyMetadata) { 8545 if (!create) return undefined; 8546 targetMetadata.set(targetKey, keyMetadata = new es6_map()); 8547 } 8548 8549 return keyMetadata; 8550 }; 8551 8552 var ordinaryHasOwnMetadata = function ordinaryHasOwnMetadata(MetadataKey, O, P) { 8553 var metadataMap = getOrCreateMetadataMap(O, P, false); 8554 return metadataMap === undefined ? false : metadataMap.has(MetadataKey); 8555 }; 8556 8557 var ordinaryGetOwnMetadata = function ordinaryGetOwnMetadata(MetadataKey, O, P) { 8558 var metadataMap = getOrCreateMetadataMap(O, P, false); 8559 return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey); 8560 }; 8561 8562 var ordinaryDefineOwnMetadata = function ordinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) { 8563 getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue); 8564 }; 8565 8566 var ordinaryOwnMetadataKeys = function ordinaryOwnMetadataKeys(target, targetKey) { 8567 var metadataMap = getOrCreateMetadataMap(target, targetKey, false); 8568 var keys = [];
vendor: 13,228 bytes, lines 8569-9049
8569 if (metadataMap) metadataMap.forEach(function (_, key) { 8570 keys.push(key); 8571 }); 8572 return keys; 8573 }; 8574 8575 var toMetaKey = function toMetaKey(it) { 8576 return it === undefined || babelHelpers.typeof(it) == 'symbol' ? it : String(it); 8577 }; 8578 8579 var exp$3 = function exp(O) { 8580 _export(_export.S, 'Reflect', O); 8581 }; 8582 8583 var _metadata = { 8584 store: store, 8585 map: getOrCreateMetadataMap, 8586 has: ordinaryHasOwnMetadata, 8587 get: ordinaryGetOwnMetadata, 8588 set: ordinaryDefineOwnMetadata, 8589 keys: ordinaryOwnMetadataKeys, 8590 key: toMetaKey, 8591 exp: exp$3 8592 }; 8593 8594 var toMetaKey$1 = _metadata.key; 8595 var ordinaryDefineOwnMetadata$1 = _metadata.set; 8596 _metadata.exp({ 8597 defineMetadata: function defineMetadata(metadataKey, metadataValue, target, targetKey) { 8598 ordinaryDefineOwnMetadata$1(metadataKey, metadataValue, _anObject(target), toMetaKey$1(targetKey)); 8599 } 8600 }); 8601 8602 var toMetaKey$2 = _metadata.key; 8603 var getOrCreateMetadataMap$1 = _metadata.map; 8604 var store$1 = _metadata.store; 8605 _metadata.exp({ 8606 deleteMetadata: function deleteMetadata(metadataKey, target 8607 /* , targetKey */ 8608 ) { 8609 var targetKey = arguments.length < 3 ? undefined : toMetaKey$2(arguments[2]); 8610 var metadataMap = getOrCreateMetadataMap$1(_anObject(target), targetKey, false); 8611 if (metadataMap === undefined || !metadataMap['delete'](metadataKey)) return false; 8612 if (metadataMap.size) return true; 8613 var targetMetadata = store$1.get(target); 8614 targetMetadata['delete'](targetKey); 8615 return !!targetMetadata.size || store$1['delete'](target); 8616 } 8617 }); 8618 8619 var ordinaryHasOwnMetadata$1 = _metadata.has; 8620 var ordinaryGetOwnMetadata$1 = _metadata.get; 8621 var toMetaKey$3 = _metadata.key; 8622 8623 var ordinaryGetMetadata = function ordinaryGetMetadata(MetadataKey, O, P) { 8624 var hasOwn = ordinaryHasOwnMetadata$1(MetadataKey, O, P); 8625 if (hasOwn) return ordinaryGetOwnMetadata$1(MetadataKey, O, P); 8626 var parent = _objectGpo(O); 8627 return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined; 8628 }; 8629 8630 _metadata.exp({ 8631 getMetadata: function getMetadata(metadataKey, target 8632 /* , targetKey */ 8633 ) { 8634 return ordinaryGetMetadata(metadataKey, _anObject(target), arguments.length < 3 ? undefined : toMetaKey$3(arguments[2])); 8635 } 8636 }); 8637 8638 var ordinaryOwnMetadataKeys$1 = _metadata.keys; 8639 var toMetaKey$4 = _metadata.key; 8640 8641 var ordinaryMetadataKeys = function ordinaryMetadataKeys(O, P) { 8642 var oKeys = ordinaryOwnMetadataKeys$1(O, P); 8643 var parent = _objectGpo(O); 8644 if (parent === null) return oKeys; 8645 var pKeys = ordinaryMetadataKeys(parent, P); 8646 return pKeys.length ? oKeys.length ? _arrayFromIterable(new es6_set(oKeys.concat(pKeys))) : pKeys : oKeys; 8647 }; 8648 8649 _metadata.exp({ 8650 getMetadataKeys: function getMetadataKeys(target 8651 /* , targetKey */ 8652 ) { 8653 return ordinaryMetadataKeys(_anObject(target), arguments.length < 2 ? undefined : toMetaKey$4(arguments[1])); 8654 } 8655 }); 8656 8657 var ordinaryGetOwnMetadata$2 = _metadata.get; 8658 var toMetaKey$5 = _metadata.key; 8659 _metadata.exp({ 8660 getOwnMetadata: function getOwnMetadata(metadataKey, target 8661 /* , targetKey */ 8662 ) { 8663 return ordinaryGetOwnMetadata$2(metadataKey, _anObject(target), arguments.length < 3 ? undefined : toMetaKey$5(arguments[2])); 8664 } 8665 }); 8666 8667 var ordinaryOwnMetadataKeys$2 = _metadata.keys; 8668 var toMetaKey$6 = _metadata.key; 8669 _metadata.exp({ 8670 getOwnMetadataKeys: function getOwnMetadataKeys(target 8671 /* , targetKey */ 8672 ) { 8673 return ordinaryOwnMetadataKeys$2(_anObject(target), arguments.length < 2 ? undefined : toMetaKey$6(arguments[1])); 8674 } 8675 }); 8676 8677 var ordinaryHasOwnMetadata$2 = _metadata.has; 8678 var toMetaKey$7 = _metadata.key; 8679 8680 var ordinaryHasMetadata = function ordinaryHasMetadata(MetadataKey, O, P) { 8681 var hasOwn = ordinaryHasOwnMetadata$2(MetadataKey, O, P); 8682 if (hasOwn) return true; 8683 var parent = _objectGpo(O); 8684 return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false; 8685 }; 8686 8687 _metadata.exp({ 8688 hasMetadata: function hasMetadata(metadataKey, target 8689 /* , targetKey */ 8690 ) { 8691 return ordinaryHasMetadata(metadataKey, _anObject(target), arguments.length < 3 ? undefined : toMetaKey$7(arguments[2])); 8692 } 8693 }); 8694 8695 var ordinaryHasOwnMetadata$3 = _metadata.has; 8696 var toMetaKey$8 = _metadata.key; 8697 _metadata.exp({ 8698 hasOwnMetadata: function hasOwnMetadata(metadataKey, target 8699 /* , targetKey */ 8700 ) { 8701 return ordinaryHasOwnMetadata$3(metadataKey, _anObject(target), arguments.length < 3 ? undefined : toMetaKey$8(arguments[2])); 8702 } 8703 }); 8704 8705 var toMetaKey$9 = _metadata.key; 8706 var ordinaryDefineOwnMetadata$2 = _metadata.set; 8707 _metadata.exp({ 8708 metadata: function metadata(metadataKey, metadataValue) { 8709 return function decorator(target, targetKey) { 8710 ordinaryDefineOwnMetadata$2(metadataKey, metadataValue, (targetKey !== undefined ? _anObject : _aFunction)(target), toMetaKey$9(targetKey)); 8711 }; 8712 } 8713 }); 8714 8715 // https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask 8716 8717 8718 var microtask$1 = _microtask(); 8719 8720 var process$3 = _global.process; 8721 8722 var isNode$2 = _cof(process$3) == 'process'; 8723 _export(_export.G, { 8724 asap: function asap(fn) { 8725 var domain = isNode$2 && process$3.domain; 8726 microtask$1(domain ? domain.bind(fn) : fn); 8727 } 8728 }); 8729 8730 var microtask$2 = _microtask(); 8731 8732 var OBSERVABLE = _wks('observable'); 8733 8734 8735 8736 8737 8738 8739 8740 8741 8742 8743 8744 8745 8746 var RETURN = _forOf.RETURN; 8747 8748 var getMethod = function getMethod(fn) { 8749 return fn == null ? undefined : _aFunction(fn); 8750 }; 8751 8752 var cleanupSubscription = function cleanupSubscription(subscription) { 8753 var cleanup = subscription._c; 8754 8755 if (cleanup) { 8756 subscription._c = undefined; 8757 cleanup(); 8758 } 8759 }; 8760 8761 var subscriptionClosed = function subscriptionClosed(subscription) { 8762 return subscription._o === undefined; 8763 }; 8764 8765 var closeSubscription = function closeSubscription(subscription) { 8766 if (!subscriptionClosed(subscription)) { 8767 subscription._o = undefined; 8768 cleanupSubscription(subscription); 8769 } 8770 }; 8771 8772 var Subscription = function Subscription(observer, subscriber) { 8773 _anObject(observer); 8774 this._c = undefined; 8775 this._o = observer; 8776 observer = new SubscriptionObserver(this); 8777 8778 try { 8779 var cleanup = subscriber(observer); 8780 var subscription = cleanup; 8781 8782 if (cleanup != null) { 8783 if (typeof cleanup.unsubscribe === 'function') cleanup = function cleanup() { 8784 subscription.unsubscribe(); 8785 };else _aFunction(cleanup); 8786 this._c = cleanup; 8787 } 8788 } catch (e) { 8789 observer.error(e); 8790 return; 8791 } 8792 8793 if (subscriptionClosed(this)) cleanupSubscription(this); 8794 }; 8795 8796 Subscription.prototype = _redefineAll({}, { 8797 unsubscribe: function unsubscribe() { 8798 closeSubscription(this); 8799 } 8800 }); 8801 8802 var SubscriptionObserver = function SubscriptionObserver(subscription) { 8803 this._s = subscription; 8804 }; 8805 8806 SubscriptionObserver.prototype = _redefineAll({}, { 8807 next: function next(value) { 8808 var subscription = this._s; 8809 8810 if (!subscriptionClosed(subscription)) { 8811 var observer = subscription._o; 8812 8813 try { 8814 var m = getMethod(observer.next); 8815 if (m) return m.call(observer, value); 8816 } catch (e) { 8817 try { 8818 closeSubscription(subscription); 8819 } finally { 8820 throw e; 8821 } 8822 } 8823 } 8824 }, 8825 error: function error(value) { 8826 var subscription = this._s; 8827 if (subscriptionClosed(subscription)) throw value; 8828 var observer = subscription._o; 8829 subscription._o = undefined; 8830 8831 try { 8832 var m = getMethod(observer.error); 8833 if (!m) throw value; 8834 value = m.call(observer, value); 8835 } catch (e) { 8836 try { 8837 cleanupSubscription(subscription); 8838 } finally { 8839 throw e; 8840 } 8841 } 8842 8843 cleanupSubscription(subscription); 8844 return value; 8845 }, 8846 complete: function complete(value) { 8847 var subscription = this._s; 8848 8849 if (!subscriptionClosed(subscription)) { 8850 var observer = subscription._o; 8851 subscription._o = undefined; 8852 8853 try { 8854 var m = getMethod(observer.complete); 8855 value = m ? m.call(observer, value) : undefined; 8856 } catch (e) { 8857 try { 8858 cleanupSubscription(subscription); 8859 } finally { 8860 throw e; 8861 } 8862 } 8863 8864 cleanupSubscription(subscription); 8865 return value; 8866 } 8867 } 8868 }); 8869 8870 var $Observable = function Observable(subscriber) { 8871 _anInstance(this, $Observable, 'Observable', '_f')._f = _aFunction(subscriber); 8872 }; 8873 8874 _redefineAll($Observable.prototype, { 8875 subscribe: function subscribe(observer) { 8876 return new Subscription(observer, this._f); 8877 }, 8878 forEach: function forEach(fn) { 8879 var that = this; 8880 return new (_core.Promise || _global.Promise)(function (resolve, reject) { 8881 _aFunction(fn); 8882 var subscription = that.subscribe({ 8883 next: function next(value) { 8884 try { 8885 return fn(value); 8886 } catch (e) { 8887 reject(e); 8888 subscription.unsubscribe(); 8889 } 8890 }, 8891 error: reject, 8892 complete: resolve 8893 }); 8894 }); 8895 } 8896 }); 8897 _redefineAll($Observable, { 8898 from: function from(x) { 8899 var C = typeof this === 'function' ? this : $Observable; 8900 var method = getMethod(_anObject(x)[OBSERVABLE]); 8901 8902 if (method) { 8903 var observable = _anObject(method.call(x)); 8904 return observable.constructor === C ? observable : new C(function (observer) { 8905 return observable.subscribe(observer); 8906 }); 8907 } 8908 8909 return new C(function (observer) { 8910 var done = false; 8911 microtask$2(function () { 8912 if (!done) { 8913 try { 8914 if (_forOf(x, false, function (it) { 8915 observer.next(it); 8916 if (done) return RETURN; 8917 }) === RETURN) return; 8918 } catch (e) { 8919 if (done) throw e; 8920 observer.error(e); 8921 return; 8922 } 8923 8924 observer.complete(); 8925 } 8926 }); 8927 return function () { 8928 done = true; 8929 }; 8930 }); 8931 }, 8932 of: function of() { 8933 for (var i = 0, l = arguments.length, items = new Array(l); i < l;) { 8934 items[i] = arguments[i++]; 8935 } 8936 8937 return new (typeof this === 'function' ? this : $Observable)(function (observer) { 8938 var done = false; 8939 microtask$2(function () { 8940 if (!done) { 8941 for (var j = 0; j < items.length; ++j) { 8942 observer.next(items[j]); 8943 if (done) return; 8944 } 8945 8946 observer.complete(); 8947 } 8948 }); 8949 return function () { 8950 done = true; 8951 }; 8952 }); 8953 } 8954 }); 8955 _hide($Observable.prototype, OBSERVABLE, function () { 8956 return this; 8957 }); 8958 _export(_export.G, { 8959 Observable: $Observable 8960 }); 8961 8962 _setSpecies('Observable'); 8963 8964 // ie9- setTimeout & setInterval additional parameters fix 8965 8966 8967 8968 8969 8970 8971 var slice = [].slice; 8972 var MSIE = /MSIE .\./.test(_userAgent); // <- dirty ie9- check 8973 8974 var wrap$1 = function wrap(set) { 8975 return function (fn, time 8976 /* , ...args */ 8977 ) { 8978 var boundArgs = arguments.length > 2; 8979 var args = boundArgs ? slice.call(arguments, 2) : false; 8980 return set(boundArgs ? function () { 8981 // eslint-disable-next-line no-new-func 8982 (typeof fn == 'function' ? fn : Function(fn)).apply(this, args); 8983 } : fn, time); 8984 }; 8985 }; 8986 8987 _export(_export.G + _export.B + _export.F * MSIE, { 8988 setTimeout: wrap$1(_global.setTimeout), 8989 setInterval: wrap$1(_global.setInterval) 8990 }); 8991 8992 _export(_export.G + _export.B, { 8993 setImmediate: _task.set, 8994 clearImmediate: _task.clear 8995 }); 8996 8997 var ITERATOR$4 = _wks('iterator'); 8998 var TO_STRING_TAG = _wks('toStringTag'); 8999 var ArrayValues = _iterators.Array; 9000 var DOMIterables = { 9001 CSSRuleList: true, 9002 // TODO: Not spec compliant, should be false. 9003 CSSStyleDeclaration: false, 9004 CSSValueList: false, 9005 ClientRectList: false, 9006 DOMRectList: false, 9007 DOMStringList: false, 9008 DOMTokenList: true, 9009 DataTransferItemList: false, 9010 FileList: false, 9011 HTMLAllCollection: false, 9012 HTMLCollection: false, 9013 HTMLFormElement: false, 9014 HTMLSelectElement: false, 9015 MediaList: true, 9016 // TODO: Not spec compliant, should be false. 9017 MimeTypeArray: false, 9018 NamedNodeMap: false, 9019 NodeList: true, 9020 PaintRequestList: false, 9021 Plugin: false, 9022 PluginArray: false, 9023 SVGLengthList: false, 9024 SVGNumberList: false, 9025 SVGPathSegList: false, 9026 SVGPointList: false, 9027 SVGStringList: false, 9028 SVGTransformList: false, 9029 SourceBufferList: false, 9030 StyleSheetList: true, 9031 // TODO: Not spec compliant, should be false. 9032 TextTrackCueList: false, 9033 TextTrackList: false, 9034 TouchList: false 9035 }; 9036 9037 for (var collections = _objectKeys(DOMIterables), i$2 = 0; i$2 < collections.length; i$2++) { 9038 var NAME$1 = collections[i$2]; 9039 var explicit = DOMIterables[NAME$1]; 9040 var Collection = _global[NAME$1]; 9041 var proto$3 = Collection && Collection.prototype; 9042 var key$1; 9043 9044 if (proto$3) { 9045 if (!proto$3[ITERATOR$4]) _hide(proto$3, ITERATOR$4, ArrayValues); 9046 if (!proto$3[TO_STRING_TAG]) _hide(proto$3, TO_STRING_TAG, NAME$1); 9047 _iterators[NAME$1] = ArrayValues; 9048 if (explicit) for (key$1 in es6_array_iterator) { 9049 if (!proto$3[key$1]) _redefine(proto$3, key$1, es6_array_iterator[key$
90491], true); 9050 } 9051 } 9052 } 9053 9054 if (window._main_core_polyfill) { 9055 console.warn('main.core.polyfill is loaded more than once on this page'); 9056 } 9057 9058 window._main_core_polyfill = true; 9059 9060}((this.window = this.window || {}))); 9061 9062 9063 9064/** 9065 * Element.prototype.matches polyfill 9066 */ 9067;(function(element) { 9068 'use strict'; 9069 9070 if (!element.matches && element.matchesSelector) 9071 { 9072 element.matches = element.matchesSelector; 9073 } 9074 9075 if (!element.matches) 9076 { 9077 element.matches = function(selector) { 9078 var matches = document.querySelectorAll(selector); 9079 var self = this; 9080 9081 return Array.prototype.some.call(matches, function(e) { 9082 return e === self; 9083 }); 9084 }; 9085 } 9086 9087})(Element.prototype); 9088 9089;(function() { 9090 'use strict'; 9091 9092 if (!Element.prototype.closest) 9093 { 9094 /** 9095 * Finds closest parent element by selector 9096 * @param {string} selector 9097 * @return {HTMLElement|Element|Node} 9098 */ 9099 Object.defineProperty(Element.prototype, 'closest', { 9100 enumerable: false, 9101 value: function(selector) { 9102 var node = this; 9103 9104 while (node) 9105 { 9106 if (node.matches(selector)) 9107 { 9108 return node; 9109 } 9110 9111 node = node.parentElement; 9112 } 9113 9114 return null; 9115 }, 9116 }); 9117 } 9118})(); 9119 9120(function (exports) { 9121 'use strict'; 9122 9123 if (!window.DOMRect || typeof DOMRect.prototype.toJSON !== 'function' || typeof DOMRect.fromRect !== 'function') { 9124 window.DOMRect = 9125 /*#__PURE__*/ 9126 function () { 9127 function DOMRect(x, y, width, height) { 9128 babelHelpers.classCallCheck(this, DOMRect); 9129 this.x = x || 0; 9130 this.y = y || 0; 9131 this.width = width || 0; 9132 this.height = height || 0; 9133 } 9134 9135 babelHelpers.createClass(DOMRect, [{ 9136 key: "toJSON", 9137 value: function toJSON() { 9138 return { 9139 top: this.top, 9140 left: this.left, 9141 right: this.right, 9142 bottom: this.bottom, 9143 width: this.width, 9144 height: this.height, 9145 x: this.x, 9146 y: this.y 9147 }; 9148 } 9149 }, { 9150 key: "top", 9151 get: function get() { 9152 return this.y; 9153 } 9154 }, { 9155 key: "left", 9156 get: function get() { 9157 return this.x; 9158 } 9159 }, { 9160 key: "right", 9161 get: function get() { 9162 return this.x + this.width; 9163 } 9164 }, { 9165 key: "bottom", 9166 get: function get() { 9167 return this.y + this.height; 9168 } 9169 }], [{ 9170 key: "fromRect", 9171 value: function fromRect(otherRect) { 9172 return new DOMRect(otherRect.x, otherRect.y, otherRect.width, otherRect.height); 9173 } 9174 }]); 9175 return DOMRect; 9176 }(); 9177 } 9178 9179}((this.window = this.window || {}))); 9180 9181 9182 9183 9184(function (exports) { 9185 'use strict'; 9186 9187 var bxTmp = window.BX; 9188 9189 window.BX = function (node) { 9190 if (window.BX.type.isNotEmptyString(node)) { 9191 return document.getElementById(node); 9192 } 9193 9194 if (window.BX.type.isDomNode(node)) { 9195 return node; 9196 } 9197 9198 if (window.BX.type.isFunction(node)) { 9199 return window.BX.ready(node); 9200 } 9201 9202 return null; 9203 }; 9204 9205 if (bxTmp) {
9206 Object.keys(bxTmp).forEach(function (key) { 9207 window.BX[key] = bxTmp[key]; 9208 }); 9209 } 9210 9211 exports = window.BX; 9212 9213 /** 9214 * Gets object.toString result 9215 * @param value 9216 * @return {string} 9217 */ 9218 function getTag(value) { 9219 return Object.prototype.toString.call(value); 9220 } 9221 9222 var objectCtorString = Function.prototype.toString.call(Object); 9223 /** 9224 * @memberOf BX 9225 */ 9226 9227 var Type = 9228 /*#__PURE__*/ 9229 function () { 9230 function Type() { 9231 babelHelpers.classCallCheck(this, Type); 9232 } 9233 9234 babelHelpers.createClass(Type, null, [{ 9235 key: "isString", 9236 9237 /** 9238 * Checks that value is string 9239 * @param value 9240 * @return {boolean} 9241 */ 9242 value: function isString(value) { 9243 return typeof value === 'string'; 9244 } 9245 /** 9246 * Returns true if a value is not empty string 9247 * @param value 9248 * @returns {boolean} 9249 */ 9250 9251 }, { 9252 key: "isStringFilled", 9253 value: function isStringFilled(value) { 9254 return this.isString(value) && value !== ''; 9255 } 9256 /** 9257 * Checks that value is function 9258 * @param value 9259 * @return {boolean} 9260 */ 9261 9262 }, { 9263 key: "isFunction", 9264 value: function isFunction(value) { 9265 return typeof value === 'function'; 9266 } 9267 /** 9268 * Checks that value is object 9269 * @param value 9270 * @return {boolean} 9271 */ 9272 9273 }, { 9274 key: "isObject", 9275 value: function isObject(value) { 9276 return !!value && (babelHelpers.typeof(value) === 'object' || typeof value === 'function'); 9277 } 9278 /** 9279 * Checks that value is object like 9280 * @param value 9281 * @return {boolean} 9282 */ 9283 9284 }, { 9285 key: "isObjectLike", 9286 value: function isObjectLike(value) { 9287 return !!value && babelHelpers.typeof(value) === 'object'; 9288 } 9289 /** 9290 * Checks that value is plain object 9291 * @param value 9292 * @return {boolean} 9293 */ 9294 9295 }, { 9296 key: "isPlainObject", 9297 value: function isPlainObject(value) { 9298 if (!Type.isObjectLike(value) || getTag(value) !== '[object Object]') { 9299 return false; 9300 } 9301 9302 var proto = Object.getPrototypeOf(value); 9303 9304 if (proto === null) { 9305 return true; 9306 } 9307 9308 var ctor = proto.hasOwnProperty('constructor') && proto.constructor; 9309 return typeof ctor === 'function' && Function.prototype.toString.call(ctor) === objectCtorString; 9310 } 9311 /** 9312 * Checks that value is boolean 9313 * @param value 9314 * @return {boolean} 9315 */ 9316 9317 }, { 9318 key: "isBoolean", 9319 value: function isBoolean(value) { 9320 return value === true || value === false; 9321 } 9322 /** 9323 * Checks that value is number 9324 * @param value 9325 * @return {boolean} 9326 */ 9327 9328 }, { 9329 key: "isNumber", 9330 value: function isNumber(value) { 9331 return !Number.isNaN(value) && typeof value === 'number'; 9332 } 9333 /** 9334 * Checks that value is integer 9335 * @param value 9336 * @return {boolean} 9337 */ 9338 9339 }, { 9340 key: "isInteger", 9341 value: function isInteger(value) { 9342 return Type.isNumber(value) && value % 1 === 0; 9343 } 9344 /** 9345 * Checks that value is float 9346 * @param value 9347 * @return {boolean} 9348 */ 9349 9350 }, { 9351 key: "isFloat", 9352 value: function isFloat(value) { 9353 return Type.isNumber(value) && !Type.isInteger(value); 9354 } 9355 /** 9356 * Checks that value is nil 9357 * @param value 9358 * @return {boolean} 9359 */ 9360 9361 }, { 9362 key: "isNil", 9363 value: function isNil(value) { 9364 return value === null || value === undefined; 9365 } 9366 /** 9367 * Checks that value is array 9368 * @param value 9369 * @return {boolean} 9370 */ 9371 9372 }, { 9373 key: "isArray", 9374 value: function isArray(value) { 9375 return !Type.isNil(value) && Array.isArray(value); 9376 } 9377 /** 9378 * Returns true if a value is an array and it has at least one element 9379 * @param value 9380 * @returns {boolean} 9381 */ 9382 9383 }, { 9384 key: "isArrayFilled", 9385 value: function isArrayFilled(value) { 9386 return this.isArray(value) && value.length > 0; 9387 } 9388 /** 9389 * Checks that value is array like 9390 * @param value 9391 * @return {boolean} 9392 */ 9393 9394 }, { 9395 key: "isArrayLike", 9396 value: function isArrayLike(value) { 9397 return !Type.isNil(value) && !Type.isFunction(value) && value.length > -1 && value.length <= Number.MAX_SAFE_INTEGER; 9398 } 9399 /** 9400 * Checks that value is Date 9401 * @param value 9402 * @return {boolean} 9403 */ 9404 9405 }, { 9406 key: "isDate", 9407 value: function isDate(value) { 9408 return Type.isObjectLike(value) && getTag(value) === '[object Date]'; 9409 } 9410 /** 9411 * Checks that is DOM node 9412 * @param value 9413 * @return {boolean} 9414 */ 9415 9416 }, { 9417 key: "isDomNode", 9418 value: function isDomNode(value) { 9419 return Type.isObjectLike(value) && !Type.isPlainObject(value) && 'nodeType' in value; 9420 } 9421 /** 9422 * Checks that value is element node 9423 * @param value 9424 * @return {boolean} 9425 */ 9426 9427 }, { 9428 key: "isElementNode", 9429 value: function isElementNode(value) { 9430 return Type.isDomNode(value) && value.nodeType === Node.ELEMENT_NODE; 9431 } 9432 /** 9433 * Checks that value is text node 9434 * @param value 9435 * @return {boolean} 9436 */ 9437 9438 }, { 9439 key: "isTextNode", 9440 value: function isTextNode(value) { 9441 return Type.isDomNode(value) && value.nodeType === Node.TEXT_NODE; 9442 } 9443 /** 9444 * Checks that value is Map 9445 * @param value 9446 * @return {boolean} 9447 */ 9448 9449 }, { 9450 key: "isMap", 9451 value: function isMap(value) { 9452 return Type.isObjectLike(value) && getTag(value) === '[object Map]'; 9453 } 9454 /** 9455 * Checks that value is Set 9456 * @param value 9457 * @return {boolean} 9458 */ 9459 9460 }, { 9461 key: "isSet", 9462 value: function isSet(value) { 9463 return Type.isObjectLike(value) && getTag(value) === '[object Set]'; 9464 } 9465 /** 9466 * Checks that value is WeakMap 9467 * @param value 9468 * @return {boolean} 9469 */ 9470 9471 }, { 9472 key: "isWeakMap", 9473 value: function isWeakMap(value) { 9474 return Type.isObjectLike(value) && getTag(value) === '[object WeakMap]'; 9475 } 9476 /** 9477 * Checks that value is WeakSet 9478 * @param value 9479 * @return {boolean} 9480 */ 9481 9482 }, { 9483 key: "isWeakSet", 9484 value: function isWeakSet(value) { 9485 return Type.isObjectLike(value) && getTag(value) === '[object WeakSet]'; 9486 } 9487 /** 9488 * Checks that value is prototype 9489 * @param value 9490 * @return {boolean} 9491 */ 9492 9493 }, { 9494 key: "isPrototype", 9495 value: function isPrototype(value) { 9496 return (typeof (value && value.constructor) === 'function' && value.constructor.prototype || Object.prototype) === value; 9497 } 9498 /** 9499 * Checks that value is regexp 9500 * @param value 9501 * @return {boolean} 9502 */ 9503 9504 }, { 9505 key: "isRegExp", 9506 value: function isRegExp(value) { 9507 return Type.isObjectLike(value) && getTag(value) === '[object RegExp]'; 9508 } 9509 /** 9510 * Checks that value is null 9511 * @param value 9512 * @return {boolean} 9513 */ 9514 9515 }, { 9516 key: "isNull", 9517 value: function isNull(value) { 9518 return value === null; 9519 } 9520 /** 9521 * Checks that value is undefined 9522 * @param value 9523 * @return {boolean} 9524 */ 9525 9526 }, { 9527 key: "isUndefined", 9528 value: function isUndefined(value) { 9529 return typeof value === 'undefined'; 9530 } 9531 /** 9532 * Checks that value is ArrayBuffer 9533 * @param value 9534 * @return {boolean} 9535 */ 9536 9537 }, { 9538 key: "isArrayBuffer", 9539 value: function isArrayBuffer(value) { 9540 return Type.isObjectLike(value) && getTag(value) === '[object ArrayBuffer]'; 9541 } 9542 /** 9543 * Checks that value is typed array 9544 * @param value 9545 * @return {boolean} 9546 */ 9547 9548 }, { 9549 key: "isTypedArray", 9550 value: function isTypedArray(value) { 9551 var regExpTypedTag = /^\[object (?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)]$/; 9552 return Type.isObjectLike(value) && regExpTypedTag.test(getTag(value)); 9553 } 9554 /** 9555 * Checks that value is Blob 9556 * @param value 9557 * @return {boolean} 9558 */ 9559 9560 }, { 9561 key: "isBlob", 9562 value: function isBlob(value) { 9563 return Type.isObjectLike(value) && Type.isNumber(value.size) && Type.isString(value.type) && Type.isFunction(value.slice); 9564 } 9565 /** 9566 * Checks that value is File 9567 * @param value 9568 * @return {boolean} 9569 */ 9570 9571 }, { 9572 key: "isFile", 9573 value: function isFile(value) { 9574 return Type.isBlob(value) && Type.isObjectLike(value.lastModifiedDate) && Type.isNumber(value.lastModified) && Type.isString(value.name); 9575 } 9576 /** 9577 * Checks that value is FormData 9578 * @param value 9579 * @return {boolean} 9580 */ 9581 9582 }, { 9583 key: "isFormData", 9584 value: function isFormData(value) { 9585 return value instanceof FormData; 9586 } 9587 }]); 9588 return Type; 9589 }(); 9590 9591 /** 9592 * @memberOf BX 9593 */ 9594 9595 var Reflection = 9596 /*#__PURE__*/ 9597 function () { 9598 function Reflection() { 9599 babelHelpers.classCallCheck(this, Reflection); 9600 } 9601 9602 babelHelpers.createClass(Reflection, null, [{ 9603 key: "getClass", 9604 9605 /** 9606 * Gets link to function by function name 9607 * @param className 9608 * @return {?Function} 9609 */ 9610 value: function getClass(className) { 9611 if (Type.isString(className) && !!className) { 9612 var classFn = null; 9613 var currentNamespace = window; 9614 var namespaces = className.split('.'); 9615 9616 for (var i = 0; i < namespaces.length; i += 1) { 9617 var namespace = namespaces[i]; 9618 9619 if (!currentNamespace[namespace]) { 9620 return null; 9621 } 9622 9623 currentNamespace = currentNamespace[namespace]; 9624 classFn = currentNamespace; 9625 } 9626 9627 return classFn; 9628 } 9629 9630 if (Type.isFunction(className)) { 9631 return className; 9632 } 9633 9634 return null; 9635 } 9636 /** 9637 * Creates a namespace or returns a link to a previously created one 9638 * @param {String} namespaceName 9639 * @return {Object<string, any> | Function | null} 9640 */ 9641 9642 }, { 9643 key: "namespace", 9644 value: function namespace(namespaceName) { 9645 var parts = namespaceName.split('.'); 9646 var parent = window.BX; 9647 9648 if (parts[0] === 'BX') { 9649 parts = parts.slice(1); 9650 } 9651 9652 for (var i = 0; i < parts.length; i += 1) { 9653 if (Type.isUndefined(parent[parts[i]])) { 9654 parent[parts[i]] = {}; 9655 } 9656 9657 parent = parent[parts[i]]; 9658 } 9659 9660 return parent; 9661 } 9662 }]); 9663 return Reflection; 9664 }(); 9665 9666 var reEscape = /[&<>'"]/g; 9667 var reUnescape = /&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34);/g; 9668 var escapeEntities = { 9669 '&': '&', 9670 '<': '<', 9671 '>': '>', 9672 "'": ''', 9673 '"': '"' 9674 }; 9675 var unescapeEntities = { 9676 '&': '&', 9677 '&': '&', 9678 '<': '<', 9679 '<': '<', 9680 '>': '>', 9681 '>': '>', 9682 ''': "'", 9683 ''': "'", 9684 '"': '"', 9685 '"': '"' 9686 }; 9687 /** 9688 * @memberOf BX 9689 */ 9690 9691 var Text = 9692 /*#__PURE__*/ 9693 function () { 9694 function Text() { 9695 babelHelpers.classCallCheck(this, Text); 9696 } 9697 9698 babelHelpers.createClass(Text, null, [{ 9699 key: "encode", 9700 9701 /** 9702 * Encodes all unsafe entities 9703 * @param {string} value 9704 * @return {string} 9705 */ 9706 value: function encode(value) { 9707 if (Type.isString(value)) { 9708 return value.replace(reEscape, function (item) { 9709 return escapeEntities[item]; 9710 }); 9711 } 9712 9713 return value; 9714 } 9715 /** 9716 * Decodes all encoded entities 9717 * @param {string} value 9718 * @return {string} 9719 */ 9720 9721 }, { 9722 key: "decode", 9723 value: function decode(value) { 9724 if (Type.isString(value)) { 9725 return value.replace(reUnescape, function (item) { 9726 return unescapeEntities[item]; 9727 }); 9728 } 9729 9730 return value; 9731 } 9732 }, { 9733 key: "getRandom", 9734 value: function getRandom() { 9735 var length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 8; 9736 // eslint-disable-next-line 9737 return babelHelpers.toConsumableArray(Array(length)).map(function () { 9738 return (~~(Math.random() * 36)).toString(36); 9739 }).join(''); 9740 } 9741 }, { 9742 key: "toNumber", 9743 value: function toNumber(value) { 9744 var parsedValue = Number.parseFloat(value); 9745 9746 if (Type.isNumber(parsedValue)) { 9747 return parsedValue; 9748 } 9749 9750 return 0; 9751 } 9752 }, { 9753 key: "toInteger", 9754 value: function toInteger(value) { 9755 return Text.toNumber(Number.parseInt(value, 10)); 9756 } 9757 }, { 9758 key: "toBoolean", 9759 value: function toBoolean(value) { 9760 var trueValues = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 9761 var transformedValue = Type.isString(value) ? value.toLowerCase() : value; 9762 return ['true', 'y', '1', 1, true].concat(babelHelpers.toConsumableArray(trueValues)).includes(transformedValue); 9763 } 9764 }, { 9765 key: "toCamelCase", 9766 value: function toCamelCase(str) { 9767 if (!Type.isStringFilled(str)) { 9768 return str; 9769 } 9770 9771 var regex = /[-_\s]+(.)?/g; 9772 9773 if (!regex.test(str)) { 9774 return str.match(/^[A-Z]+$/) ? str.toLowerCase() : str[0].toLowerCase() + str.slice(1); 9775 } 9776 9777 str = str.toLowerCase(); 9778 str = str.replace(regex, function (match, letter) { 9779 return letter ? letter.toUpperCase() : ''; 9780 }); 9781 return str[0].toLowerCase() + str.substr(1); 9782 } 9783 }, { 9784 key: "toPascalCase", 9785 value: function toPascalCase(str) { 9786 if (!Type.isStringFilled(str)) { 9787 return str; 9788 } 9789 9790 return this.capitalize(this.toCamelCase(str)); 9791 } 9792 }, { 9793 key: "toKebabCase", 9794 value: function toKebabCase(str) { 9795 if (!Type.isStringFilled(str)) { 9796 return str; 9797 } 9798 9799 var matches = str.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g); 9800 9801 if (!matches) { 9802 return str; 9803 } 9804 9805 return matches.map(function (x) { 9806 return x.toLowerCase(); 9807 }).join('-'); 9808 } 9809 }, { 9810 key: "capitalize", 9811 value: function capitalize(str) { 9812 if (!Type.isStringFilled(str)) { 9813 return str; 9814 } 9815 9816 return str[0].toUpperCase() + str.substr(1); 9817 } 9818 }]); 9819 return Text; 9820 }(); 9821 9822 var aliases = { 9823 mousewheel: ['DOMMouseScroll'], 9824 bxchange: ['change', 'cut', 'paste', 'drop', 'keyup'], 9825 animationend: ['animationend', 'oAnimationEnd', 'webkitAnimationEnd', 'MSAnimationEnd'], 9826 transitionend: ['webkitTransitionEnd', 'otransitionend', 'oTransitionEnd', 'msTransitionEnd', 'transitionend'], 9827 fullscreenchange: ['fullscreenchange', 'webkitfullscreenchange', 'mozfullscreenchange', 'MSFullscreenChange'], 9828 fullscreenerror: ['fullscreenerror', 'webkitfullscreenerror', 'mozfullscreenerror', 'MSFullscreenError'] 9829 }; 9830 9831 var Registry = 9832 /*#__PURE__*/ 9833 function () { 9834 function Registry() { 9835 babelHelpers.classCallCheck(this, Registry); 9836 babelHelpers.defineProperty(this, "registry", new WeakMap()); 9837 } 9838 9839 babelHelpers.createClass(Registry, [{ 9840 key: "set", 9841 value: function set(target, event, listener) { 9842 var events = this.get(target); 9843 9844 if (!Type.isSet(events[event])) { 9845 events[event] = new Set(); 9846 } 9847 9848 events[event].add(listener); 9849 this.registry.set(target, events); 9850 } 9851 }, { 9852 key: "get", 9853 value: function get(target) { 9854 return this.registry.get(target) || {}; 9855 } 9856 }, { 9857 key: "has", 9858 value: function has(target, event, listener) { 9859 if (event && listener) { 9860 return this.registry.has(target) && this.registry.get(target)[event].has(listener); 9861 } 9862 9863 return this.registry.has(target); 9864 } 9865 }, { 9866 key: "delete", 9867 value: function _delete(target, event, listener) { 9868 if (!Type.isDomNode(target)) { 9869 return; 9870 } 9871 9872 if (Type.isString(event) && Type.isFunction(listener)) { 9873 var events = this.registry.get(target); 9874 9875 if (Type.isPlainObject(events) && Type.isSet(events[event])) { 9876 events[event].delete(listener); 9877 } 9878 9879 return; 9880 } 9881 9882 if (Type.isString(event)) { 9883 var _events = this.registry.get(target); 9884 9885 if (Type.isPlainObject(_events) && Type.isSet(_ev
9885ents[event])) { 9886 _events[event] = new Set(); 9887 } 9888 9889 return; 9890 } 9891 9892 this.registry.delete(target); 9893 } 9894 }]); 9895 return Registry; 9896 }(); 9897 var registry = new Registry(); 9898 9899 function isOptionSupported(name) { 9900 var isSupported = false; 9901 9902 try { 9903 var options = Object.defineProperty({}, name, { 9904 get: function get() { 9905 isSupported = true; 9906 return undefined; 9907 } 9908 }); 9909 window.addEventListener('test', null, options); 9910 } // eslint-disable-next-line 9911 catch (err) {} 9912 9913 return isSupported; 9914 } 9915 9916 function fetchSupportedListenerOptions(options) { 9917 if (!Type.isPlainObject(options)) { 9918 return options; 9919 } 9920 9921 return Object.keys(options).reduce(function (acc, name) { 9922 if (isOptionSupported(name)) { 9923 acc[name] = options[name]; 9924 } 9925 9926 return acc; 9927 }, {}); 9928 } 9929 9930 function bind(target, eventName, handler, options) { 9931 if (!Type.isObject(target) || !Type.isFunction(target.addEventListener)) { 9932 return; 9933 } 9934 9935 var listenerOptions = fetchSupportedListenerOptions(options); 9936 9937 if (eventName in aliases) { 9938 aliases[eventName].forEach(function (key) { 9939 target.addEventListener(key, handler, listenerOptions); 9940 registry.set(target, eventName, handler); 9941 }); 9942 return; 9943 } 9944 9945 target.addEventListener(eventName, handler, listenerOptions); 9946 registry.set(target, eventName, handler); 9947 } 9948 9949 function unbind(target, eventName, handler, options) { 9950 if (!Type.isObject(target) || !Type.isFunction(target.removeEventListener)) { 9951 return; 9952 } 9953 9954 var listenerOptions = fetchSupportedListenerOptions(options); 9955 9956 if (eventName in aliases) { 9957 aliases[eventName].forEach(function (key) { 9958 target.removeEventListener(key, handler, listenerOptions); 9959 registry.delete(target, key, handler); 9960 }); 9961 return; 9962 } 9963 9964 target.removeEventListener(eventName, handler, listenerOptions); 9965 registry.delete(target, eventName, handler); 9966 } 9967 9968 function unbindAll(target, eventName) { 9969 var events = registry.get(target); 9970 Object.keys(events).forEach(function (currentEvent) { 9971 events[currentEvent].forEach(function (handler) { 9972 if (!Type.isString(eventName) || eventName === currentEvent) { 9973 unbind(target, currentEvent, handler); 9974 } 9975 }); 9976 }); 9977 } 9978 9979 function bindOnce(target, eventName, handler, options) { 9980 var once = function once() { 9981 unbind(target, eventName, once, options); 9982 handler.apply(void 0, arguments); 9983 }; 9984 9985 bind(target, eventName, once, options); 9986 } 9987 9988 var debugState = true; 9989 function enableDebug() { 9990 debugState = true; 9991 } 9992 function disableDebug() { 9993 debugState = false; 9994 } 9995 function isDebugEnabled() { 9996 return debugState; 9997 } 9998 function debug() { 9999 if (isDebugEnabled() && Type.isObject(window.console)) { 10000 if (Type.isFunction(window.console.log)) { 10001 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 10002 args[_key] = arguments[_key]; 10003 } 10004 10005 window.console.log('BX.debug: ', args.length > 0 ? args : args[0]); 10006 10007 if (args[0] instanceof Error && args[0].stack) { 10008 window.console.log('BX.debug error stack trace', args[0].stack); 10009 } 10010 } 10011 10012 if (Type.isFunction(window.console.trace)) { 10013 // eslint-disable-next-line 10014 console.trace(); 10015 } 10016 } 10017 } 10018 10019 function fetchExtensionSettings(html) { 10020 if (Type.isStringFilled(html)) { 10021 var scripts = html.match(/<script type="extension\/settings" \b[^>]*>([\s\S]*?)<\/script>/g); 10022 10023 if (Type.isArrayFilled(scripts)) { 10024 return scripts.map(function (script) { 10025 var _script$match = script.match(/data-extension="(.[a-z0-9_.-]+)"/), 10026 _script$match2 = babelHelpers.slicedToArray(_script$match, 2), 10027 extension = _script$match2[1]; 10028 10029 return { 10030 extension: extension, 10031 script: script 10032 }; 10033 }); 10034 } 10035 } 10036 10037 return []; 10038 } 10039 10040 var Extension = 10041 /*#__PURE__*/ 10042 function () { 10043 function Extension(options) { 10044 babelHelpers.classCallCheck(this, Extension); 10045 this.config = options.config || {}; 10046 this.name = options.extension; 10047 this.state = 'scheduled'; // eslint-disable-next-line 10048 10049 var result = BX.processHTML(options.html || ''); 10050 this.inlineScripts = result.SCRIPT.reduce(inlineScripts, []); 10051 this.externalScripts = result.SCRIPT.reduce(externalScripts, []); 10052 this.externalStyles = result.STYLE.reduce(externalStyles, []); 10053 this.settingsScripts = fetchExtensionSettings(result.HTML); 10054 } 10055 10056 babelHelpers.createClass(Extension, [{ 10057 key: "load", 10058 value: function load() { 10059 var _this = this; 10060 10061 if (this.state === 'error') { 10062 this.loadPromise = this.loadPromise || Promise.resolve(this); 10063 console.warn('Extension', this.name, 'not found'); 10064 } 10065 10066 if (!this.loadPromise && this.state) { 10067 this.state = 'load';
10068 this.settingsScripts.forEach(function (entry) { 10069 var isLoaded = !!document.querySelector("script[data-extension=\"".concat(entry.extension, "\"]")); 10070 10071 if (!isLoaded) { 10072 document.body.insertAdjacentHTML('beforeend', entry.script); 10073 } 10074 }); 10075 this.inlineScripts.forEach(BX.evalGlobal); 10076 this.loadPromise = Promise.all([loadAll(this.externalScripts), loadAll(this.externalStyles)]).then(function () { 10077 _this.state = 'loaded'; 10078 10079 if (Type.isPlainObject(_this.config) && _this.config.namespace) { 10080 return Reflection.getClass(_this.config.namespace); 10081 } 10082 10083 return window; 10084 }); 10085 } 10086 10087 return this.loadPromise; 10088 } 10089 }]); 10090 return Extension; 10091 }(); 10092 10093 var initialized = {}; 10094 var ajaxController = 'main.bitrix.main.controller.loadext.getextensions'; 10095 10096 function makeIterable(value) { 10097 return Type.isArray(value) ? value : [value]; 10098 } 10099 function isInitialized(extension) { 10100 return extension in initialized; 10101 } 10102 function getInitialized(extension) { 10103 return initialized[extension]; 10104 } 10105 function isAllInitialized(extensions) { 10106 return extensions.every(isInitialized); 10107 } 10108 function loadExtensions(extensions) { 10109 return Promise.all(extensions.map(function (item) { 10110 return item.load(); 10111 })); 10112 } 10113 function mergeExports(exports) { 10114 return exports.reduce(function (acc, currentExports) { 10115 if (Type.isObject(currentExports)) { 10116 return babelHelpers.objectSpread({}, currentExports); 10117 } 10118 10119 return currentExports; 10120 }, {}); 10121 } 10122 function inlineScripts(acc, item) { 10123 if (item.isInternal) { 10124 acc.push(item.JS); 10125 } 10126 10127 return acc; 10128 } 10129 function externalScripts(acc, item) { 10130 if (!item.isInternal) { 10131 acc.push(item.JS); 10132 } 10133 10134 return acc; 10135 } 10136 function externalStyles(acc, item) { 10137 if (Type.isString(item) && item !== '') { 10138 acc.push(item); 10139 } 10140 10141 return acc; 10142 } 10143 function request(options) { 10144 return new Promise(function (resolve) { 10145 // eslint-disable-next-line 10146 BX.ajax.runAction(ajaxController, { 10147 data: options 10148 }).then(resolve); 10149 }); 10150 } 10151 function prepareExtensions(response) { 10152 if (response.status !== 'success') { 10153 response.errors.map(console.warn); 10154 return []; 10155 } 10156 10157 return response.data.map(function (item) { 10158 var initializedExtension = getInitialized(item.extension); 10159 10160 if (initializedExtension) { 10161 return initializedExtension; 10162 } 10163 10164 initialized[item.extension] = new Extension(item); 10165 return initialized[item.extension]; 10166 }); 10167 } 10168 function loadAll(items) { 10169 var itemsList = makeIterable(items); 10170 10171 if (!itemsList.length) { 10172 return Promise.resolve(); 10173 } 10174 10175 return new Promise(function (resolve) { 10176 // eslint-disable-next-line 10177 BX.load(itemsList, resolve); 10178 }); 10179 } 10180 10181 /** 10182 * Loads extensions asynchronously 10183 * @param {string|Array<string>} extension 10184 * @return {Promise<Array<Extension>>} 10185 */ 10186 function loadExtension(extension) { 10187 var extensions = makeIterable(extension); 10188 var isAllInitialized$1 = isAllInitialized(extensions); 10189 10190 if (isAllInitialized$1) { 10191 var initializedExtensions = extensions.map(getInitialized); 10192 return loadExtensions(initializedExtensions).then(mergeExports); 10193 } 10194 10195 return request({ 10196 extension: extensions 10197 }).then(prepareExtensions).then(loadExtensions).then(mergeExports); 10198 } 10199 10200 var cloneableTags = ['[object Object]', '[object Array]', '[object RegExp]', '[object Arguments]', '[object Date]', '[object Error]', '[object Map]', '[object Set]', '[object ArrayBuffer]', '[object DataView]', '[object Float32Array]', '[object Float64Array]', '[object Int8Array]', '[object Int16Array]', '[object Int32Array]', '[object Uint8Array]', '[object Uint16Array]', '[object Uint32Array]', '[object Uint8ClampedArray]']; 10201 10202 function isCloneable(value) { 10203 var isCloneableValue = Type.isObjectLike(value) && cloneableTags.includes(getTag(value)); 10204 return isCloneableValue || Type.isDomNode(value); 10205 } 10206 10207 function internalClone(value, map) { 10208 if (map.has(value)) { 10209 return map.get(value); 10210 } 10211 10212 if (isCloneable(value)) { 10213 if (Type.isArray(value)) { 10214 var cloned = Array.from(value); 10215 map.set(value, cloned); 10216 value.forEach(function (item, index) { 10217 cloned[index] = internalClone(item, map); 10218 }); 10219 return map.get(value); 10220 } 10221 10222 if (Type.isDomNode(value)) { 10223 return value.cloneNode(true); 10224 } 10225 10226 if (Type.isMap(value)) { 10227 var _result = new Map(); 10228 10229 map.set(value, _result); 10230 value.forEach(function (item, key) { 10231 _result.set(internalClone(key, map), internalClone(item, map)); 10232 }); 10233 return _result; 10234 } 10235 10236 if (Type.isSet(value)) { 10237 var _result2 = new Set(); 10238 10239 map.set(value, _result2); 10240 value.forEach(function (item) { 10241 _result2.add(internalClone(item, map)); 10242 }); 10243 return _result2; 10244 } 10245 10246 if (Type.isDate(value)) { 10247 return new Date(value); 10248 } 10249 10250 if (Type.isRegExp(value)) { 10251 var regExpFlags = /\w*$/; 10252 var flags = regExpFlags.exec(value); 10253 10254 var _result3 = new RegExp(value.source); 10255 10256 if (flags && Type.isArray(flags)) { 10257 _result3 = new RegExp(value.source, flags[0]); 10258 } 10259 10260 _result3.lastIndex = value.lastIndex; 10261 return _result3; 10262 } 10263 10264 var proto = Object.getPrototypeOf(value); 10265 var result = Object.assign(Object.create(proto), value); 10266 map.set(value, result); 10267 Object.keys(value).forEach(function (key) { 10268 result[key] = internalClone(value[key], map); 10269 }); 10270 return result; 10271 } 10272 10273 return value; 10274 }
10275 /** 10276 * Clones any cloneable object 10277 * @param value 10278 * @return {*} 10279 */ 10280 10281 function clone(value) { 10282 return internalClone(value, new WeakMap()); 10283 } 10284 10285 function merge(current, target) { 10286 return Object.entries(target).reduce(function (acc, _ref) { 10287 var _ref2 = babelHelpers.slicedToArray(_ref, 2), 10288 key = _ref2[0], 10289 value = _ref2[1]; 10290 10291 if (!Type.isDomNode(acc[key]) && Type.isObjectLike(acc[key]) && Type.isObjectLike(value)) { 10292 acc[key] = merge(acc[key], value); 10293 return acc; 10294 } 10295 10296 acc[key] = value; 10297 return acc; 10298 }, current); 10299 } 10300 10301 function createComparator(fields) { 10302 var orders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 10303 return function (a, b) { 10304 var field = fields[0]; 10305 var order = orders[0] || 'asc'; 10306 10307 if (Type.isUndefined(field)) { 10308 return 0; 10309 } 10310 10311 var valueA = a[field]; 10312 var valueB = b[field]; 10313 10314 if (Type.isString(valueA) && Type.isString(valueB)) { 10315 valueA = valueA.toLowerCase(); 10316 valueB = valueB.toLowerCase(); 10317 } 10318 10319 if (valueA < valueB) { 10320 return order === 'asc' ? -1 : 1; 10321 } 10322 10323 if (valueA > valueB) { 10324 return order === 'asc' ? 1 : -1; 10325 } 10326 10327 return createComparator(fields.slice(1), orders.slice(1))(a, b); 10328 }; 10329 } 10330 10331 /** 10332 * @memberOf BX 10333 */ 10334 10335 var Runtime = 10336 /*#__PURE__*/ 10337 function () { 10338 function Runtime() { 10339 babelHelpers.classCallCheck(this, Runtime); 10340 } 10341 10342 babelHelpers.createClass(Runtime, null, [{ 10343 key: "debounce", 10344 value: function debounce(func) { 10345 var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 10346 var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; 10347 var timeoutId; 10348 return function debounced() { 10349 var _this = this; 10350 10351 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 10352 args[_key] = arguments[_key]; 10353 } 10354 10355 if (Type.isNumber(timeoutId)) { 10356 clearTimeout(timeoutId); 10357 } 10358 10359 timeoutId = setTimeout(function () { 10360 func.apply(context || _this, args); 10361 }, wait); 10362 }; 10363 } 10364 }, { 10365 key: "throttle", 10366 value: function throttle(func) { 10367 var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 10368 var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; 10369 var timer = 0; 10370 var invoke; 10371 return function wrapper() { 10372 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 10373 args[_key2] = arguments[_key2]; 10374 } 10375 10376 invoke = true; 10377 10378 if (!timer) { 10379 var q = function q() { 10380 if (invoke) { 10381 func.apply(context || this, args); 10382 invoke = false; 10383 timer = setTimeout(q, wait); 10384 } else { 10385 timer = null; 10386 } 10387 }; 10388 10389 q(); 10390 } 10391 }; 10392 } 10393 }, { 10394 key: "html", 10395 value: function html(node, _html) { 10396 var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 10397 10398 if (Type.isNil(_html) && Type.isDomNode(node)) { 10399 return node.innerHTML; 10400 } // eslint-disable-next-line 10401 10402 10403 var parsedHtml = BX.processHTML(_html); 10404 var externalCss = parsedHtml.STYLE.reduce(externalStyles, []); 10405 var externalJs = parsedHtml.SCRIPT.reduce(externalScripts, []); 10406 var inlineJs = parsedHtml.SCRIPT.reduce(inlineScripts, []); 10407 10408 if (Type.isDomNode(node)) { 10409 if (params.htmlFirst || !externalJs.length && !externalCss.length) { 10410 node.innerHTML = parsedHtml.HTML; 10411 } 10412 } 10413 10414 return Promise.all([loadAll(externalJs), loadAll(externalCss)]).then(function () { 10415 if (Type.isDomNode(node) && (externalJs.length > 0 || externalCss.length > 0)) { 10416 node.innerHTML = parsedHtml.HTML; 10417 } // eslint-disable-next-line 10418 10419 10420 inlineJs.forEach(function (script) { 10421 return BX.evalGlobal(script); 10422 }); 10423 10424 if (Type.isFunction(params.callback)) { 10425 params.callback(); 10426 } 10427 }); 10428 } 10429 /** 10430 * Merges objects or arrays 10431 * @param targets 10432 * @return {any} 10433 */ 10434 10435 }, { 10436 key: "merge", 10437 value: function merge$1() { 10438 for (var _len3 = arguments.length, targets = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { 10439 targets[_key3] = arguments[_key3]; 10440 } 10441 10442 if (Type.isArray(targets[0])) { 10443 targets.unshift([]); 10444 } else if (Type.isObject(targets[0])) { 10445 targets.unshift({}); 10446 } 10447 10448 return targets.reduce(function (acc, item) { 10449 return merge(acc, item); 10450 }, targets[0]); 10451 } 10452 }, { 10453 key: "orderBy", 10454 value: function orderBy(collection) { 10455 var fields = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 10456 var orders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; 10457 var comparator = createComparator(fields, orders); 10458 return Object.values(collection).sort(comparator); 10459 } 10460 }, {
10461 key: "destroy", 10462 value: function destroy(target) { 10463 var errorMessage = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Object is destroyed'; 10464 10465 if (Type.isObject(target)) { 10466 var onPropertyAccess = function onPropertyAccess() { 10467 throw new Error(errorMessage); 10468 }; 10469 10470 var ownProperties = Object.keys(target); 10471 10472 var prototypeProperties = function () { 10473 var targetPrototype = Object.getPrototypeOf(target); 10474 10475 if (Type.isObject(targetPrototype)) { 10476 return Object.getOwnPropertyNames(targetPrototype); 10477 } 10478 10479 return []; 10480 }(); 10481 10482 var uniquePropertiesList = babelHelpers.toConsumableArray(new Set([].concat(babelHelpers.toConsumableArray(ownProperties), babelHelpers.toConsumableArray(prototypeProperties)))); 10483 uniquePropertiesList.filter(function (name) { 10484 var descriptor = Object.getOwnPropertyDescriptor(target, name); 10485 return !/__(.+)__/.test(name) && (!Type.isObject(descriptor) || descriptor.configurable === true); 10486 }
10486).forEach(function (name) { 10487 Object.defineProperty(target, name, { 10488 get: onPropertyAccess, 10489 set: onPropertyAccess, 10490 configurable: false 10491 }); 10492 }); 10493 Object.setPrototypeOf(target, null); 10494 } 10495 } 10496 }]); 10497 return Runtime; 10498 }(); 10499 10500 babelHelpers.defineProperty(Runtime, "debug", debug); 10501 babelHelpers.defineProperty(Runtime, "loadExtension", loadExtension); 10502 babelHelpers.defineProperty(Runtime, "clone", clone); 10503 10504 var _isError = Symbol.for('BX.BaseError.isError'); 10505 /** 10506 * @memberOf BX 10507 */ 10508 10509 10510 var BaseError = 10511 /*#__PURE__*/ 10512 function () { 10513 function BaseError(message, code, customData) { 10514 babelHelpers.classCallCheck(this, BaseError); 10515 this[_isError] = true; 10516 this.message = ''; 10517 this.code = null; 10518 this.customData = null; 10519 this.setMessage(message); 10520 this.setCode(code); 10521 this.setCustomData(customData); 10522 } 10523 /** 10524 * Returns a brief description of the error 10525 * @returns {string} 10526 */ 10527 10528 10529 babelHelpers.createClass(BaseError, [{ 10530 key: "getMessage", 10531 value: function getMessage() { 10532 return this.message; 10533 } 10534 /** 10535 * Sets a message of the error 10536 * @param {string} message 10537 * @returns {this} 10538 */ 10539 10540 }, { 10541 key: "setMessage", 10542 value: function setMessage(message) { 10543 if (Type.isString(message)) { 10544 this.message = message; 10545 } 10546 10547 return this; 10548 } 10549 /** 10550 * Returns a code of the error 10551 * @returns {?string} 10552 */ 10553 10554 }, { 10555 key: "getCode", 10556 value: function getCode() { 10557 return this.code; 10558 } 10559 /** 10560 * Sets a code of the error 10561 * @param {string} code 10562 * @returns {this} 10563 */ 10564 10565 }, { 10566 key: "setCode", 10567 value: function setCode(code) { 10568 if (Type.isStringFilled(code) || code === null) { 10569 this.code = code; 10570 } 10571 10572 return this; 10573 } 10574 /** 10575 * Returns custom data of the error 10576 * @returns {null|*} 10577 */ 10578 10579 }, { 10580 key: "getCustomData", 10581 value: function getCustomData() { 10582 return this.customData; 10583 } 10584 /** 10585 * Sets custom data of the error 10586 * @returns {this} 10587 */ 10588 10589 }, { 10590 key: "setCustomData", 10591 value: function setCustomData(customData) { 10592 if (!Type.isUndefined(customData)) { 10593 this.customData = customData; 10594 } 10595 10596 return this; 10597 } 10598 }, { 10599 key: "toString", 10600 value: function toString() { 10601 var code = this.getCode(); 10602 var message = this.getMessage(); 10603 10604 if (!Type.isStringFilled(code) && !Type.isStringFilled(message)) { 10605 return ''; 10606 } else if (!Type.isStringFilled(code)) { 10607 return "Error: ".concat(message); 10608 } else if (!Type.isStringFilled(message)) { 10609 return code; 10610 } else { 10611 return "".concat(code, ": ").concat(message); 10612 } 10613 } 10614 /** 10615 * Returns true if the object is an instance of BaseError 10616 * @param error 10617 * @returns {boolean} 10618 */ 10619 10620 }], [{ 10621 key: "isError", 10622 value: function isError(error) { 10623 return Type.isObject(error) && error[_isError] === true; 10624 } 10625 }]); 10626 return BaseError; 10627 }(); 10628 10629 /** 10630 * Implements base event object interface 10631 */ 10632 10633 var BaseEvent = 10634 /*#__PURE__*/ 10635 function () { 10636 function BaseEvent() { 10637 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { 10638 data: {} 10639 }; 10640 babelHelpers.classCallCheck(this, BaseEvent); 10641 this.type = ''; 10642 this.data = null; 10643 this.target = null; 10644 this.compatData = null; 10645 this.defaultPrevented = false; 10646 this.immediatePropagationStopped = false; 10647 this.errors = []; 10648 this.setData(options.data); 10649 this.setCompatData(options.compatData); 10650 } 10651 10652 babelHelpers.createClass(BaseEvent, [{ 10653 key: "getType", 10654 10655 /** 10656 * Returns the name of the event 10657 * @returns {string} 10658 */ 10659 value: function getType() { 10660 return this.type; 10661 } 10662 /** 10663 * 10664 * @param {string} type 10665 */ 10666 10667 }, { 10668 key: "setType", 10669 value: function setType(type) { 10670 if (Type.isStringFilled(type)) { 10671 this.type = type; 10672 } 10673 10674 return this; 10675 } 10676 /** 10677 * Returns an event data 10678 */ 10679 10680 }, { 10681 key: "getData", 10682 value: function getData() { 10683 return this.data; 10684 } 10685 /** 10686 * Sets an event data 10687 * @param data 10688 */ 10689 10690 }, { 10691 key: "setData", 10692 value: function setData(data) { 10693 if (!Type.isUndefined(data)) { 10694 this.data = data; 10695 } 10696 10697 return this; 10698 } 10699 /** 10700 * Returns arguments for BX.addCustomEvent handlers (deprecated). 10701 * @returns {array | null} 10702 */ 10703 10704 }, { 10705 key: "getCompatData", 10706 value: function getCompatData() { 10707 return this.compatData; 10708 } 10709 /** 10710 * Sets arguments for BX.addCustomEvent handlers (deprecated) 10711 * @param data 10712 */ 10713 10714 }, { 10715 key: "setCompatData", 10716 value: function setCompatData(data) { 10717 if (Type.isArrayLike(data)) { 10718 this.compatData = data; 10719 } 10720 10721 return this; 10722 } 10723 /** 10724 * Sets a event target 10725 * @param target 10726 */ 10727 10728 }, { 10729 key: "setTarget", 10730 value: function setTarget(target) { 10731 this.target = target; 10732 return this; 10733 } 10734 /** 10735 * Returns a event target 10736 */ 10737 10738 }, { 10739 key: "getTarget", 10740 value: function getTarget() { 10741 return this.target; 10742 } 10743 /** 10744 * Returns an array of event errors 10745 * @returns {[]} 10746 */ 10747 10748 }, { 10749 key: "getErrors", 10750 value: function getErrors() { 10751 return this.errors; 10752 } 10753 /** 10754 * Adds an error of the event. 10755 * Event listeners can prevent emitter's default action and set the reason of this behavior. 10756 * @param error 10757 */ 10758 10759 }, { 10760 key: "setError", 10761 value: function setError(error) { 10762 if (BaseError.isError(error)) { 10763 this.errors.push(error); 10764 } 10765 } 10766 /** 10767 * Prevents default action 10768 */ 10769 10770 }, { 10771 key: "preventDefault", 10772 value: function preventDefault() { 10773 this.defaultPrevented = true; 10774 } 10775 /** 10776 * Checks that is default action prevented 10777 * @return {boolean} 10778 */ 10779 10780 }, { 10781 key: "isDefaultPrevented", 10782 value: function isDefaultPrevented() { 10783 return this.defaultPrevented; 10784 } 10785 /** 10786 * Stops event immediate propagation 10787 */ 10788 10789 }, { 10790 key: "stopImmediatePropagation", 10791 value: function stopImmediatePropagation() { 10792 this.immediatePropagationStopped = true; 10793 } 10794 /** 10795 * Checks that is immediate propagation stopped 10796 * @return {boolean} 10797 */ 10798 10799 }, { 10800 key: "isImmediatePropagationStopped", 10801 value: function isImmediatePropagationStopped() { 10802 return this.immediatePropagationStopped; 10803 } 10804 }], [{ 10805 key: "create", 10806 value: function create(options) { 10807 return new this(options); 10808 } 10809 }]); 10810 return BaseEvent; 10811 }(); 10812 10813 var EventStore = 10814 /*#__PURE__*/ 10815 function () { 10816 function EventStore() { 10817 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 10818 babelHelpers.classCallCheck(this, EventStore); 10819 this.defaultMaxListeners = Type.isNumber(options.defaultMaxListeners) ? options.defaultMaxListeners : 10; 10820 this.eventStore = new WeakMap(); 10821 } 10822 10823 babelHelpers.createClass(EventStore, [{ 10824 key: "add", 10825 value: function add(target) { 10826 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 10827 var record = this.getRecordScheme(); 10828 10829 if (Type.isNumber(options.maxListeners)) { 10830 record.maxListeners = options.maxListeners; 10831 } 10832 10833 this.eventStore.set(target, record); 10834 return record; 10835 } 10836 }, { 10837 key: "get", 10838 value: function get(target) { 10839 return this.eventStore.get(target); 10840 } 10841 }, { 10842 key: "getOrAdd", 10843 value: function getOrAdd(target) { 10844 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 10845 return this.get(target) || this.add(target, options); 10846 } 10847 }, { 10848 key: "delete", 10849 value: function _delete(context) { 10850 this.eventStore.delete(context); 10851 } 10852 }, { 10853 key: "getRecordScheme", 10854 value: function getRecordScheme() { 10855 return { 10856 eventsMap: new Map(), 10857 onceMap: new Map(), 10858 maxListeners: this.getDefaultMaxListeners(), 10859 eventsMaxListeners: new Map() 10860 }; 10861 } 10862 }, { 10863 key: "getDefaultMaxListeners", 10864 value: function getDefaultMaxListeners() { 10865 return this.defaultMaxListeners; 10866 } 10867 }]); 10868 return EventStore; 10869 }(); 10870 10871 var WarningStore = 10872 /*#__PURE__*/ 10873 function () {
10874 function WarningStore() { 10875 babelHelpers.classCallCheck(this, WarningStore); 10876 this.warnings = new Map(); 10877 this.printDelayed = Runtime.debounce(this.print.bind(this), 500); 10878 } 10879 10880 babelHelpers.createClass(WarningStore, [{ 10881 key: "add", 10882 value: function add(target, eventName, listeners) { 10883 var contextWarnings = this.warnings.get(target); 10884 10885 if (!contextWarnings) { 10886 contextWarnings = Object.create(null); 10887 this.warnings.set(target, contextWarnings); 10888 } 10889 10890 if (!contextWarnings[eventName]) { 10891 contextWarnings[eventName] = {}; 10892 } 10893 10894 contextWarnings[eventName].size = listeners.size; 10895 10896 if (!Type.isArray(contextWarnings[eventName].errors)) { 10897 contextWarnings[eventName].errors = []; 10898 } 10899 10900 contextWarnings[eventName].errors.push(new Error()); 10901 } 10902 }, { 10903 key: "print", 10904 value: function print() { 10905 var _iteratorNormalCompletion = true; 10906 var _didIteratorError = false; 10907 var _iteratorError = undefined; 10908 10909 try { 10910 for (var _iterator = this.warnings[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { 10911 var _step$value = babelHelpers.slicedToArray(_step.value, 2), 10912 target = _step$value[0], 10913 warnings = _step$value[1]; 10914
10915 for (var eventName in warnings) { 10916 console.groupCollapsed('Possible BX.Event.EventEmitter memory leak detected. ' + warnings[eventName].size + ' "' + eventName + '" listeners added. ' + 'Use emitter.setMaxListeners() to increase limit.'); 10917 console.dir(warnings[eventName].errors); 10918 console.groupEnd(); 10919 } 10920 } 10921 } catch (err) { 10922 _didIteratorError = true; 10923 _iteratorError = err; 10924 } finally { 10925 try { 10926 if (!_iteratorNormalCompletion && _iterator.return != null) { 10927 _iterator.return(); 10928 } 10929 } finally { 10930 if (_didIteratorError) { 10931 throw _iteratorError; 10932 } 10933 } 10934 } 10935 10936 this.clear(); 10937 } 10938 }, { 10939 key: "clear", 10940 value: function clear() { 10941 this.warnings.clear(); 10942 } 10943 }, { 10944 key: "printDelayed", 10945 value: function printDelayed() {} 10946 }]); 10947 return WarningStore; 10948 }(); 10949 10950 var eventStore = new EventStore({ 10951 defaultMaxListeners: 10 10952 }); 10953 var warningStore = new WarningStore(); 10954 var aliasStore = new Map(); 10955 var globalTarget = { 10956 GLOBAL_TARGET: 'GLOBAL_TARGET' // this key only for debugging purposes 10957 10958 }; 10959 eventStore.add(globalTarget, { 10960 maxListeners: 25 10961 }); 10962 var isEmitterProperty = Symbol.for('BX.Event.EventEmitter.isEmitter'); 10963 var namespaceProperty = Symbol('namespaceProperty'); 10964 var targetProperty = Symbol('targetProperty'); 10965 10966 var EventEmitter = 10967 /*#__PURE__*/ 10968 function () { 10969 /** @private */ 10970 function EventEmitter() { 10971 var _this = this; 10972 10973 babelHelpers.classCallCheck(this, EventEmitter); 10974 this[targetProperty] = null; 10975 this[namespaceProperty] = null; 10976 this[isEmitterProperty] = true; 10977 var target = this; 10978 10979 if (Object.getPrototypeOf(this) === EventEmitter.prototype && arguments.length > 0) //new EventEmitter(obj) case 10980 { 10981 if (!Type.isObject(arguments.length <= 0 ? undefined : arguments[0])) { 10982 throw new TypeError("The \"target\" argument must be an object."); 10983 } 10984 10985 target = arguments.length <= 0 ? undefined : arguments[0]; 10986 this.setEventNamespace(arguments.length <= 1 ? undefined : arguments[1]); 10987 } 10988 10989 this[targetProperty] = target; 10990 setTimeout(function () { 10991 if (_this.getEventNamespace() === null) { 10992 console.warn('The instance of BX.Event.EventEmitter is supposed to have an event namespace. ' + 'Use emitter.setEventNamespace() to make events more unique.'); 10993 } 10994 }, 500); 10995 } 10996 /** 10997 * Makes a target observable 10998 * @param {object} target 10999 * @param {string} namespace 11000 */ 11001 11002 11003 babelHelpers.createClass(EventEmitter, [{ 11004 key: "setEventNamespace", 11005 value: function setEventNamespace(namespace) { 11006 if (Type.isStringFilled(namespace)) { 11007 this[namespaceProperty] = namespace; 11008 } 11009 } 11010 }, { 11011 key: "getEventNamespace", 11012 value: function getEventNamespace() { 11013 return this[namespaceProperty]; 11014 } 11015 /** 11016 * Subscribes listener on specified global event 11017 * @param {object} target 11018 * @param {string} eventName 11019 * @param {Function<BaseEvent>} listener 11020 * @param {object} options 11021 */ 11022 11023 }, { 11024 key: "subscribe", 11025 11026 /** 11027 * Subscribes a listener on a specified event 11028 * @param {string} eventName 11029 * @param {Function<BaseEvent>} listener 11030 * @return {this} 11031 */ 11032 value: function subscribe(eventName, listener) { 11033 EventEmitter.subscribe(this, eventName, listener); 11034 return this; 11035 } 11036 /** 11037 * 11038 * @param {object} options 11039 * @param {object} [aliases] 11040 * @param {boolean} [compatMode=false] 11041 */ 11042 11043 }, { 11044 key: "subscribeFromOptions", 11045 value: function subscribeFromOptions(options, aliases, compatMode) { 11046 var _this2 = this; 11047 11048 if (!Type.isPlainObject(options)) { 11049 return; 11050 } 11051 11052 aliases = Type.isPlainObject(aliases) ? EventEmitter.normalizeAliases(aliases) : {}; 11053 Object.keys(options).forEach(function (eventName) { 11054 var listener = options[eventName]; 11055 11056 if (!Type.isFunction(listener)) { 11057 throw new TypeError("The \"listener\" argument must be of type Function. Received type ".concat(babelHelpers.typeof(listener), ".")); 11058 } 11059 11060 eventName = EventEmitter.normalizeEventName(eventName); 11061 11062 if (aliases[eventName]) { 11063 var actualName = aliases[eventName].eventName; 11064 EventEmitter.subscribe(_this2, actualName, listener, { 11065 compatMode: compatMode !== false 11066 }); 11067 } else { 11068 EventEmitter.subscribe(_this2, eventName, listener, { 11069 compatMode: compatMode === true 11070 }); 11071 } 11072 }); 11073 } 11074 /** 11075 * Subscribes a listener that is called at 11076 * most once for a specified event. 11077 * @param {object} target 11078 * @param {string} eventName 11079 * @param {Function<BaseEvent>} listener 11080 */ 11081 11082 }, { 11083 key: "subscribeOnce", 11084 11085 /** 11086 * Subscribes a listener that is called at most once for a specified event. 11087 * @param {string} eventName 11088 * @param {Function<BaseEvent>} listener 11089 * @return {this} 11090 */ 11091 value: function subscribeOnce(eventName, listener) { 11092 EventEmitter.subscribeOnce(this, eventName, listener); 11093 return this; 11094 } 11095 /** 11096 * Unsubscribes an event listener 11097 * @param {object} target 11098 * @param {string} eventName 11099 * @param {Function<BaseEvent>} listener 11100 * @param options 11101 */ 11102 11103 }, { 11104 key: "unsubscribe", 11105 11106 /** 11107 * Unsubscribes an event listener 11108 * @param {string} eventName 11109 * @param {Function<BaseEvent>} listener 11110 * @return {this} 11111 */ 11112 value: function unsubscribe(eventName, listener) { 11113 EventEmitter.unsubscribe(this, eventName, listener); 11114 return this; 11115 } 11116 /** 11117 * Unsubscribes all event listeners 11118 * @param {object} target 11119 * @param {string} eventName 11120 * @param options 11121 */ 11122 11123 }, { 11124 key: "unsubscribeAll", 11125 11126 /** 11127 * Unsubscribes all event listeners 11128 * @param {string} [eventName] 11129 */ 11130 value: function unsubscribeAll(eventName) { 11131 EventEmitter.unsubscribeAll(this, eventName); 11132 } 11133 /** 11134 * 11135 * @param {object} target 11136 * @param {string} eventName 11137 * @param {BaseEvent | any} event 11138 * @param {object} options 11139 * @returns {Array} 11140 */ 11141 11142 }, { 11143 key: "emit", 11144 11145 /** 11146 * Emits specified event with specified event object 11147 * @param {string} eventName 11148 * @param {BaseEvent | any} event 11149 * @return {this} 11150 */ 11151 value: function emit(eventName, event) { 11152 EventEmitter.emit(this, eventName, event); 11153 return this; 11154 } 11155 /** 11156 * Emits global event and returns a promise that is resolved when 11157 * all promise returned from event handlers are resolved, 11158 * or rejected when at least one of the returned promise is rejected. 11159 * Importantly. You can return any value from synchronous handlers, not just promise 11160 * @param {object} target 11161 * @param {string} eventName 11162 * @param {BaseEvent | any} event 11163 * @return {Promise<Array>} 11164 */ 11165 11166 }, { 11167 key: "emitAsync", 11168 11169 /** 11170 * Emits event and returns a promise that is resolved when 11171 * all promise returned from event handlers are resolved, 11172 * or rejected when at least one of the returned promise is rejected. 11173 * Importantly. You can return any value from synchronous handlers, not just promise 11174 * @param {string} eventName 11175 * @param {BaseEvent|any} event 11176 * @return {Promise<Array>} 11177 */ 11178 value: function emitAsync(eventName, event) { 11179 return EventEmitter.emitAsync(this, eventName, event); 11180 } 11181 /** 11182 * @private 11183 * @param {object} target 11184 * @param {string} eventName 11185 * @param {BaseEvent|any} event 11186 * @returns {BaseEvent} 11187 */ 11188 11189 }, { 11190 key: "setMaxListeners", 11191 11192 /** 11193 * Sets max events listeners count 11194 * this.setMaxListeners(10) - sets the default value for all events
11195 * this.setMaxListeners("onClose", 10) sets the value for onClose event 11196 * @return {this} 11197 * @param args 11198 */ 11199 value: function setMaxListeners() { 11200 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 11201 args[_key] = arguments[_key]; 11202 } 11203 11204 EventEmitter.setMaxListeners.apply(EventEmitter, [this].concat(args)); 11205 return this; 11206 } 11207 /** 11208 * Returns max event listeners count 11209 * @param {object} target 11210 * @param {string} [eventName] 11211 * @returns {number} 11212 */ 11213 11214 }, { 11215 key: "getMaxListeners", 11216 11217 /** 11218 * Returns max event listeners count 11219 * @param {string} [eventName] 11220 * @returns {number} 11221 */ 11222 value: function getMaxListeners(eventName) { 11223 return EventEmitter.getMaxListeners(this, eventName); 11224 } 11225 /** 11226 * Adds or subtracts max listeners count 11227 * Event.EventEmitter.addMaxListeners() - adds one max listener for all events of global target 11228 * Event.EventEmitter.addMaxListeners(3) - adds three max listeners for all events of global target 11229 * Event.EventEmitter.addMaxListeners(-1) - subtracts one max listener for all events of global target 11230 * Event.EventEmitter.addMaxListeners('onClose') - adds one max listener for onClose event of global target 11231 * Event.EventEmitter.addMaxListeners('onClose', 2) - adds two max listeners for onClose event of global target 11232 * Event.EventEmitter.addMaxListeners('onClose', -1) - subtracts one max listener for onClose event of global target 11233 * 11234 * Event.EventEmitter.addMaxListeners(obj) - adds one max listener for all events of 'obj' target 11235 * Event.EventEmitter.addMaxListeners(obj, 3) - adds three max listeners for all events of 'obj' target 11236 * Event.EventEmitter.addMaxListeners(obj, -1) - subtracts one max listener for all events of 'obj' target 11237 * Event.EventEmitter.addMaxListeners(obj, 'onClose') - adds one max listener for onClose event of 'obj' target 11238 * Event.EventEmitter.addMaxListeners(obj, 'onClose', 2) - adds two max listeners for onClose event of 'obj' target 11239 * Event.EventEmitter.addMaxListeners(obj, 'onClose', -1) - subtracts one max listener for onClose event of 'obj' target 11240 * @param args 11241 * @returns {number} 11242 */ 11243 11244 }, { 11245 key: "incrementMaxListeners", 11246 11247 /** 11248 * Increases max listeners count 11249 * this.incrementMaxListeners() - adds one max listener for all events 11250 * this.incrementMaxListeners(3) - adds three max listeners for all events 11251 * this.incrementMaxListeners('onClose') - adds one max listener for onClose event 11252 * this.incrementMaxListeners('onClose', 2) - adds two max listeners for onClose event 11253 */ 11254 value: function incrementMaxListeners() { 11255 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 11256 args[_key2] = arguments[_key2]; 11257 } 11258 11259 return EventEmitter.incrementMaxListeners.apply(EventEmitter, [this].concat(args)); 11260 } 11261 /** 11262 * Decreases max listeners count 11263 * 11264 * Event.EventEmitter.decrementMaxListeners() - subtracts one max listener for all events of global target 11265 * Event.EventEmitter.decrementMaxListeners(3) - subtracts three max listeners for all events of global target 11266 * Event.EventEmitter.decrementMaxListeners('onClose') - subtracts one max listener for onClose event of global target 11267 * Event.EventEmitter.decrementMaxListeners('onClose', 2) - subtracts two max listeners for onClose event of global target 11268 * 11269 * Event.EventEmitter.decrementMaxListeners(obj) - subtracts one max listener for all events of 'obj' target 11270 * Event.EventEmitter.decrementMaxListeners(obj, 3) - subtracts three max listeners for all events of 'obj' target 11271 * Event.EventEmitter.decrementMaxListeners(obj, 'onClose') - subtracts one max listener for onClose event of 'obj' target 11272 * Event.EventEmitter.decrementMaxListeners(obj, 'onClose', 2) - subtracts two max listeners for onClose event of 'obj' target 11273 */ 11274 11275 }, { 11276 key: "decrementMaxListeners", 11277 11278 /** 11279 * Increases max listeners count 11280 * this.decrementMaxListeners() - subtracts one max listener for all events 11281 * this.decrementMaxListeners(3) - subtracts three max listeners for all events 11282 * this.decrementMaxListeners('onClose') - subtracts one max listener for onClose event 11283 * this.decrementMaxListeners('onClose', 2) - subtracts two max listeners for onClose event 11284 */ 11285 value: function decrementMaxListeners() { 11286 for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { 11287 args[_key3] = arguments[_key3]; 11288 } 11289 11290 return EventEmitter.decrementMaxListeners.apply(EventEmitter, [this].concat(args)); 11291 } 11292 /** 11293 * @private 11294 * @param {Array} args 11295 * @returns Array 11296 */ 11297 11298 }, { 11299 key: "getListeners", 11300 11301 /** 11302 * Gets listeners list for specified event 11303 * @param {string} eventName 11304 */ 11305 value: function getListeners(eventName) { 11306 return EventEmitter.getListeners(this, eventName); 11307 } 11308 /** 11309 * Returns a full event name with namespace 11310 * @param {string} eventName 11311 * @returns {string} 11312 */ 11313 11314 }, { 11315 key: "getFullEventName", 11316 value: function getFullEventName(eventName) { 11317 if (!Type.isStringFilled(eventName)) { 11318 throw new TypeError("The \"eventName\" argument must be a string."); 11319 } 11320 11321 return EventEmitter.makeFullEventName(this.getEventNamespace(), eventName); 11322 } 11323 /** 11324 * Registers aliases (old event names for BX.onCustomEvent) 11325 * @param aliases 11326 */ 11327 11328 }], [{ 11329 key: "makeObservable", 11330 value: function makeObservable(target, namespace) { 11331 if (!Type.isObject(target)) { 11332 throw new TypeError('The "target" argument must be an object.'); 11333 } 11334 11335 if (!Type.isStringFilled(namespace)) { 11336 throw new TypeError('The "namespace" must be an non-empty string.'); 11337 } 11338 11339 if (EventEmitter.isEventEmitter(target)) { 11340 throw new TypeError('The "target" is an event emitter already.'); 11341 } 11342 11343 var targetProto = Object.getPrototypeOf(target); 11344 var emitter = new EventEmitter(); 11345 emitter.setEventNamespace(namespace); 11346 Object.setPrototypeOf(emitter, targetProto); 11347 Object.setPrototypeOf(target, emitter); 11348 Object.getOwnPropertyNames(EventEmitter.prototype).forEach(function (method) {
11349 if (['constructor'].includes(method)) { 11350 return; 11351 } 11352 11353 emitter[method] = function () { 11354 for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { 11355 args[_key4] = arguments[_key4]; 11356 } 11357 11358 return EventEmitter.prototype[method].apply(target, args); 11359 }; 11360 }); 11361 } 11362 }, { 11363 key: "subscribe", 11364 value: function subscribe(target, eventName, listener, options) { 11365 if (Type.isString(target)) { 11366 options = listener; 11367 listener = eventName; 11368 eventName = target; 11369 target = this.GLOBAL_TARGET; 11370 } 11371 11372 if (!Type.isObject(target)) { 11373 throw new TypeError("The \"target\" argument must be an object."); 11374 } 11375 11376 eventName = this.normalizeEventName(eventName); 11377 11378 if (!Type.isStringFilled(eventName)) { 11379 throw new TypeError("The \"eventName\" argument must be a string."); 11380 } 11381 11382 if (!Type.isFunction(listener)) { 11383 throw new TypeError("The \"listener\" argument must be of type Function. Received type ".concat(babelHelpers.typeof(listener), ".")); 11384 } 11385 11386 options = Type.isPlainObject(options) ? options : {}; 11387 var fullEventName = this.resolveEventName(eventName, target, options.useGlobalNaming === true); 11388 11389 var _eventStore$getOrAdd = eventStore.getOrAdd(target), 11390 eventsMap = _eventStore$getOrAdd.eventsMap, 11391 onceMap = _eventStore$getOrAdd.onceMap; 11392 11393 var onceListeners = onceMap.get(fullEventName); 11394 var listeners = eventsMap.get(fullEventName); 11395 11396 if (listeners && listeners.has(listener) || onceListeners && onceListeners.has(listener)) { 11397 console.error("You cannot subscribe the same \"".concat(fullEventName, "\" event listener twice.")); 11398 } else { 11399 if (listeners) { 11400 listeners.set(listener, { 11401 listener: listener, 11402 options: options, 11403 sort: this.getNextSequenceValue() 11404 }); 11405 } else { 11406 listeners = new Map([[listener, { 11407 listener: listener, 11408 options: options, 11409 sort: this.getNextSequenceValue() 11410 }]]); 11411 eventsMap.set(fullEventName, listeners); 11412 } 11413 } 11414 11415 var maxListeners = this.getMaxListeners(target, eventName); 11416 11417 if (listeners.size > maxListeners) { 11418 warningStore.add(target, fullEventName, listeners); 11419 warningStore.printDelayed(); 11420 } 11421 } 11422 }, { 11423 key: "subscribeOnce", 11424 value: function subscribeOnce(target, eventName, listener) { 11425 var _this3 = this; 11426 11427 if (Type.isString(target)) { 11428 listener = eventName; 11429 eventName = target; 11430 target = this.GLOBAL_TARGET;
11431 } 11432 11433 if (!Type.isObject(target)) { 11434 throw new TypeError("The \"target\" argument must be an object."); 11435 } 11436 11437 eventName = this.normalizeEventName(eventName); 11438 11439 if (!Type.isStringFilled(eventName)) { 11440 throw new TypeError("The \"eventName\" argument must be a string."); 11441 } 11442 11443 if (!Type.isFunction(listener)) { 11444 throw new TypeError("The \"listener\" argument must be of type Function. Received type ".concat(babelHelpers.typeof(listener), ".")); 11445 } 11446 11447 var fullEventName = this.resolveEventName(eventName, target); 11448 11449 var _eventStore$getOrAdd2 = eventStore.getOrAdd(target), 11450 eventsMap = _eventStore$getOrAdd2.eventsMap, 11451 onceMap = _eventStore$getOrAdd2.onceMap; 11452 11453 var listeners = eventsMap.get(fullEventName); 11454 var onceListeners = onceMap.get(fullEventName); 11455 11456 if (listeners && listeners.has(listener) || onceListeners && onceListeners.has(listener)) { 11457 console.error("You cannot subscribe the same \"".concat(fullEventName, "\" event listener twice.")); 11458 } else { 11459 var once = function once() { 11460 _this3.unsubscribe(target, eventName, once); 11461 11462 onceListeners.delete(listener); 11463 listener.apply(void 0, arguments); 11464 }; 11465 11466 if (onceListeners) { 11467 onceListeners.set(listener, once); 11468 } else { 11469 onceListeners = new Map([[listener, once]]); 11470 onceMap.set(fullEventName, onceListeners); 11471 } 11472 11473 this.subscribe(target, eventName, once); 11474 } 11475 } 11476 }, { 11477 key: "unsubscribe", 11478 value: function unsubscribe(target, eventName, listener, options) { 11479 if (Type.isString(target)) { 11480 listener = eventName; 11481 eventName = target; 11482 target = this.GLOBAL_TARGET;
11483 } 11484 11485 eventName = this.normalizeEventName(eventName); 11486 11487 if (!Type.isStringFilled(eventName)) { 11488 throw new TypeError("The \"eventName\" argument must be a string."); 11489 } 11490 11491 if (!Type.isFunction(listener)) { 11492 throw new TypeError("The \"listener\" argument must be of type Function. Received type ".concat(typeof event === "undefined" ? "undefined" : babelHelpers.typeof(event), ".")); 11493 } 11494 11495 options = Type.isPlainObject(options) ? options : {}; 11496 var fullEventName = this.resolveEventName(eventName, target, options.useGlobalNaming === true); 11497 var targetInfo = eventStore.get(target); 11498 var listeners = targetInfo && targetInfo.eventsMap.get(fullEventName); 11499 var onceListeners = targetInfo && targetInfo.onceMap.get(fullEventName); 11500 11501 if (listeners) { 11502 listeners.delete(listener); 11503 } 11504 11505 if (onceListeners) { 11506 var once = onceListeners.get(listener); 11507 11508 if (once) { 11509 onceListeners.delete(listener); 11510 listeners.delete(once); 11511 } 11512 } 11513 } 11514 }, { 11515 key: "unsubscribeAll", 11516 value: function unsubscribeAll(target, eventName, options) { 11517 if (Type.isString(target)) { 11518 eventName = target; 11519 target = this.GLOBAL_TARGET;
11520 } 11521 11522 if (Type.isStringFilled(eventName)) { 11523 var targetInfo = eventStore.get(target); 11524 11525 if (targetInfo) { 11526 options = Type.isPlainObject(options) ? options : {}; 11527 var fullEventName = this.resolveEventName(eventName, target, options.useGlobalNaming === true); 11528 targetInfo.eventsMap.delete(fullEventName); 11529 targetInfo.onceMap.delete(fullEventName); 11530 } 11531 } else if (Type.isNil(eventName)) { 11532 if (target === this.GLOBAL_TARGET) { 11533 console.error('You cannot unsubscribe all global listeners.'); 11534 } else { 11535 eventStore.delete(target); 11536 } 11537 } 11538 } 11539 }, { 11540 key: "emit", 11541 value: function emit(target, eventName, event, options) { 11542 if (Type.isString(target)) { 11543 options = event; 11544 event = eventName; 11545 eventName = target; 11546 target = this.GLOBAL_TARGET; 11547 } 11548 11549 if (!Type.isObject(target)) { 11550 throw new TypeError("The \"target\" argument must be an object."); 11551 } 11552 11553 eventName = this.normalizeEventName(eventName); 11554 11555 if (!Type.isStringFilled(eventName)) { 11556 throw new TypeError("The \"eventName\" argument must be a string."); 11557 } 11558 11559 options = Type.isPlainObject(options) ? options : {}; 11560 var fullEventName = this.resolveEventName(eventName, target, options.useGlobalNaming === true); 11561 var globalEvents = eventStore.get(this.GLOBAL_TARGET); 11562 var globalListeners = globalEvents && globalEvents.eventsMap.get(fullEventName) || new Map(); 11563 var targetListeners = new Set(); 11564 11565 if (target !== this.GLOBAL_TARGET) { 11566 var targetEvents = eventStore.get(target); 11567 targetListeners = targetEvents && targetEvents.eventsMap.get(fullEventName) || new Map(); 11568 } 11569 11570 var listeners = [].concat(babelHelpers.toConsumableArray(globalListeners.values()), babelHelpers.toConsumableArray(targetListeners.values())); 11571 listeners.sort(function (a, b) { 11572 return a.sort - b.sort; 11573 }); 11574 var preparedEvent = this.prepareEvent(target, fullEventName, event); 11575 var result = []; 11576 11577 for (var i = 0; i < listeners.length; i++) { 11578 if (preparedEvent.isImmediatePropagationStopped()) { 11579 break; 11580 } 11581 11582 var _listeners$i = listeners[i], 11583 listener = _listeners$i.listener, 11584 listenerOptions = _listeners$i.options; //A previous listener could remove a current listener. 11585 11586 if (globalListeners.has(listener) || targetListeners.has(listener)) { 11587 var listenerResult = void 0; 11588 11589 if (listenerOptions.compatMode) { 11590 var params = []; 11591 var compatData = preparedEvent.getCompatData(); 11592 11593 if (compatData !== null) { 11594 params = options.cloneData === true ? Runtime.clone(compatData) : compatData; 11595 } else { 11596 params = [preparedEvent]; 11597 } 11598 11599 var context = Type.isUndefined(options.thisArg) ? target : options.thisArg; 11600 listenerResult = listener.apply(context, params); 11601 } else { 11602 listenerResult = Type.isUndefined(options.thisArg) ? listener(preparedEvent) : listener.call(options.thisArg, preparedEvent); 11603 } 11604 11605 result.push(listenerResult); 11606 } 11607 } 11608 11609 return result; 11610 } 11611 }, { 11612 key: "emitAsync", 11613 value: function emitAsync(target, eventName, event) { 11614 if (Type.isString(target)) { 11615 event = eventName; 11616 eventName = target; 11617 target = this.GLOBAL_TARGET;
11618 } 11619 11620 return Promise.all(this.emit(target, eventName, event)); 11621 } 11622 }, { 11623 key: "prepareEvent", 11624 value: function prepareEvent(target, eventName, event) { 11625 var preparedEvent = event; 11626 11627 if (!(event instanceof BaseEvent)) { 11628 preparedEvent = new BaseEvent(); 11629 preparedEvent.setData(event); 11630 } 11631 11632 preparedEvent.setTarget(this.isEventEmitter(target) ? target[targetProperty] : target); 11633 preparedEvent.setType(eventName); 11634 return preparedEvent; 11635 } 11636 /** 11637 * @private 11638 * @returns {number} 11639 */ 11640 11641 }, { 11642 key: "getNextSequenceValue", 11643 value: function getNextSequenceValue() { 11644 return this.sequenceValue++; 11645 } 11646 /** 11647 * Sets max global events listeners count 11648 * Event.EventEmitter.setMaxListeners(10) - sets the default value for all events (global target) 11649 * Event.EventEmitter.setMaxListeners("onClose", 10) - sets the value for onClose event (global target) 11650 * Event.EventEmitter.setMaxListeners(obj, 10) - sets the default value for all events (obj target) 11651 * Event.EventEmitter.setMaxListeners(obj, "onClose", 10); - sets the value for onClose event (obj target) 11652 * @return {void} 11653 * @param args 11654 */ 11655 11656 }, { 11657 key: "setMaxListeners", 11658 value: function setMaxListeners() { 11659 var target = this.GLOBAL_TARGET;
11660 var eventName = null; 11661 var count = undefined; 11662 11663 for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { 11664 args[_key5] = arguments[_key5]; 11665 } 11666 11667 if (args.length === 1) { 11668 count = args[0]; 11669 } else if (args.length === 2) { 11670 if (Type.isString(args[0])) { 11671 eventName = args[0]; 11672 count = args[1]; 11673 } else { 11674 target = args[0]; 11675 count = args[1]; 11676 } 11677 } else if (args.length >= 3) { 11678 target = args[0]; 11679 eventName = args[1]; 11680 count = args[2]; 11681 } 11682 11683 if (!Type.isObject(target)) { 11684 throw new TypeError("The \"target\" argument must be an object."); 11685 } 11686 11687 if (eventName !== null && !Type.isStringFilled(eventName)) { 11688 throw new TypeError("The \"eventName\" argument must be a string."); 11689 } 11690 11691 if (!Type.isNumber(count) || count < 0) { 11692 throw new TypeError("The value of \"count\" is out of range. It must be a non-negative number. Received ".concat(count, ".")); 11693 } 11694 11695 var targetInfo = eventStore.getOrAdd(target); 11696 11697 if (Type.isStringFilled(eventName)) { 11698 var fullEventName = this.resolveEventName(eventName, target); 11699 targetInfo.eventsMaxListeners.set(fullEventName, count); 11700 } else { 11701 targetInfo.maxListeners = count; 11702 } 11703 } 11704 }, { 11705 key: "getMaxListeners", 11706 value: function getMaxListeners(target, eventName) { 11707 if (Type.isString(target)) { 11708 eventName = target; 11709 target = this.GLOBAL_TARGET;
11710 } else if (Type.isNil(target)) { 11711 target = this.GLOBAL_TARGET; 11712 } 11713 11714 if (!Type.isObject(target)) { 11715 throw new TypeError("The \"target\" argument must be an object."); 11716 } 11717 11718 var targetInfo = eventStore.get(target); 11719 11720 if (targetInfo) { 11721 var maxListeners = targetInfo.maxListeners; 11722 11723 if (Type.isStringFilled(eventName)) { 11724 var fullEventName = this.resolveEventName(eventName, target); 11725 maxListeners = targetInfo.eventsMaxListeners.get(fullEventName) || maxListeners; 11726 } 11727 11728 return maxListeners; 11729 } 11730 11731 return this.DEFAULT_MAX_LISTENERS; 11732 } 11733 }, { 11734 key: "addMaxListeners", 11735 value: function addMaxListeners() { 11736 var _this$destructMaxList = this.destructMaxListenersArgs.apply(this, arguments), 11737 _this$destructMaxList2 = babelHelpers.slicedToArray(_this$destructMaxList, 3), 11738 target = _this$destructMaxList2[0], 11739 eventName = _this$destructMaxList2[1], 11740 increment = _this$destructMaxList2[2]; 11741 11742 var maxListeners = Math.max(this.getMaxListeners(target, eventName) + increment, 0); 11743 11744 if (Type.isStringFilled(eventName)) { 11745 EventEmitter.setMaxListeners(target, eventName, maxListeners); 11746 } else { 11747 EventEmitter.setMaxListeners(target, maxListeners); 11748 } 11749 11750 return maxListeners; 11751 } 11752 /** 11753 * Increases max listeners count 11754 * 11755 * Event.EventEmitter.incrementMaxListeners() - adds one max listener for all events of global target 11756 * Event.EventEmitter.incrementMaxListeners(3) - adds three max listeners for all events of global target 11757 * Event.EventEmitter.incrementMaxListeners('onClose') - adds one max listener for onClose event of global target 11758 * Event.EventEmitter.incrementMaxListeners('onClose', 2) - adds two max listeners for onClose event of global target 11759 * 11760 * Event.EventEmitter.incrementMaxListeners(obj) - adds one max listener for all events of 'obj' target 11761 * Event.EventEmitter.incrementMaxListeners(obj, 3) - adds three max listeners for all events of 'obj' target 11762 * Event.EventEmitter.incrementMaxListeners(obj, 'onClose') - adds one max listener for onClose event of 'obj' target 11763 * Event.EventEmitter.incrementMaxListeners(obj, 'onClose', 2) - adds two max listeners for onClose event of 'obj' target 11764 */ 11765 11766 }, { 11767 key: "incrementMaxListeners", 11768 value: function incrementMaxListeners() { 11769 var _this$destructMaxList3 = this.destructMaxListenersArgs.apply(this, arguments), 11770 _this$destructMaxList4 = babelHelpers.slicedToArray(_this$destructMaxList3, 3), 11771 target = _this$destructMaxList4[0], 11772 eventName = _this$destructMaxList4[1], 11773 increment = _this$destructMaxList4[2]; 11774 11775 return this.addMaxListeners(target, eventName, Math.abs(increment)); 11776 } 11777 }, { 11778 key: "decrementMaxListeners", 11779 value: function decrementMaxListeners() { 11780 var _this$destructMaxList5 = this.destructMaxListenersArgs.apply(this, arguments), 11781 _this$destructMaxList6 = babelHelpers.slicedToArray(_this$destructMaxList5, 3), 11782 target = _this$destructMaxList6[0], 11783 eventName = _this$destructMaxList6[1], 11784 increment = _this$destructMaxList6[2]; 11785 11786 return this.addMaxListeners(target, eventName, -Math.abs(increment)); 11787 } 11788 }, { 11789 key: "destructMaxListenersArgs", 11790 value: function destructMaxListenersArgs() { 11791 var eventName = null; 11792 var increment = 1; 11793 var target = this.GLOBAL_TARGET;
11794 11795 for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) { 11796 args[_key6] = arguments[_key6]; 11797 } 11798 11799 if (args.length === 1) { 11800 if (Type.isNumber(args[0])) { 11801 increment = args[0]; 11802 } else if (Type.isString(args[0])) { 11803 eventName = args[0]; 11804 } else { 11805 target = args[0]; 11806 } 11807 } else if (args.length === 2) { 11808 if (Type.isString(args[0])) { 11809 eventName = args[0]; 11810 increment = args[1]; 11811 } else if (Type.isString(args[1])) { 11812 target = args[0]; 11813 eventName = args[1]; 11814 } else { 11815 target = args[0]; 11816 increment = args[1]; 11817 } 11818 } else if (args.length >= 3) { 11819 target = args[0]; 11820 eventName = args[1]; 11821 increment = args[2]; 11822 } 11823 11824 if (!Type.isObject(target)) { 11825 throw new TypeError("The \"target\" argument must be an object."); 11826 } 11827 11828 if (eventName !== null && !Type.isStringFilled(eventName)) { 11829 throw new TypeError("The \"eventName\" argument must be a string."); 11830 } 11831 11832 if (!Type.isNumber(increment)) { 11833 throw new TypeError("The value of \"increment\" must be a number."); 11834 } 11835 11836 return [target, eventName, increment]; 11837 } 11838 /** 11839 * Gets listeners list for a specified event 11840 * @param {object} target 11841 * @param {string} eventName 11842 */ 11843 11844 }, { 11845 key: "getListeners", 11846 value: function getListeners(target, eventName) { 11847 if (Type.isString(target)) { 11848 eventName = target; 11849 target = this.GLOBAL_TARGET;
11850 } 11851 11852 if (!Type.isObject(target)) { 11853 throw new TypeError("The \"target\" argument must be an object."); 11854 } 11855 11856 eventName = this.normalizeEventName(eventName); 11857 11858 if (!Type.isStringFilled(eventName)) { 11859 throw new TypeError("The \"eventName\" argument must be a string."); 11860 } 11861 11862 var targetInfo = eventStore.get(target); 11863 11864 if (!targetInfo) { 11865 return new Map(); 11866 } 11867 11868 var fullEventName = this.resolveEventName(eventName, target); 11869 return targetInfo.eventsMap.get(fullEventName) || new Map(); 11870 } 11871 }, { 11872 key: "registerAliases", 11873 value: function registerAliases(aliases) { 11874 aliases = this.normalizeAliases(aliases); 11875 Object.keys(aliases).forEach(function (alias) { 11876 aliasStore.set(alias, { 11877 eventName: aliases[alias].eventName, 11878 namespace: aliases[alias].namespace 11879 }); 11880 }); 11881 EventEmitter.mergeEventAliases(aliases); 11882 } 11883 /** 11884 * @private 11885 * @param aliases 11886 */ 11887 11888 }, { 11889 key: "normalizeAliases", 11890 value: function normalizeAliases(aliases) { 11891 if (!Type.isPlainObject(aliases)) { 11892 throw new TypeError("The \"aliases\" argument must be an object."); 11893 } 11894 11895 var result = Object.create(null); 11896 11897 for (var _alias in aliases) { 11898 if (!Type.isStringFilled(_alias)) { 11899 throw new TypeError("The alias must be an non-empty string."); 11900 } 11901 11902 var options = aliases[_alias]; 11903 11904 if (!options || !Type.isStringFilled(options.eventName) || !Type.isStringFilled(options.namespace)) { 11905 throw new TypeError("The alias options must set the \"eventName\" and the \"namespace\"."); 11906 } 11907 11908 _alias = this.normalizeEventName(_alias); 11909 result[_alias] = { 11910 eventName: options.eventName, 11911 namespace: options.namespace 11912 }; 11913 } 11914 11915 return result; 11916 } 11917 /** 11918 * @private 11919 */ 11920 11921 }, { 11922 key: "mergeEventAliases", 11923 value: function mergeEventAliases(aliases) { 11924 var _this4 = this; 11925 11926 var globalEvents = eventStore.get(this.GLOBAL_TARGET); 11927 11928 if (!globalEvents) { 11929 return; 11930 } 11931 11932 Object.keys(aliases).forEach(function (alias) { 11933 var options = aliases[alias]; 11934 alias = _this4.normalizeEventName(alias); 11935 11936 var fullEventName = _this4.makeFullEventName(options.namespace, options.eventName); 11937 11938 var aliasListeners = globalEvents.eventsMap.get(alias); 11939 11940 if (aliasListeners) { 11941 var listeners = globalEvents.eventsMap.get(fullEventName) || new Map(); 11942 globalEvents.eventsMap.set(fullEventName, new Map([].concat(babelHelpers.toConsumableArray(listeners), babelHelpers.toConsumableArray(aliasListeners)))); 11943 globalEvents.eventsMap.delete(alias); 11944 } 11945 11946 var aliasOnceListeners = globalEvents.onceMap.get(alias); 11947 11948 if (aliasOnceListeners) { 11949 var onceListeners = globalEvents.onceMap.get(fullEventName) || new Map(); 11950 globalEvents.onceMap.set(fullEventName, new Map([].concat(babelHelpers.toConsumableArray(onceListeners), babelHelpers.toConsumableArray(aliasOnceListeners)))); 11951 globalEvents.onceMap.delete(alias); 11952 } 11953 11954 var aliasMaxListeners = globalEvents.eventsMaxListeners.get(alias); 11955 11956 if (aliasMaxListeners) { 11957 var eventMaxListeners = globalEvents.eventsMaxListeners.get(fullEventName) || 0; 11958 globalEvents.eventsMaxListeners.set(fullEventName, Math.max(eventMaxListeners, aliasMaxListeners)); 11959 globalEvents.eventsMaxListeners.delete(alias); 11960 } 11961 }); 11962 } 11963 /** 11964 * Returns true if the target is an instance of Event.EventEmitter 11965 * @param {object} target 11966 * @returns {boolean} 11967 */ 11968 11969 }, { 11970 key: "isEventEmitter", 11971 value: function isEventEmitter(target) { 11972 return Type.isObject(target) && target[isEmitterProperty] === true; 11973 } 11974 /** 11975 * @private 11976 * @param {string} eventName 11977 * @returns {string} 11978 */ 11979 11980 }, { 11981 key: "normalizeEventName", 11982 value: function normalizeEventName(eventName) { 11983 if (!Type.isStringFilled(eventName)) { 11984 return ''; 11985 } 11986 11987 return eventName.toLowerCase(); 11988 } 11989 /** 11990 * @private 11991 * @param eventName 11992 * @param target 11993 * @param useGlobalNaming 11994 * @returns {string} 11995 */ 11996 11997 }, { 11998 key: "resolveEventName", 11999 value: function resolveEventName(eventName, target) { 12000 var useGlobalNaming = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
12001 eventName = this.normalizeEventName(eventName); 12002 12003 if (!Type.isStringFilled(eventName)) { 12004 return ''; 12005 } 12006 12007 if (this.isEventEmitter(target) && useGlobalNaming !== true) { 12008 if (target.getEventNamespace() !== null && eventName.includes('.')) { 12009 console.warn("Possible the wrong event name \"".concat(eventName, "\".")); 12010 } 12011 12012 eventName = target.getFullEventName(eventName); 12013 } else if (aliasStore.has(eventName)) { 12014 var _aliasStore$get = aliasStore.get(eventName), 12015 namespace = _aliasStore$get.namespace, 12016 actualEventName = _aliasStore$get.eventName; 12017 12018 eventName = this.makeFullEventName(namespace, actualEventName); 12019 } 12020 12021 return eventName; 12022 } 12023 /** 12024 * @private 12025 * @param {string} namespace 12026 * @param {string} eventName 12027 * @returns {string} 12028 */ 12029 12030 }, { 12031 key: "makeFullEventName", 12032 value: function makeFullEventName(namespace, eventName) { 12033 var fullName = Type.isStringFilled(namespace) ? "".concat(namespace, ":").concat(eventName) : eventName; 12034 return Type.isStringFilled(fullName) ? fullName.toLowerCase() : ''; 12035 } 12036 }]); 12037 return EventEmitter; 12038 }(); 12039 12040 babelHelpers.defineProperty(EventEmitter, "GLOBAL_TARGET", globalTarget); 12041 babelHelpers.defineProperty(EventEmitter, "DEFAULT_MAX_LISTENERS", eventStore.getDefaultMaxListeners()); 12042 babelHelpers.defineProperty(EventEmitter, "sequenceValue", 1); 12043 12044 var stack = []; 12045 /** 12046 * For compatibility only 12047 * @type {boolean} 12048 */ 12049 // eslint-disable-next-line 12050 12051 exports.isReady = false; 12052 function ready(handler) { 12053 switch (document.readyState) { 12054 case 'loading': 12055 stack.push(handler); 12056 break; 12057 12058 case 'interactive': 12059 case 'complete': 12060 if (Type.isFunction(handler)) { 12061 handler(); 12062 } 12063 12064 exports.isReady = true; 12065 break; 12066 } 12067 } 12068 document.addEventListener('readystatechange', function () { 12069 if (!exports.isReady) { 12070 stack.forEach(ready); 12071 stack = []; 12072 } 12073 }); 12074 12075 /** 12076 * @memberOf BX 12077 */ 12078 12079 var Event = function Event() { 12080 babelHelpers.classCallCheck(this, Event); 12081 }; 12082 12083 babelHelpers.defineProperty(Event, "bind", bind); 12084 babelHelpers.defineProperty(Event, "bindOnce", bindOnce); 12085 babelHelpers.defineProperty(Event, "unbind", unbind); 12086 babelHelpers.defineProperty(Event, "unbindAll", unbindAll); 12087 babelHelpers.defineProperty(Event, "ready", ready); 12088 babelHelpers.defineProperty(Event, "EventEmitter", EventEmitter); 12089 babelHelpers.defineProperty(Event, "BaseEvent", BaseEvent); 12090 12091 function encodeAttributeValue(value) { 12092 if (Type.isPlainObject(value) || Type.isArray(value)) { 12093 return JSON.stringify(value); 12094 } 12095 12096 return Text.encode(Text.decode(value)); 12097 } 12098 12099 function decodeAttributeValue(value) { 12100 if (Type.isString(value)) { 12101 var decodedValue = Text.decode(value); 12102 var result; 12103 12104 try { 12105 result = JSON.parse(decodedValue); 12106 } catch (e) { 12107 result = decodedValue; 12108 } 12109 12110 if (result === decodedValue) { 12111 if (/^[\d.]+[.]?\d+$/.test(result)) { 12112 return Number(result); 12113 } 12114 } 12115 12116 if (result === 'true' || result === 'false') { 12117 return Boolean(result); 12118 } 12119 12120 return result; 12121 } 12122 12123 return value; 12124 } 12125 12126 function getPageScroll() { 12127 var _document = document, 12128 documentElement = _document.documentElement, 12129 body = _document.body; 12130 var scrollTop = Math.max(window.pageYOffset || 0, documentElement ? documentElement.scrollTop : 0, body ? body.scrollTop : 0); 12131 var scrollLeft = Math.max(window.pageXOffset || 0, documentElement ? documentElement.scrollLeft : 0, body ? body.scrollLeft : 0); 12132 return { 12133 scrollTop: scrollTop, 12134 scrollLeft: scrollLeft 12135 }; 12136 } 12137 12138 /** 12139 * @memberOf BX 12140 */ 12141 12142 var Dom = 12143 /*#__PURE__*/ 12144 function () { 12145 function Dom() { 12146 babelHelpers.classCallCheck(this, Dom); 12147 } 12148 12149 babelHelpers.createClass(Dom, null, [{ 12150 key: "replace", 12151 12152 /** 12153 * Replaces old html element to new html element 12154 * @param oldElement 12155 * @param newElement 12156 */ 12157 value: function replace(oldElement, newElement) { 12158 if (Type.isDomNode(oldElement) && Type.isDomNode(newElement)) { 12159 if (Type.isDomNode(oldElement.parentNode)) { 12160 oldElement.parentNode.replaceChild(newElement, oldElement); 12161 } 12162 } 12163 } 12164 /** 12165 * Removes element 12166 * @param element 12167 */ 12168 12169 }, { 12170 key: "remove", 12171 value: function remove(element) { 12172 if (Type.isDomNode(element) && Type.isDomNode(element.parentNode)) { 12173 element.parentNode.removeChild(element); 12174 } 12175 } 12176 /** 12177 * Cleans element 12178 * @param element 12179 */ 12180 12181 }, { 12182 key: "clean", 12183 value: function clean(element) { 12184 if (Type.isDomNode(element)) { 12185 while (element.childNodes.length > 0) { 12186 element.removeChild(element.firstChild); 12187 } 12188 12189 return; 12190 } 12191 12192 if (Type.isString(element)) { 12193 Dom.clean(document.getElementById(element)); 12194 } 12195 } 12196 /** 12197 * Inserts element before target element 12198 * @param current 12199 * @param target 12200 */ 12201 12202 }, { 12203 key: "insertBefore", 12204 value: function insertBefore(current, target) { 12205 if (Type.isDomNode(current) && Type.isDomNode(target)) { 12206 if (Type.isDomNode(target.parentNode)) { 12207 target.parentNode.insertBefore(current, target); 12208 } 12209 } 12210 } 12211 /** 12212 * Inserts element after target element 12213 * @param current 12214 * @param target 12215 */ 12216 12217 }, { 12218 key: "insertAfter", 12219 value: function insertAfter(current, target) { 12220 if (Type.isDomNode(current) && Type.isDomNode(target)) { 12221 if (Type.isDomNode(target.parentNode)) { 12222 var parent = target.parentNode; 12223 12224 if (Type.isDomNode(target.nextSibling)) { 12225 parent.insertBefore(current, target.nextSibling); 12226 return; 12227 } 12228 12229 parent.appendChild(current); 12230 } 12231 } 12232 } 12233 /** 12234 * Appends element to target element 12235 * @param current 12236 * @param target 12237 */ 12238 12239 }, { 12240 key: "append", 12241 value: function append(current, target) { 12242 if (Type.isDomNode(current) && Type.isDomNode(target)) { 12243 target.appendChild(current); 12244 } 12245 } 12246 /** 12247 * Prepends element to target element 12248 * @param current 12249 * @param target 12250 */ 12251 12252 }, {
12253 key: "prepend", 12254 value: function prepend(current, target) { 12255 if (Type.isDomNode(current) && Type.isDomNode(target)) { 12256 if (Type.isDomNode(target.firstChild)) { 12257 target.insertBefore(current, target.firstChild); 12258 return; 12259 } 12260 12261 Dom.append(current, target); 12262 } 12263 } 12264 /** 12265 * Checks that element contains class name or class names 12266 * @param element 12267 * @param className 12268 * @return {Boolean} 12269 */ 12270 12271 }, { 12272 key: "hasClass", 12273 value: function hasClass(element, className) { 12274 if (Type.isElementNode(element)) { 12275 if (Type.isString(className)) { 12276 var preparedClassName = className.trim(); 12277 12278 if (preparedClassName.length > 0) { 12279 if (preparedClassName.includes(' ')) { 12280 return preparedClassName.split(' ').every(function (name) { 12281 return Dom.hasClass(element, name); 12282 }); 12283 } 12284 12285 if ('classList' in element) { 12286 return element.classList.contains(preparedClassName); 12287 } 12288 12289 if (Type.isObject(element.className) && Type.isString(element.className.baseVal)) { 12290 return element.getAttribute('class').split(' ').some(function (name) { 12291 return name === preparedClassName; 12292 }); 12293 } 12294 } 12295 } 12296 12297 if (Type.isArray(className) && className.length > 0) { 12298 return className.every(function (name) { 12299 return Dom.hasClass(element, name); 12300 }); 12301 } 12302 } 12303 12304 return false; 12305 } 12306 /** 12307 * Adds class name 12308 * @param element 12309 * @param className 12310 */ 12311 12312 }, { 12313 key: "addClass", 12314 value: function addClass(element, className) { 12315 if (Type.isElementNode(element)) { 12316 if (Type.isString(className)) { 12317 var preparedClassName = className.trim(); 12318 12319 if (preparedClassName.length > 0) { 12320 if (preparedClassName.includes(' ')) { 12321 Dom.addClass(element, preparedClassName.split(' ')); 12322 return; 12323 } 12324 12325 if ('classList' in element) { 12326 element.classList.add(preparedClassName); 12327 return; 12328 } 12329 12330 if (Type.isObject(element.className) && Type.isString(element.className.baseVal)) { 12331 if (element.className.baseVal === '') { 12332 element.className.baseVal = preparedClassName; 12333 return; 12334 } 12335 12336 var names = element.className.baseVal.split(' '); 12337 12338 if (!names.includes(preparedClassName)) { 12339 names.push(preparedClassName); 12340 element.className.baseVal = names.join(' ').trim(); 12341 return; 12342 } 12343 } 12344 12345 return; 12346 } 12347 } 12348 12349 if (Type.isArray(className)) { 12350 className.forEach(function (name) { 12351 return Dom.addClass(element, name); 12352 }); 12353 } 12354 } 12355 } 12356 /** 12357 * Removes class name 12358 * @param element 12359 * @param className 12360 */ 12361 12362 }, { 12363 key: "removeClass", 12364 value: function removeClass(element, className) { 12365 if (Type.isElementNode(element)) { 12366 if (Type.isString(className)) { 12367 var preparedClassName = className.trim(); 12368 12369 if (preparedClassName.length > 0) { 12370 if (preparedClassName.includes(' ')) { 12371 Dom.removeClass(element, preparedClassName.split(' ')); 12372 return; 12373 } 12374 12375 if ('classList' in element) { 12376 element.classList.remove(preparedClassName); 12377 return; 12378 } 12379 12380 if (Type.isObject(element.className) && Type.isString(element.className.baseVal)) { 12381 var names = element.className.baseVal.split(' ').filter(function (name) { 12382 return name !== preparedClassName; 12383 }); 12384 element.className.baseVal = names.join(' '); 12385 return; 12386 } 12387 } 12388 } 12389 12390 if (Type.isArray(className)) { 12391 className.forEach(function (name) { 12392 return Dom.removeClass(element, name); 12393 }); 12394 } 12395 } 12396 } 12397 /**
12398 * Toggles class name 12399 * @param element 12400 * @param className 12401 */ 12402 12403 }, { 12404 key: "toggleClass", 12405 value: function toggleClass(element, className) { 12406 if (Type.isElementNode(element)) { 12407 if (Type.isString(className)) { 12408 var preparedClassName = className.trim(); 12409 12410 if (preparedClassName.length > 0) { 12411 if (preparedClassName.includes(' ')) { 12412 Dom.toggleClass(element, preparedClassName.split(' ')); 12413 return; 12414 } 12415 12416 element.classList.toggle(preparedClassName); 12417 return; 12418 } 12419 } 12420 12421 if (Type.isArray(className)) { 12422 className.forEach(function (name) { 12423 return Dom.toggleClass(element, name); 12424 }); 12425 } 12426 } 12427 } 12428 /** 12429 * Styles element 12430 */ 12431 12432 }, { 12433 key: "style", 12434 value: function style(element, prop, value) { 12435 if (Type.isElementNode(element)) { 12436 if (Type.isNull(prop)) { 12437 element.removeAttribute('style'); 12438 return element; 12439 } 12440 12441 if (Type.isPlainObject(prop)) { 12442 Object.entries(prop).forEach(function (item) { 12443 var _item = babelHelpers.slicedToArray(item, 2), 12444 currentKey = _item[0], 12445 currentValue = _item[1]; 12446 12447 Dom.style(element, currentKey, currentValue); 12448 }); 12449 return element; 12450 } 12451 12452 if (Type.isString(prop)) { 12453 if (Type.isUndefined(value) && element.nodeType !== Node.DOCUMENT_NODE) { 12454 var computedStyle = getComputedStyle(element); 12455 12456 if (prop in computedStyle) { 12457 return computedStyle[prop]; 12458 } 12459 12460 return computedStyle.getPropertyValue(prop); 12461 } 12462 12463 if (Type.isNull(value) || value === '' || value === 'null') { 12464 // eslint-disable-next-line 12465 element.style[prop] = ''; 12466 return element; 12467 } 12468 12469 if (Type.isString(value) || Type.isNumber(value)) { 12470 // eslint-disable-next-line 12471 element.style[prop] = value; 12472 return element; 12473 } 12474 } 12475 } 12476 12477 return null; 12478 } 12479 /** 12480 * Adjusts element 12481 * @param target 12482 * @param data 12483 * @return {*} 12484 */ 12485 12486 }, { 12487 key: "adjust", 12488 value: function adjust(target) { 12489 var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 12490 12491 if (!target.nodeType) { 12492 return null; 12493 } 12494 12495 var element = target; 12496 12497 if (target.nodeType === Node.DOCUMENT_NODE) { 12498 element = target.body; 12499 } 12500 12501 if (Type.isPlainObject(data)) { 12502 if (Type.isPlainObject(data.attrs)) { 12503 Object.keys(data.attrs).forEach(function (key) { 12504 if (key === 'class' || key.toLowerCase() === 'classname') { 12505 element.className = data.attrs[key]; 12506 return; 12507 } // eslint-disable-next-line 12508 12509 12510 if (data.attrs[key] == '') { 12511 element.removeAttribute(key); 12512 return; 12513 } 12514 12515 element.setAttribute(key, data.attrs[key]); 12516 }); 12517 } 12518 12519 if (Type.isPlainObject(data.style)) { 12520 Dom.style(element, data.style); 12521 } 12522 12523 if (Type.isPlainObject(data.props)) { 12524 Object.keys(data.props).forEach(function (key) { 12525 element[key] = data.props[key]; 12526 }); 12527 } 12528 12529 if (Type.isPlainObject(data.events)) { 12530 Object.keys(data.events).forEach(function (key) { 12531 Event.bind(element, key, data.events[key]); 12532 }); 12533 } 12534 12535 if (Type.isPlainObject(data.dataset)) { 12536 Object.keys(data.dataset).forEach(function (key) { 12537 element.dataset[key] = data.dataset[key]; 12538 }); 12539 } 12540 12541 if (Type.isString(data.children)) { 12542 data.children = [data.children]; 12543 } 12544 12545 if (Type.isArray(data.children) && data.children.length > 0) {
12546 data.children.forEach(function (item) { 12547 if (Type.isDomNode(item)) { 12548 Dom.append(item, element); 12549 } 12550 12551 if (Type.isString(item)) { 12552 element.innerHTML += item; 12553 } 12554 }); 12555 return element; 12556 } 12557 12558 if ('text' in data && !Type.isNil(data.text)) { 12559 element.innerText = data.text; 12560 return element; 12561 } 12562 12563 if ('html' in data && !Type.isNil(data.html)) { 12564 element.innerHTML = data.html; 12565 } 12566 } 12567 12568 return element; 12569 } 12570 /** 12571 * Creates element 12572 * @param tag 12573 * @param data 12574 * @param context 12575 * @return {HTMLElement|HTMLBodyElement} 12576 */ 12577 12578 }, { 12579 key: "create", 12580 value: function create(tag) { 12581 var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 12582 var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : document; 12583 var tagName = tag; 12584 var options = data; 12585 12586 if (Type.isObjectLike(tag)) { 12587 options = tag; 12588 tagName = tag.tag; 12589 } 12590 12591 return Dom.adjust(context.createElement(tagName), options); 12592 } 12593 /** 12594 * Shows element 12595 * @param element 12596 */ 12597 12598 }, { 12599 key: "show", 12600 value: function show(element) { 12601 if (Type.isDomNode(element)) { 12602 // eslint-disable-next-line 12603 element.hidden = false; 12604 } 12605 } 12606 /** 12607 * Hides element 12608 * @param element 12609 */ 12610 12611 }, { 12612 key: "hide", 12613 value: function hide(element) { 12614 if (Type.isDomNode(element)) { 12615 // eslint-disable-next-line 12616 element.hidden = true; 12617 } 12618 } 12619 /** 12620 * Checks that element is shown 12621 * @param element 12622 * @return {*|boolean} 12623 */ 12624 12625 }, { 12626 key: "isShown", 12627 value: function isShown(element) { 12628 return Type.isDomNode(element) && !element.hidden && element.style.getPropertyValue('display') !== 'none'; 12629 } 12630 /** 12631 * Toggles element visibility 12632 * @param element 12633 */ 12634 12635 }, { 12636 key: "toggle", 12637 value: function toggle(element) { 12638 if (Type.isDomNode(element)) { 12639 if (Dom.isShown(element)) { 12640 Dom.hide(element); 12641 } else { 12642 Dom.show(element); 12643 } 12644 } 12645 } 12646 /** 12647 * Gets element position relative page 12648 * @param {HTMLElement} element 12649 * @return {DOMRect} 12650 */ 12651 12652 }, { 12653 key: "getPosition", 12654 value: function getPosition(element) { 12655 if (Type.isDomNode(element)) { 12656 var elementRect = element.getBoundingClientRect(); 12657 12658 var _getPageScroll = getPageScroll(), 12659 scrollLeft = _getPageScroll.scrollLeft, 12660 scrollTop = _getPageScroll.scrollTop; 12661 12662 return new DOMRect(elementRect.left + scrollLeft, elementRect.top + scrollTop, elementRect.width, elementRect.height); 12663 } 12664 12665 return new DOMRect(); 12666 } 12667 /** 12668 * Gets element position relative specified element position 12669 * @param {HTMLElement} element 12670 * @param {HTMLElement} relationElement 12671 * @return {DOMRect} 12672 */ 12673 12674 }, { 12675 key: "getRelativePosition", 12676 value: function getRelativePosition(element, relationElement) { 12677 if (Type.isDomNode(element) && Type.isDomNode(relationElement)) { 12678 var elementPosition = Dom.getPosition(element); 12679 var relationElementPosition = Dom.getPosition(relationElement); 12680 return new DOMRect(elementPosition.left - relationElementPosition.left, elementPosition.top - relationElementPosition.top, elementPosition.width, elementPosition.height); 12681 } 12682 12683 return new DOMRect(); 12684 } 12685 }, { 12686 key: "attr", 12687 value: function attr(element, _attr, value) { 12688 if (Type.isElementNode(element)) { 12689 if (Type.isString(_attr)) { 12690 if (!Type.isNil(value)) { 12691 return element.setAttribute(_attr, encodeAttributeValue(value)); 12692 } 12693 12694 if (Type.isNull(value)) { 12695 return element.removeAttribute(_attr); 12696 } 12697 12698 return decodeAttributeValue(element.getAttribute(_attr)); 12699 } 12700 12701 if (Type.isPlainObject(_attr)) { 12702 return Object.entries(_attr).forEach(function (_ref) { 12703 var _ref2 = babelHelpers.slicedToArray(_ref, 2), 12704 attrKey = _ref2[0], 12705 attrValue = _ref2[1]; 12706 12707 Dom.attr(element, attrKey, attrValue); 12708 }); 12709 } 12710 } 12711 12712 return null; 12713 } 12714 }]); 12715 return Dom; 12716 }(); 12717 12718 var UA = navigator.userAgent.toLowerCase(); 12719 /** 12720 * @memberOf BX 12721 */ 12722 12723 var Browser = 12724 /*#__PURE__*/ 12725 function () { 12726 function Browser() { 12727 babelHelpers.classCallCheck(this, Browser); 12728 } 12729 12730 babelHelpers.createClass(Browser, null, [{ 12731 key: "isOpera", 12732 value: function isOpera() { 12733 return UA.includes('opera'); 12734 } 12735 }, { 12736 key: "isIE", 12737 value: function isIE() { 12738 return 'attachEvent' in document && !Browser.isOpera(); 12739 } 12740 }, { 12741 key: "isIE6", 12742 value: function isIE6() { 12743 return UA.includes('msie 6'); 12744 } 12745 }, { 12746 key: "isIE7", 12747 value: function isIE7() { 12748 return UA.includes('msie 7'); 12749 } 12750 }, { 12751 key: "isIE8", 12752 value: function isIE8() { 12753 return UA.includes('msie 8'); 12754 } 12755 }, { 12756 key: "isIE9", 12757 value: function isIE9() { 12758 return 'documentMode' in document && document.documentMode >= 9; 12759 } 12760 }, { 12761 key: "isIE10", 12762 value: function isIE10() { 12763 return 'documentMode' in document && document.documentMode >= 10; 12764 } 12765 }, { 12766 key: "isSafari", 12767 value: function isSafari() { 12768 return UA.includes('webkit'); 12769 } 12770 }, { 12771 key: "isFirefox", 12772 value: function isFirefox() { 12773 return UA.includes('firefox'); 12774 } 12775 }, { 12776 key: "isChrome", 12777 value: function isChrome() { 12778 return UA.includes('chrome'); 12779 } 12780 }, { 12781 key: "detectIEVersion", 12782 value: function detectIEVersion() { 12783 if (Browser.isOpera() || Browser.isSafari() || Browser.isFirefox() || Browser.isChrome()) { 12784 return -1; 12785 } 12786 12787 var rv = -1; 12788 12789 if (!!window.MSStream && !window.ActiveXObject && 'ActiveXObject' in window) { 12790 rv = 11; 12791 } else if (Browser.isIE10()) { 12792 rv = 10; 12793 } else if (Browser.isIE9()) { 12794 rv = 9; 12795 } else if (Browser.isIE()) { 12796 rv = 8; 12797 } 12798 12799 if (rv === -1 || rv === 8) { 12800 if (navigator.appName === 'Microsoft Internet Explorer') { 12801 var re = new RegExp('MSIE ([0-9]+[.0-9]*)'); 12802 var res = navigator.userAgent.match(re); 12803 12804 if (Type.isArrayLike(res) && res.length > 0) { 12805 rv = parseFloat(res[1]); 12806 } 12807 } 12808 12809 if (navigator.appName === 'Netscape') { 12810 // Alternative check for IE 11 12811 rv = 11; 12812 12813 var _re = new RegExp('Trident/.*rv:([0-9]+[.0-9]*)'); 12814 12815 if (_re.exec(navigator.userAgent) != null) { 12816 var _res = navigator.userAgent.match(_re); 12817 12818 if (Type.isArrayLike(_res) && _res.length > 0) { 12819 rv = parseFloat(_res[1]); 12820 } 12821 } 12822 } 12823 } 12824 12825 return rv; 12826 } 12827 }, { 12828 key: "isIE11", 12829 value: function isIE11() { 12830 return Browser.detectIEVersion() >= 11; 12831 } 12832 }, { 12833 key: "isMac", 12834 value: function isMac() { 12835 return UA.includes('macintosh'); 12836 } 12837 }, { 12838 key: "isAndroid", 12839 value: function isAndroid() { 12840 return UA.includes('android'); 12841 } 12842 }, { 12843 key: "isIPad", 12844 value: function isIPad() { 12845 return UA.includes('ipad;'); 12846 } 12847 }, { 12848 key: "isIPhone", 12849 value: function isIPhone() { 12850 return UA.includes('iphone;'); 12851 } 12852 }, { 12853 key: "isIOS", 12854 value: function isIOS() { 12855 return Browser.isIPad() || Browser.isIPhone(); 12856 } 12857 }, { 12858 key: "isMobile", 12859 value: function isMobile() { 12860 return Browser.isIPhone() || Browser.isIPad() || Browser.isAndroid() || UA.includes('mobile') || UA.includes('touch'); 12861 } 12862 }, { 12863 key: "isRetina", 12864 value: function isRetina() { 12865 return window.devicePixelRatio && window.devicePixelRatio >= 2; 12866 } 12867 }, { 12868 key: "isDoctype", 12869 value: function isDoctype(target) { 12870 var doc = target || document; 12871 12872 if (doc.compatMode) { 12873 return doc.compatMode === 'CSS1Compat'; 12874 } 12875 12876 return doc.documentElement && doc.documentElement.clientHeight; 12877 } 12878 }, { 12879 key: "isLocalStorageSupported", 12880 value: function isLocalStorageSupported() { 12881 try { 12882 localStorage.setItem('test', 'test'); 12883 localStorage.removeItem('test'); 12884 return true; 12885 } catch (e) { 12886 return false;
12887 } 12888 } 12889 }, { 12890 key: "addGlobalClass", 12891 value: function addGlobalClass() { 12892 var globalClass = 'bx-core'; 12893 12894 if (Dom.hasClass(document.documentElement, globalClass)) { 12895 return; 12896 } 12897 12898 if (Browser.isIOS()) { 12899 globalClass += ' bx-ios'; 12900 } else if (Browser.isMac()) { 12901 globalClass += ' bx-mac'; 12902 } else if (Browser.isAndroid()) { 12903 globalClass += ' bx-android'; 12904 } 12905 12906 globalClass += Browser.isMobile() ? ' bx-touch' : ' bx-no-touch'; 12907 globalClass += Browser.isRetina() ? ' bx-retina' : ' bx-no-retina'; 12908 var ieVersion = -1; 12909 12910 if (/AppleWebKit/.test(navigator.userAgent)) { 12911 globalClass += ' bx-chrome'; 12912 } else if (Browser.detectIEVersion() > 0) { 12913 ieVersion = Browser.detectIEVersion(); 12914 globalClass += " bx-ie bx-ie".concat(ieVersion); 12915 12916 if (ieVersion > 7 && ieVersion < 10 && !Browser.isDoctype()) { 12917 globalClass += ' bx-quirks'; 12918 } 12919 } else if (/Opera/.test(navigator.userAgent)) { 12920 globalClass += ' bx-opera'; 12921 } else if (/Gecko/.test(navigator.userAgent)) { 12922 globalClass += ' bx-firefox'; 12923 } 12924 12925 Dom.addClass(document.documentElement, globalClass); 12926 } 12927 }, { 12928 key: "detectAndroidVersion", 12929 value: function detectAndroidVersion() { 12930 var re = new RegExp('Android ([0-9]+[.0-9]*)'); 12931 12932 if (re.exec(navigator.userAgent) != null) { 12933 var res = navigator.userAgent.match(re); 12934 12935 if (Type.isArrayLike(res) && res.length > 0) { 12936 return parseFloat(res[1]); 12937 } 12938 } 12939 12940 return 0; 12941 } 12942 }, { 12943 key: "isPropertySupported", 12944 value: function isPropertySupported(jsProperty, returnCSSName) { 12945 if (jsProperty === '') { 12946 return false; 12947 } 12948 12949 function getCssName(propertyName) { 12950 return propertyName.replace(/([A-Z])/g, function () { 12951 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 12952 args[_key] = arguments[_key]; 12953 } 12954 12955 return "-".concat(args[1].toLowerCase()); 12956 }); 12957 } 12958 12959 function getJsName(cssName) { 12960 var reg = /(\\-([a-z]))/g; 12961 12962 if (reg.test(cssName)) { 12963 return cssName.replace(reg, function () { 12964 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 12965 args[_key2] = arguments[_key2]; 12966 } 12967 12968 return args[2].toUpperCase(); 12969 }); 12970 } 12971 12972 return cssName; 12973 } 12974 12975 var property = jsProperty.includes('-') ? getJsName(jsProperty) : jsProperty; 12976 var bReturnCSSName = !!returnCSSName; 12977 var ucProperty = property.charAt(0).toUpperCase() + property.slice(1); 12978 var props = ['Webkit', 'Moz', 'O', 'ms'].join("".concat(ucProperty, " ")); 12979 var properties = "".concat(property, " ").concat(props, " ").concat(ucProperty).split(' '); 12980 var obj = document.body || document.documentElement; 12981 12982 for (var i = 0; i < properties.length; i += 1) { 12983 var prop = properties[i]; 12984 12985 if (obj && 'style' in obj && prop in obj.style) { 12986 var lowerProp = prop.substr(0, prop.length - property.length).toLowerCase(); 12987 var prefix = prop === property ? '' : "-".concat(lowerProp, "-"); 12988 return bReturnCSSName ? prefix + getCssName(property) : prop; 12989 } 12990 } 12991 12992 return false; 12993 } 12994 }, { 12995 key: "addGlobalFeatures", 12996 value: function addGlobalFeatures(features) { 12997 if (!Type.isArray(features)) { 12998 return; 12999 } 13000 13001 var classNames = []; 13002 13003 for (var i = 0; i < features.length; i += 1) { 13004 var support = !!Browser.isPropertySupported(features[i]); 13005 classNames.push("bx-".concat(support ? '' : 'no-').concat(features[i].toLowerCase())); 13006 } 13007 13008 Dom.addClass(document.documentElement, classNames.join(' ')); 13009 } 13010 }]); 13011 return Browser; 13012 }(); 13013 13014 var Cookie = 13015 /*#__PURE__*/ 13016 function () { 13017 function Cookie() { 13018 babelHelpers.classCallCheck(this, Cookie); 13019 } 13020 13021 babelHelpers.createClass(Cookie, null, [{ 13022 key: "getList", 13023 13024 /** 13025 * Gets cookies list for current domain 13026 * @return {object} 13027 */ 13028 value: function getList() { 13029 return document.cookie.split(';').map(function (item) { 13030 return item.split('='); 13031 }).map(function (item) { 13032 return item.map(function (subItem) { 13033 return subItem.trim(); 13034 }); 13035 }).reduce(function (acc, item) { 13036 var _item = babelHelpers.slicedToArray(item, 2), 13037 key = _item[0], 13038 value = _item[1]; 13039 13040 acc[decodeURIComponent(key)] = decodeURIComponent(value); 13041 return acc; 13042 }, {}); 13043 } 13044 /** 13045 * Gets cookie value 13046 * @param {string} name 13047 * @return {*} 13048 */ 13049 13050 }, { 13051 key: "get", 13052 value: function get(name) { 13053 var cookiesList = Cookie.getList(); 13054 13055 if (name in cookiesList) { 13056 return cookiesList[name]; 13057 } 13058 13059 return undefined; 13060 } 13061 /** 13062 * Sets cookie 13063 * @param {string} name 13064 * @param {*} value 13065 * @param {object} [options] 13066 */ 13067 13068 }, { 13069 key: "set", 13070 value: function set(name, value) { 13071 var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 13072 var attributes = babelHelpers.objectSpread({ 13073 expires: '' 13074 }, options); 13075 13076 if (Type.isNumber(attributes.expires)) { 13077 var now = +new Date(); 13078 var days = attributes.expires; 13079 var dayInMs = 864e+5; 13080 attributes.expires = new Date(now + days * dayInMs); 13081 } 13082 13083 if (Type.isDate(attributes.expires)) { 13084 attributes.expires = attributes.expires.toUTCString(); 13085 } 13086 13087 var safeName = decodeURIComponent(String(name)).replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape); 13088 var safeValue = encodeURIComponent(String(value)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent); 13089 var stringifiedAttributes = Object.keys(attributes).reduce(function (acc, key) { 13090 var attributeValue = attributes[key]; 13091 13092 if (!attributeValue) { 13093 return acc; 13094 } 13095 13096 if (attributeValue === true) { 13097 return "".concat(acc, "; ").concat(key); 13098 } 13099 /** 13100 * Considers RFC 6265 section 5.2: 13101 * ... 13102 * 3. If the remaining unparsed-attributes contains a %x3B (';') 13103 * character: 13104 * Consume the characters of the unparsed-attributes up to, 13105 * not including, the first %x3B (';') character. 13106 */ 13107 13108 13109 return "".concat(acc, "; ").concat(key, "=").concat(attributeValue.split(';')[0]); 13110 }, ''); 13111 document.cookie = "".concat(safeName, "=").concat(safeValue).concat(stringifiedAttributes); 13112 } 13113 /** 13114 * Removes cookie 13115 * @param {string} name 13116 * @param {object} [options] 13117 */ 13118 13119 }, { 13120 key: "remove", 13121 value: function remove(name) { 13122 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 13123 Cookie.set(name, '', babelHelpers.objectSpread({}, options, { 13124 expires: -1 13125 })); 13126 } 13127 }]); 13128 return Cookie; 13129 }(); 13130 13131 function objectToFormData(source) { 13132 var formData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new FormData(); 13133 var pre = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; 13134 13135 if (Type.isUndefined(source)) { 13136 return formData; 13137 } 13138 13139 if (Type.isNull(source)) { 13140 formData.append(pre, ''); 13141 } else if (Type.isArray(source)) { 13142 if (!source.length) { 13143 var _key = "".concat(pre, "[]"); 13144 13145 formData.append(_key, ''); 13146 } else { 13147 source.forEach(function (value, index) { 13148 var key = "".concat(pre, "[").concat(index, "]"); 13149 objectToFormData(value, formData, key); 13150 }); 13151 } 13152 } else if (Type.isDate(source)) { 13153 formData.append(pre, source.toISOString()); 13154 } else if (Type.isObject(source) && !Type.isFile(source) && !Type.isBlob(source)) { 13155 Object.keys(source).forEach(function (property) { 13156 var value = source[property]; 13157 var preparedProperty = property; 13158 13159 if (Type.isArray(value)) { 13160 while (property.length > 2 && property.lastIndexOf('[]') === property.length - 2) { 13161 preparedProperty = property.substring(0, property.length - 2); 13162 } 13163 } 13164 13165 var key = pre ? "".concat(pre, "[").concat(preparedProperty, "]") : preparedProperty; 13166 objectToFormData(value, formData, key); 13167 }); 13168 } else { 13169 formData.append(pre, source); 13170 } 13171 13172 return formData; 13173 } 13174 13175 var Data = 13176 /*#__PURE__*/ 13177 function () { 13178 function Data() { 13179 babelHelpers.classCallCheck(this, Data); 13180 } 13181 13182 babelHelpers.createClass(Data, null, [{ 13183 key: "convertObjectToFormData", 13184 13185 /** 13186 * Converts object to FormData 13187 * @param source 13188 * @return {FormData} 13189 */ 13190 value: function convertObjectToFormData(source) { 13191 return objectToFormData(source); 13192 } 13193 }]); 13194 return Data; 13195 }(); 13196 13197 /** 13198 * @memberOf BX 13199 */ 13200 13201 var Http = function Http() { 13202 babelHelpers.classCallCheck(this, Http); 13203 }; 13204 13205 babelHelpers.defineProperty(Http, "Cookie", Cookie); 13206 babelHelpers.defineProperty(Http, "Data", Data); 13207 13208 function message(value) { 13209 if (Type.isString(value)) { 13210 if (Type.isNil(message[value])) { 13211 // eslint-disable-next-line 13212 EventEmitter.emit('onBXMessageNotFound', new BaseEvent({ 13213 compatData: [value] 13214 })); 13215 13216 if (Type.isNil(message[value])) { 13217 Runtime.debug("message undefined: ".concat(value)); 13218 message[value] = ''; 13219 } 13220 } 13221 } 13222 13223 if (Type.isPlainObject(value)) { 13224 Object.keys(value).forEach(function (key) { 13225 message[key] = value[key]; 13226 }); 13227 } 13228 13229 return message[value]; 13230 } 13231 13232 if (!Type.isNil(window.BX) && Type.isFunction(window.BX.message)) { 13233 Object.keys(window.BX.message).forEach(function (key) { 13234 message(babelHelpers.defineProperty({}, key, window.BX.message[key])); 13235 }); 13236 } 13237 13238 /** 13239 * Implements interface for works with language messages 13240 * @memberOf BX 13241 */ 13242 13243 var Loc = 13244 /*#__PURE__*/ 13245 function () { 13246 function Loc() { 13247 babelHelpers.classCallCheck(this, Loc); 13248 } 13249 13250 babelHelpers.createClass(Loc, null, [{ 13251 key: "getMessage", 13252 13253 /** 13254 * Gets message by id 13255 * @param {string} messageId 13256 * @return {?string} 13257 */
13258 value: function getMessage(messageId) { 13259 return message(messageId); 13260 } 13261 /** 13262 * Sets message or messages 13263 * @param {string | Object<string, string>} id 13264 * @param {string} [value] 13265 */ 13266 13267 }, { 13268 key: "setMessage", 13269 value: function setMessage(id, value) { 13270 if (Type.isString(id) && Type.isString(value)) { 13271 message(babelHelpers.defineProperty({}, id, value)); 13272 } 13273 13274 if (Type.isObject(id)) { 13275 message(id); 13276 } 13277 } 13278 }]); 13279 return Loc; 13280 }(); 13281 13282 var handlers = new Map(); 13283 var children = new Map(); 13284 13285 var getUid = function () { 13286 var incremental = 0; 13287 return function () { 13288 incremental += 1; 13289 return incremental; 13290 }; 13291 }(); 13292 13293 function bindAll(element, handlersMap) { 13294 handlersMap.forEach(function (handler, key) { 13295 var currentElement = element.querySelector("[".concat(key, "]")); 13296 13297 if (currentElement) { 13298 currentElement.removeAttribute(key); 13299 var event = key.replace(/-(.*)/, ''); 13300 Event.bind(currentElement, event, handler); 13301 handlers.delete(key); 13302 } 13303 }); 13304 } 13305 13306 function replaceChild(element, childrenMap) { 13307 childrenMap.forEach(function (item, id) { 13308 var currentElement = element.getElementById(id); 13309 13310 if (currentElement) { 13311 Dom.replace(currentElement, item); 13312 children.delete(id); 13313 } 13314 }); 13315 } 13316 13317 function render(sections) { 13318 var eventAttrRe = /[ |\t]on(\w+)="$/; 13319 var uselessSymbolsRe = /[\r\n\t]/g; 13320 13321 for (var _len = arguments.length, substitutions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 13322 substitutions[_key - 1] = arguments[_key]; 13323 } 13324 13325 var html = substitutions.reduce(function (acc, item, index) { 13326 var preparedAcc = acc; // Process event handlers 13327 13328 var matches = acc.match(eventAttrRe); 13329 13330 if (matches && Type.isFunction(item)) { 13331 var eventName = matches[1].replace(/=['|"]/, ''); 13332 var attrName = "".concat(eventName, "-").concat(getUid()); 13333 var attribute = "".concat(attrName, "=\""); 13334 preparedAcc = preparedAcc.replace(eventAttrRe, " ".concat(attribute)); 13335 handlers.set(attrName, item); 13336 preparedAcc += sections[index + 1].replace(uselessSymbolsRe, ' ').replace(/ +/g, ' '); 13337 return preparedAcc; 13338 } // Process element 13339 13340 13341 if (Type.isDomNode(item)) { 13342 var childKey = "tmp___".concat(getUid()); 13343 children.set(childKey, item); 13344 preparedAcc += "<span id=\"".concat(childKey, "\"> </span>"); 13345 preparedAcc += sections[index + 1]; 13346 return preparedAcc; 13347 } // Process array 13348 13349 13350 if (Type.isArray(item)) { 13351 babelHelpers.toConsumableArray(item).forEach(function (currentElement) { 13352 if (Type.isDomNode(currentElement)) { 13353 var _childKey = "tmp___".concat(getUid()); 13354 13355 children.set(_childKey, currentElement); 13356 preparedAcc += "<span id=\"".concat(_childKey, "\"> </span>"); 13357 } 13358 }); 13359 preparedAcc += sections[index + 1]; 13360 return preparedAcc; 13361 } 13362 13363 return preparedAcc + item + sections[index + 1]; 13364 }, sections[0]); 13365 var lowercaseHtml = html.trim().toLowerCase(); 13366 13367 if (lowercaseHtml.startsWith('<!doctype') || lowercaseHtml.startsWith('<html')) { 13368 var doc = document.implementation.createHTMLDocument(''); 13369 doc.documentElement.innerHTML = html; 13370 replaceChild(doc, children); 13371 bindAll(doc, handlers); 13372 handlers.clear(); 13373 return doc; 13374 } 13375 13376 var parser = new DOMParser(); 13377 var parsedDocument = parser.parseFromString(html, 'text/html'); 13378 replaceChild(parsedDocument, children); 13379 bindAll(parsedDocument, handlers); 13380 13381 if (parsedDocument.head.children.length && parsedDocument.body.children.length) { 13382 return parsedDocument; 13383 } 13384 13385 if (parsedDocument.body.children.length === 1) { 13386 var _parsedDocument$body$ = babelHelpers.slicedToArray(parsedDocument.body.children, 1), 13387 el = _parsedDocument$body$[0]; 13388 13389 Dom.remove(el); 13390 return el; 13391 } 13392 13393 if (parsedDocument.body.children.length > 1) { 13394 return babelHelpers.toConsumableArray(parsedDocument.body.children).map(function (item) { 13395 Dom.remove(item); 13396 return item; 13397 }); 13398 } 13399 13400 if (parsedDocument.body.children.length === 0) { 13401 if (parsedDocument.head.children.length === 1) { 13402 var _parsedDocument$head$ = babelHelpers.slicedToArray(parsedDocument.head.children, 1), 13403 _el = _parsedDocument$head$[0]; 13404 13405 Dom.remove(_el); 13406 return _el; 13407 } 13408 13409 if (parsedDocument.head.children.length > 1) { 13410 return babelHelpers.toConsumableArray(parsedDocument.head.children).map(function (item) { 13411 Dom.remove(item); 13412 return item; 13413 }); 13414 } 13415 } 13416 13417 return false;
13418 } 13419 13420 function parseProps(sections) { 13421 for (var _len = arguments.length, substitutions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 13422 substitutions[_key - 1] = arguments[_key]; 13423 } 13424 13425 return substitutions.reduce(function (acc, item, index) { 13426 var nextSectionIndex = index + 1; 13427 13428 if (!Type.isPlainObject(item) && !Type.isArray(item)) { 13429 return acc + item + sections[nextSectionIndex]; 13430 } 13431 13432 return "".concat(acc, "__s").concat(index).concat(sections[nextSectionIndex]); 13433 }, sections[0]).replace(/[\r\t]/gm, '').split(';\n').map(function (item) { 13434 return item.replace(/\n/, ''); 13435 }).reduce(function (acc, item) { 13436 if (item !== '') { 13437 var matches = item.match(/^[\w-. ]+:/); 13438 var splitted = item.split(/^[\w-. ]+:/); 13439 13440 var _key2 = matches[0].replace(':', '').trim(); 13441 13442 var value = splitted[1].trim(); 13443 var substitutionPlaceholderExp = /^__s\d+/; 13444 13445 if (substitutionPlaceholderExp.test(value)) { 13446 acc[_key2] = substitutions[value.replace('__s', '')]; 13447 return acc; 13448 } 13449 13450 acc[_key2] = value; 13451 } 13452 13453 return acc; 13454 }, {}); 13455 } 13456 /** 13457 * @memberOf BX 13458 */ 13459 13460 13461 var Tag = 13462 /*#__PURE__*/ 13463 function () { 13464 function Tag() { 13465 babelHelpers.classCallCheck(this, Tag); 13466 } 13467 13468 babelHelpers.createClass(Tag, null, [{ 13469 key: "safe", 13470 13471 /** 13472 * Encodes all substitutions 13473 * @param sections 13474 * @param substitutions 13475 * @return {string} 13476 */ 13477 value: function safe(sections) { 13478 for (var _len2 = arguments.length, substitutions = new Array(_len2 > 1 ? _len2 - 1 : 0), _key3 = 1; _key3 < _len2; _key3++) { 13479 substitutions[_key3 - 1] = arguments[_key3]; 13480 } 13481 13482 return substitutions.reduce(function (acc, item, index) { 13483 return acc + Text.encode(item) + sections[index + 1]; 13484 }, sections[0]); 13485 } 13486 /** 13487 * Decodes all substitutions 13488 * @param sections 13489 * @param substitutions 13490 * @return {string} 13491 */ 13492 13493 }, { 13494 key: "unsafe", 13495 value: function unsafe(sections) { 13496 for (var _len3 = arguments.length, substitutions = new Array(_len3 > 1 ? _len3 - 1 : 0), _key4 = 1; _key4 < _len3; _key4++) { 13497 substitutions[_key4 - 1] = arguments[_key4]; 13498 } 13499 13500 return substitutions.reduce(function (acc, item, index) { 13501 return acc + Text.decode(item) + sections[index + 1]; 13502 }, sections[0]); 13503 } 13504 /** 13505 * Adds styles to specified element 13506 * @param {HTMLElement} element 13507 * @return {Function} 13508 */ 13509 13510 }, { 13511 key: "style", 13512 value: function style(element) { 13513 if (!Type.isDomNode(element)) { 13514 throw new Error('element is not HTMLElement'); 13515 } 13516 13517 return function styleTagHandler() { 13518 Dom.style(element, parseProps.apply(void 0, arguments)); 13519 }; 13520 } 13521 /** 13522 * Replace all messages identifiers to real messages 13523 * @param sections 13524 * @param substitutions 13525 * @return {string} 13526 */ 13527 13528 }, { 13529 key: "message", 13530 value: function message(sections) { 13531 for (var _len4 = arguments.length, substitutions = new Array(_len4 > 1 ? _len4 - 1 : 0), _key5 = 1; _key5 < _len4; _key5++) { 13532 substitutions[_key5 - 1] = arguments[_key5]; 13533 } 13534 13535 return substitutions.reduce(function (acc, item, index) { 13536 return acc + Loc.getMessage(item) + sections[index + 1]; 13537 }, sections[0]); 13538 } 13539 }, { 13540 key: "attrs", 13541 13542 /** 13543 * Adds attributes to specified element 13544 * @param element 13545 * @return {Function} 13546 */ 13547 value: function attrs(element) { 13548 if (!Type.isDomNode(element)) { 13549 throw new Error('element is not HTMLElement'); 13550 } 13551 13552 return function attrsTagHandler() { 13553 Dom.attr(element, parseProps.apply(void 0, arguments)); 13554 }; 13555 } 13556 }]); 13557 return Tag; 13558 }(); 13559 13560 babelHelpers.defineProperty(Tag, "render", render); 13561 babelHelpers.defineProperty(Tag, "attr", Tag.attrs); 13562 13563 function getParser(format) { 13564 switch (format) { 13565 case 'index': 13566 return function (sourceKey, value, accumulator) { 13567 var result = /\[(\w*)\]$/.exec(sourceKey); 13568 var key = sourceKey.replace(/\[\w*\]$/, ''); 13569 13570 if (Type.isNil(result)) { 13571 accumulator[key] = value; 13572 return; 13573 } 13574 13575 if (Type.isUndefined(accumulator[key])) { 13576 accumulator[key] = {}; 13577 } 13578 13579 accumulator[key][result[1]] = value; 13580 }; 13581 13582 case 'bracket': 13583 return function (sourceKey, value, accumulator) { 13584 var result = /(\[\])$/.exec(sourceKey); 13585 var key = sourceKey.replace(/\[\]$/, ''); 13586 13587 if (Type.isNil(result)) { 13588 accumulator[key] = value; 13589 return; 13590 } 13591 13592 if (Type.isUndefined(accumulator[key])) { 13593 accumulator[key] = [value]; 13594 return; 13595 } 13596 13597 accumulator[key] = [].concat(accumulator[key], value); 13598 }; 13599 13600 default: 13601 return function (sourceKey, value, accumulator) { 13602 var key = sourceKey.replace(/\[\]$/, ''); 13603 accumulator[key] = value; 13604 }; 13605 } 13606 } 13607 13608 function getKeyFormat(key) { 13609 if (/^\w+\[([\w]+)\]$/.test(key)) { 13610 return 'index'; 13611 } 13612 13613 if (/^\w+\[\]$/.test(key)) { 13614 return 'bracket'; 13615 } 13616 13617 return 'default'; 13618 } 13619 13620 function parseQuery(input) { 13621 if (!Type.isString(input)) { 13622 return {}; 13623 } 13624 13625 var url = input.trim().replace(/^[?#&]/, ''); 13626 13627 if (!url) { 13628 return {}; 13629 } 13630 13631 return url.split('&').reduce(function (acc, param) { 13632 var _param$replace$split = param.replace(/\+/g, ' ').split('='), 13633 _param$replace$split2 = babelHelpers.slicedToArray(_param$replace$split, 2), 13634 key = _param$replace$split2[0], 13635 value = _param$replace$split2[1]; 13636 13637 var keyFormat = getKeyFormat(key); 13638 var formatter = getParser(keyFormat); 13639 formatter(key, value, acc); 13640 return acc; 13641 }, {}); 13642 } 13643 13644 var urlExp = /^((\w+):)?(\/\/((\w+)?(:(\w+))?@)?([^\/\?:]+)(:(\d+))?)?(\/?([^\/\?#][^\?#]*)?)?(\?([^#]+))?(#(\w*))?/; 13645 function parseUrl(url) { 13646 var result = url.match(urlExp); 13647 13648 if (Type.isArray(result)) { 13649 var queryParams = parseQuery(result[14]); 13650 return { 13651 useShort: /^\/\//.test(url), 13652 href: result[0] || '', 13653 schema: result[2] || '', 13654 host: result[8] || '', 13655 port: result[10] || '', 13656 path: result[11] || '', 13657 query: result[14] || '', 13658 queryParams: queryParams, 13659 hash: result[16] || '', 13660 username: result[5] || '', 13661 password: result[7] || '', 13662 origin: result[8] || '' 13663 }; 13664 } 13665 13666 return {}; 13667 } 13668 13669 function buildQueryString() { 13670 var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 13671 var queryString = Object.keys(params).reduce(function (acc, key) { 13672 if (Type.isArray(params[key])) {
13673 params[key].forEach(function (paramValue) { 13674 acc.push("".concat(key, "[]=").concat(paramValue)); 13675 }, ''); 13676 } 13677 13678 if (Type.isPlainObject(params[key])) { 13679 Object.keys(params[key]).forEach(function (paramIndex) { 13680 acc.push("".concat(key, "[").concat(paramIndex, "]=").concat(params[key][paramIndex])); 13681 }, ''); 13682 } 13683 13684 if (!Type.isObject(params[key]) && !Type.isArray(params[key])) { 13685 acc.push("".concat(key, "=").concat(params[key])); 13686 } 13687 13688 return acc; 13689 }, []).join('&'); 13690 13691 if (queryString.length > 0) { 13692 return "?".concat(queryString); 13693 } 13694 13695 return queryString; 13696 } 13697 13698 function prepareParamValue(value) { 13699 if (Type.isArray(value)) { 13700 return value.map(function (item) { 13701 return String(item); 13702 }); 13703 } 13704 13705 if (Type.isPlainObject(value)) { 13706 return babelHelpers.objectSpread({}, value); 13707 } 13708 13709 return String(value); 13710 } 13711 13712 var map = new WeakMap(); 13713 /** 13714 * Implements interface for works with URI 13715 * @memberOf BX 13716 */ 13717 13718 var Uri = 13719 /*#__PURE__*/ 13720 function () { 13721 babelHelpers.createClass(Uri, null, [{ 13722 key: "addParam", 13723 value: function addParam(url) { 13724 var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 13725 return new Uri(url).setQueryParams(params).toString(); 13726 } 13727 }, { 13728 key: "removeParam", 13729 value: function removeParam(url, params) { 13730 var _ref; 13731 13732 var removableParams = Type.isArray(params) ? params : [params]; 13733 return (_ref = new Uri(url)).removeQueryParam.apply(_ref, babelHelpers.toConsumableArray(removableParams)).toString(); 13734 } 13735 }]); 13736 13737 function Uri() { 13738 var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; 13739 babelHelpers.classCallCheck(this, Uri); 13740 map.set(this, parseUrl(url)); 13741 } 13742 /** 13743 * Gets schema 13744 * @return {?string} 13745 */ 13746 13747 13748 babelHelpers.createClass(Uri, [{ 13749 key: "getSchema", 13750 value: function getSchema() { 13751 return map.get(this).schema; 13752 } 13753 /** 13754 * Sets schema 13755 * @param {string} schema 13756 * @return {Uri} 13757 */ 13758 13759 }, { 13760 key: "setSchema", 13761 value: function setSchema(schema) { 13762 map.get(this).schema = String(schema); 13763 return this; 13764 } 13765 /** 13766 * Gets host 13767 * @return {?string} 13768 */ 13769 13770 }, { 13771 key: "getHost", 13772 value: function getHost() { 13773 return map.get(this).host; 13774 } 13775 /** 13776 * Sets host 13777 * @param {string} host 13778 * @return {Uri} 13779 */ 13780 13781 }, { 13782 key: "setHost", 13783 value: function setHost(host) { 13784 map.get(this).host = String(host); 13785 return this; 13786 } 13787 /** 13788 * Gets port 13789 * @return {?string} 13790 */ 13791 13792 }, { 13793 key: "getPort", 13794 value: function getPort() { 13795 return map.get(this).port; 13796 } 13797 /** 13798 * Sets port 13799 * @param {String | Number} port 13800 * @return {Uri} 13801 */ 13802 13803 }, { 13804 key: "setPort", 13805 value: function setPort(port) { 13806 map.get(this).port = String(port); 13807 return this; 13808 } 13809 /** 13810 * Gets path 13811 * @return {?string} 13812 */ 13813 13814 }, { 13815 key: "getPath", 13816 value: function getPath() { 13817 return map.get(this).path; 13818 } 13819 /** 13820 * Sets path 13821 * @param {string} path 13822 * @return {Uri} 13823 */ 13824 13825 }, { 13826 key: "setPath", 13827 value: function setPath(path) { 13828 if (!/^\//.test(path)) { 13829 map.get(this).path = "/".concat(String(path)); 13830 return this; 13831 } 13832 13833 map.get(this).path = String(path); 13834 return this; 13835 } 13836 /** 13837 * Gets query 13838 * @return {?string} 13839 */ 13840 13841 }, { 13842 key: "getQuery", 13843 value: function getQuery() { 13844 return buildQueryString(map.get(this).queryParams); 13845 } 13846 /** 13847 * Gets query param value by name 13848 * @param {string} key 13849 * @return {?string} 13850 */ 13851 13852 }, { 13853 key: "getQueryParam", 13854 value: function getQueryParam(key) { 13855 var params = this.getQueryParams(); 13856 13857 if (key in params) { 13858 return params[key]; 13859 } 13860 13861 return null; 13862 } 13863 /** 13864 * Sets query param 13865 * @param {string} key 13866 * @param [value] 13867 * @return {Uri} 13868 */ 13869 13870 }, { 13871 key: "setQueryParam", 13872 value: function setQueryParam(key) { 13873 var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; 13874 map.get(this).queryParams[key] = prepareParamValue(value); 13875 return this; 13876 } 13877 /** 13878 * Gets query params 13879 * @return {Object<string, any>} 13880 */ 13881 13882 }, { 13883 key: "getQueryParams", 13884 value: function getQueryParams() { 13885 return babelHelpers.objectSpread({}, map.get(this).queryParams); 13886 } 13887 /** 13888 * Sets query params 13889 * @param {Object<string, any>} params 13890 * @return {Uri} 13891 */ 13892 13893 }, { 13894 key: "setQueryParams", 13895 value: function setQueryParams() { 13896 var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
13897 var currentParams = this.getQueryParams(); 13898 var newParams = babelHelpers.objectSpread({}, currentParams, params); 13899 Object.keys(newParams).forEach(function (key) { 13900 newParams[key] = prepareParamValue(newParams[key]); 13901 }); 13902 map.get(this).queryParams = newParams; 13903 return this; 13904 } 13905 /** 13906 * Removes query params by name 13907 * @param keys 13908 * @return {Uri} 13909 */ 13910 13911 }, { 13912 key: "removeQueryParam", 13913 value: function removeQueryParam() { 13914 var currentParams = babelHelpers.objectSpread({}, map.get(this).queryParams); 13915 13916 for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) { 13917 keys[_key] = arguments[_key]; 13918 } 13919 13920 keys.forEach(function (key) { 13921 if (key in currentParams) { 13922 delete currentParams[key]; 13923 } 13924 }); 13925 map.get(this).queryParams = currentParams; 13926 return this; 13927 } 13928 /** 13929 * Gets fragment 13930 * @return {?string} 13931 */ 13932 13933 }, { 13934 key: "getFragment", 13935 value: function getFragment() { 13936 return map.get(this).hash; 13937 } 13938 /** 13939 * Sets fragment 13940 * @param {string} hash 13941 * @return {Uri} 13942 */ 13943 13944 }, { 13945 key: "setFragment", 13946 value: function setFragment(hash) { 13947 map.get(this).hash = String(hash); 13948 return this; 13949 } 13950 /** 13951 * Serializes URI 13952 * @return {Object} 13953 */ 13954 13955 }, { 13956 key: "serialize", 13957 value: function serialize() { 13958 var serialized = babelHelpers.objectSpread({}, map.get(this)); 13959 serialized.href = this.toString(); 13960 return serialized; 13961 } 13962 /** 13963 * Gets URI string 13964 * @return {string} 13965 */ 13966 13967 }, { 13968 key: "toString", 13969 value: function toString() { 13970 var data = babelHelpers.objectSpread({}, map.get(this)); 13971 var protocol = data.schema ? "".concat(data.schema, "://") : ''; 13972 13973 if (data.useShort) { 13974 protocol = '//'; 13975 } 13976 13977 var port = function () { 13978 if (Type.isString(data.port) && !['', '80'].includes(data.port)) { 13979 return ":".concat(data.port); 13980 } 13981 13982 return ''; 13983 }(); 13984 13985 var host = this.getHost(); 13986 var path = this.getPath(); 13987 var query = buildQueryString(data.queryParams); 13988 var hash = data.hash ? "#".concat(data.hash) : ''; 13989 return "".concat(host ? protocol : '').concat(host).concat(host ? port : '').concat(path).concat(query).concat(hash); 13990 } 13991 }]); 13992 return Uri; 13993 }(); 13994 13995 /** 13996 * @memberOf BX 13997 */ 13998 var Validation = 13999 /*#__PURE__*/ 14000 function () { 14001 function Validation() { 14002 babelHelpers.classCallCheck(this, Validation); 14003 } 14004 14005 babelHelpers.createClass(Validation, null, [{ 14006 key: "isEmail", 14007 14008 /** 14009 * Checks that value is valid email 14010 * @param value 14011 * @return {boolean} 14012 */ 14013 value: function isEmail(value) { 14014 var exp = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/; 14015 return exp.test(String(value).toLowerCase()); 14016 } 14017 }]); 14018 return Validation; 14019 }(); 14020 14021 var BaseCache = 14022 /*#__PURE__*/ 14023 function () { 14024 function BaseCache() { 14025 babelHelpers.classCallCheck(this, BaseCache); 14026 babelHelpers.defineProperty(this, "storage", new Map()); 14027 } 14028 14029 babelHelpers.createClass(BaseCache, [{ 14030 key: "get", 14031 14032 /** 14033 * Gets cached value or default value 14034 */ 14035 value: function get(key, defaultValue) { 14036 if (!this.storage.has(key)) { 14037 if (Type.isFunction(defaultValue)) { 14038 return defaultValue(); 14039 } 14040 14041 if (!Type.isUndefined(defaultValue)) { 14042 return defaultValue; 14043 } 14044 } 14045 14046 return this.storage.get(key); 14047 } 14048 /** 14049 * Sets cache entry 14050 */ 14051 14052 }, { 14053 key: "set", 14054 value: function set(key, value) { 14055 this.storage.set(key, value); 14056 } 14057 /** 14058 * Deletes cache entry 14059 */ 14060 14061 }, { 14062 key: "delete", 14063 value: function _delete(key) { 14064 this.storage.delete(key); 14065 } 14066 /** 14067 * Checks that storage contains entry with specified key 14068 */ 14069 14070 }, { 14071 key: "has", 14072 value: function has(key) { 14073 return this.storage.has(key); 14074 } 14075 /** 14076 * Gets cached value if exists, 14077 */ 14078 14079 }, { 14080 key: "remember", 14081 value: function remember(key, defaultValue) { 14082 if (!this.storage.has(key)) { 14083 if (Type.isFunction(defaultValue)) { 14084 this.storage.set(key, defaultValue()); 14085 } else if (!Type.isUndefined(defaultValue)) { 14086 this.storage.set(key, defaultValue); 14087 } 14088 } 14089 14090 return this.storage.get(key); 14091 } 14092 /** 14093 * Gets storage size 14094 */ 14095 14096 }, { 14097 key: "size", 14098 value: function size() { 14099 return this.storage.size; 14100 } 14101 /** 14102 * Gets storage keys 14103 */ 14104 14105 }, { 14106 key: "keys", 14107 value: function keys() { 14108 return babelHelpers.toConsumableArray(this.storage.keys()); 14109 } 14110 /** 14111 * Gets storage values 14112 */ 14113 14114 }, { 14115 key: "values", 14116 value: function values() { 14117 return babelHelpers.toConsumableArray(this.storage.values()); 14118 } 14119 }]); 14120 return BaseCache; 14121 }(); 14122 14123 var MemoryCache = 14124 /*#__PURE__*/ 14125 function (_BaseCache) { 14126 babelHelpers.inherits(MemoryCache, _BaseCache); 14127 14128 function MemoryCache() { 14129 var _babelHelpers$getProt; 14130 14131 var _this; 14132 14133 babelHelpers.classCallCheck(this, MemoryCache); 14134 14135 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 14136 args[_key] = arguments[_key]; 14137 } 14138 14139 _this = babelHelpers.possibleConstructorReturn(this, (_babelHelpers$getProt = babelHelpers.getPrototypeOf(MemoryCache)).call.apply(_babelHelpers$getProt, [this].concat(args))); 14140 babelHelpers.defineProperty(babelHelpers.assertThisInitialized(_this), "storage", new Map()); 14141 return _this; 14142 } 14143 14144 return MemoryCache; 14145 }(BaseCache); 14146 14147 var LsStorage = 14148 /*#__PURE__*/ 14149 function () { 14150 function LsStorage() { 14151 babelHelpers.classCallCheck(this, LsStorage); 14152 babelHelpers.defineProperty(this, "stackKey", 'BX.Cache.Storage.LsStorage.stack'); 14153 babelHelpers.defineProperty(this, "stack", null); 14154 } 14155 14156 babelHelpers.createClass(LsStorage, [{ 14157 key: "getStack", 14158 14159 /** 14160 * @private 14161 */ 14162 value: function getStack() { 14163 if (Type.isPlainObject(this.stack)) { 14164 return this.stack; 14165 } 14166 14167 var stack = localStorage.getItem(this.stackKey); 14168 14169 if (Type.isString(stack) && stack !== '') { 14170 var parsedStack = JSON.parse(stack); 14171 14172 if (Type.isPlainObject(parsedStack)) { 14173 this.stack = parsedStack; 14174 return this.stack; 14175 } 14176 } 14177 14178 this.stack = {}; 14179 return this.stack; 14180 } 14181 /** 14182 * @private 14183 */ 14184 14185 }, { 14186 key: "saveStack", 14187 value: function saveStack() { 14188 if (Type.isPlainObject(this.stack)) { 14189 var preparedStack = JSON.stringify(this.stack); 14190 localStorage.setItem(this.stackKey, preparedStack); 14191 } 14192 } 14193 }, { 14194 key: "get", 14195 value: function get(key) {
14196 var stack = this.getStack(); 14197 return stack[key]; 14198 } 14199 }, { 14200 key: "set", 14201 value: function set(key, value) { 14202 var stack = this.getStack(); 14203 stack[key] = value; 14204 this.saveStack(); 14205 } 14206 }, { 14207 key: "delete", 14208 value: function _delete(key) { 14209 var stack = this.getStack(); 14210 14211 if (key in stack) { 14212 delete stack[key]; 14213 } 14214 } 14215 }, { 14216 key: "has", 14217 value: function has(key) { 14218 var stack = this.getStack(); 14219 return key in stack; 14220 } 14221 }, { 14222 key: "keys", 14223 value: function keys() { 14224 var stack = this.getStack(); 14225 return Object.keys(stack); 14226 } 14227 }, { 14228 key: "values", 14229 value: function values() { 14230 var stack = this.getStack(); 14231 return Object.values(stack); 14232 } 14233 }, { 14234 key: "size", 14235 get: function get() { 14236 var stack = this.getStack(); 14237 return Object.keys(stack).length; 14238 } 14239 }]); 14240 return LsStorage; 14241 }(); 14242 14243 var LocalStorageCache = 14244 /*#__PURE__*/ 14245 function (_BaseCache) { 14246 babelHelpers.inherits(LocalStorageCache, _BaseCache); 14247 14248 function LocalStorageCache() { 14249 var _babelHelpers$getProt; 14250 14251 var _this; 14252 14253 babelHelpers.classCallCheck(this, LocalStorageCache); 14254 14255 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 14256 args[_key] = arguments[_key]; 14257 } 14258 14259 _this = babelHelpers.possibleConstructorReturn(this, (_babelHelpers$getProt = babelHelpers.getPrototypeOf(LocalStorageCache)).call.apply(_babelHelpers$getProt, [this].concat(args))); 14260 babelHelpers.defineProperty(babelHelpers.assertThisInitialized(_this), "storage", new LsStorage()); 14261 return _this; 14262 } 14263 14264 return LocalStorageCache; 14265 }(BaseCache); 14266 14267 /** 14268 * @memberOf BX 14269 */ 14270 14271 var Cache = function Cache() { 14272 babelHelpers.classCallCheck(this, Cache); 14273 }; 14274 14275 babelHelpers.defineProperty(Cache, "MemoryCache", MemoryCache); 14276 babelHelpers.defineProperty(Cache, "LocalStorageCache", LocalStorageCache); 14277 14278 function convertPath(path) { 14279 if (Type.isStringFilled(path)) { 14280 return path.split('.').reduce(function (acc, item) { 14281 item.split(/\[['"]?(.+?)['"]?\]/g).forEach(function (key) { 14282 if (Type.isStringFilled(key)) { 14283 acc.push(key); 14284 } 14285 }); 14286 return acc; 14287 }, []); 14288 } 14289 14290 return []; 14291 } 14292 14293 var SettingsCollection = 14294 /*#__PURE__*/ 14295 function () { 14296 function SettingsCollection() { 14297 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 14298 babelHelpers.classCallCheck(this, SettingsCollection); 14299 14300 if (Type.isPlainObject(options)) { 14301 Object.assign(this, options); 14302 } 14303 } 14304 14305 babelHelpers.createClass(SettingsCollection, [{ 14306 key: "get", 14307 value: function get(path) { 14308 var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 14309 var convertedPath = convertPath(path); 14310 return convertedPath.reduce(function (acc, key) { 14311 if (!Type.isNil(acc) && acc !== defaultValue) { 14312 if (!Type.isUndefined(acc[key])) { 14313 return acc[key]; 14314 } 14315 14316 return defaultValue; 14317 } 14318 14319 return acc; 14320 }, this); 14321 } 14322 }]); 14323 return SettingsCollection; 14324 }(); 14325 14326 function deepFreeze(target) { 14327 if (Type.isObject(target)) { 14328 Object.values(target).forEach(function (value) { 14329 deepFreeze(value); 14330 }); 14331 return Object.freeze(target); 14332 } 14333 14334 return target; 14335 } 14336 14337 var settingsStorage = new Map(); 14338 14339 var Extension$1 = 14340 /*#__PURE__*/ 14341 function () { 14342 function Extension() { 14343 babelHelpers.classCallCheck(this, Extension); 14344 } 14345 14346 babelHelpers.createClass(Extension, null, [{ 14347 key: "getSettings", 14348 value: function getSettings(extensionName) { 14349 if (Type.isStringFilled(extensionName)) { 14350 if (settingsStorage.has(extensionName)) { 14351 return settingsStorage.get(extensionName); 14352 } 14353 14354 var settingsScriptNode = document.querySelector("script[data-extension=\"".concat(extensionName, "\"]")); 14355 14356 if (Type.isDomNode(settingsScriptNode)) { 14357 var decodedSettings = function () { 14358 try { 14359 return new SettingsCollection(JSON.parse(settingsScriptNode.innerHTML)); 14360 } catch (error) { 14361 return new SettingsCollection(); 14362 } 14363 }(); 14364 14365 var frozenSettings = deepFreeze(decodedSettings); 14366 settingsStorage.set(extensionName, frozenSettings); 14367 return frozenSettings; 14368 } 14369 } 14370 14371 return deepFreeze(new SettingsCollection()); 14372 } 14373 }]); 14374 return Extension; 14375 }(); 14376 14377 function getElement(element) { 14378 if (Type.isString(element)) { 14379 return document.getElementById(element); 14380 } 14381 14382 return element; 14383 } 14384 14385 function getWindow(element) { 14386 if (Type.isElementNode(element)) { 14387 return element.ownerDocument.parentWindow || element.ownerDocument.defaultView || window; 14388 } 14389 14390 if (Type.isDomNode(element)) { 14391 return element.parentWindow || element.defaultView || window; 14392 } 14393 14394 return window; 14395 } 14396 14397 /* eslint-disable prefer-rest-params */ 14398 14399 var getClass = Reflection.getClass, 14400 namespace = Reflection.namespace; 14401 var message$1 = message; 14402 /** 14403 * @memberOf BX 14404 */ 14405 14406 var replace = Dom.replace, 14407 remove = Dom.remove, 14408 clean = Dom.clean, 14409 insertBefore = Dom.insertBefore, 14410 insertAfter = Dom.insertAfter, 14411 append = Dom.append, 14412 prepend = Dom.prepend, 14413 style = Dom.style, 14414 adjust = Dom.adjust, 14415 create = Dom.create, 14416 isShown = Dom.isShown; 14417 var addClass = function addClass() { 14418 Dom.addClass.apply(Dom, babelHelpers.toConsumableArray(Runtime.merge([], Array.from(arguments), [getElement(arguments[0])]))); 14419 }; 14420 var removeClass = function removeClass() { 14421 Dom.removeClass.apply(Dom, babelHelpers.toConsumableArray(Runtime.merge(Array.from(arguments), [getElement(arguments[0])]))); 14422 }; 14423 var hasClass = function hasClass() { 14424 return Dom.hasClass.apply(Dom, babelHelpers.toConsumableArray(Runtime.merge(Array.from(arguments), [getElement(arguments[0])]))); 14425 }; 14426 var toggleClass = function toggleClass() { 14427 Dom.toggleClass.apply(Dom, babelHelpers.toConsumableArray(Runtime.merge(Array.from(arguments), [getElement(arguments[0])]))); 14428 }; 14429 var cleanNode = function cleanNode(element) { 14430 var removeElement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
14431 var currentElement = getElement(element); 14432 14433 if (Type.isDomNode(currentElement)) { 14434 Dom.clean(currentElement); 14435 14436 if (removeElement) { 14437 Dom.remove(currentElement); 14438 return currentElement; 14439 } 14440 } 14441 14442 return currentElement; 14443 }; 14444 var getCookie = Http.Cookie.get; 14445 var setCookie = function setCookie(name, value) { 14446 var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 14447 var attributes = babelHelpers.objectSpread({}, options); 14448 14449 if (Type.isNumber(attributes.expires)) { 14450 attributes.expires /= 3600 * 24; 14451 } 14452 14453 Http.Cookie.set(name, value, attributes); 14454 }; 14455 var bind$1 = Event.bind, 14456 unbind$1 = Event.unbind, 14457 unbindAll$1 = Event.unbindAll, 14458 bindOnce$1 = Event.bindOnce, 14459 ready$1 = Event.ready; 14460 var debugEnableFlag = debugState, 14461 debugStatus = isDebugEnabled, 14462 debug$1 = debug; 14463 var debugEnable = function debugEnable(value) { 14464 if (value) { 14465 enableDebug(); 14466 } else { 14467 disableDebug(); 14468 } 14469 }; 14470 var clone$1 = Runtime.clone, 14471 loadExt = Runtime.loadExtension, 14472 debounce = Runtime.debounce, 14473 throttle = Runtime.throttle, 14474 html = Runtime.html; // BX.type 14475 var type = babelHelpers.objectSpread({}, Object.getOwnPropertyNames(Type).filter(function (key) { 14476 return !['name', 'length', 'prototype', 'caller', 'arguments'].includes(key); 14477 }).reduce(function (acc, key) { 14478 acc[key] = Type[key]; 14479 return acc; 14480 }, {}), { 14481 isNotEmptyString: function isNotEmptyString(value) { 14482 return Type.isString(value) && value !== ''; 14483 }, 14484 isNotEmptyObject: function isNotEmptyObject(value) { 14485 return Type.isObjectLike(value) && Object.keys(value).length > 0; 14486 }, 14487 isMapKey: Type.isObject, 14488 stringToInt: function stringToInt(value) { 14489 var parsed = parseInt(value); 14490 return !Number.isNaN(parsed) ? parsed : 0; 14491 } 14492 }); // BX.browser 14493 14494 var browser = { 14495 IsOpera: Browser.isOpera, 14496 IsIE: Browser.isIE, 14497 IsIE6: Browser.isIE6, 14498 IsIE7: Browser.isIE7, 14499 IsIE8: Browser.isIE8, 14500 IsIE9: Browser.isIE9, 14501 IsIE10: Browser.isIE10, 14502 IsIE11: Browser.isIE11, 14503 IsSafari: Browser.isSafari, 14504 IsFirefox: Browser.isFirefox, 14505 IsChrome: Browser.isChrome, 14506 DetectIeVersion: Browser.detectIEVersion, 14507 IsMac: Browser.isMac, 14508 IsAndroid: Browser.isAndroid, 14509 isIPad: Browser.isIPad, 14510 isIPhone: Browser.isIPhone, 14511 IsIOS: Browser.isIOS, 14512 IsMobile: Browser.isMobile, 14513 isRetina: Browser.isRetina, 14514 IsDoctype: Browser.isDoctype, 14515 SupportLocalStorage: Browser.isLocalStorageSupported, 14516 addGlobalClass: Browser.addGlobalClass, 14517 DetectAndroidVersion: Browser.detectAndroidVersion, 14518 isPropertySupported: Browser.isPropertySupported, 14519 addGlobalFeatures: Browser.addGlobalFeatures 14520 }; // eslint-disable-next-line 14521 14522 var ajax = window.BX ? window.BX.ajax : function () {}; 14523 function GetWindowScrollSize() { 14524 var doc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; 14525 return { 14526 scrollWidth: doc.documentElement.scrollWidth, 14527 scrollHeight: doc.documentElement.scrollHeight 14528 }; 14529 } 14530 function GetWindowScrollPos() { 14531 var doc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; 14532 var win = getWindow(doc); 14533 return { 14534 scrollLeft: win.pageXOffset, 14535 scrollTop: win.pageYOffset 14536 }; 14537 } 14538 function GetWindowInnerSize() { 14539 var doc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; 14540 var win = getWindow(doc); 14541 return { 14542 innerWidth: win.innerWidth, 14543 innerHeight: win.innerHeight 14544 }; 14545 } 14546 function GetWindowSize() { 14547 var doc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; 14548 return babelHelpers.objectSpread({}, GetWindowInnerSize(doc), GetWindowScrollPos(doc), GetWindowScrollSize(doc)); 14549 } 14550 function GetContext(node) { 14551 return getWindow(node); 14552 } 14553 function pos(element) { 14554 var relative = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 14555 14556 if (!element) { 14557 return new DOMRect().toJSON(); 14558 } 14559 14560 if (element.ownerDocument === document && !relative) { 14561 var clientRect = element.getBoundingClientRect(); 14562 var root = document.documentElement; 14563 var _document = document, 14564 body = _document.body; 14565 return { 14566 top: Math.round(clientRect.top + (root.scrollTop || body.scrollTop)), 14567 left: Math.round(clientRect.left + (root.scrollLeft || body.scrollLeft)), 14568 width: Math.round(clientRect.right - clientRect.left), 14569 height: Math.round(clientRect.bottom - clientRect.top), 14570 right: Math.round(clientRect.right + (root.scrollLeft || body.scrollLeft)), 14571 bottom: Math.round(clientRect.bottom + (root.scrollTop || body.scrollTop)) 14572 }; 14573 } 14574 14575 var x = 0; 14576 var y = 0; 14577 var w = element.offsetWidth; 14578 var h = element.offsetHeight; 14579 var first = true; // eslint-disable-next-line no-param-reassign 14580 14581 for (; element != null; element = element.offsetParent) { 14582 if (!first && relative && BX.is_relative(element)) { 14583 break; 14584 } 14585 14586 x += element.offsetLeft; 14587 y += element.offsetTop; 14588 14589 if (first) { 14590 first = false; // eslint-disable-next-line no-continue 14591 14592 continue; 14593 } 14594 14595 x += Text.toNumber(Dom.style(element, 'border-left-width')); 14596 y += Text.toNumber(Dom.style(element, 'border-top-width')); 14597 } 14598 14599 return new DOMRect(x, y, w, h).toJSON(); 14600 } 14601 function addCustomEvent(eventObject, eventName, eventHandler) { 14602 if (Type.isString(eventObject)) { 14603 eventHandler = eventName; 14604 eventName = eventObject; 14605 eventObject = EventEmitter.GLOBAL_TARGET;
14606 } 14607 14608 if (eventObject === window) { 14609 eventObject = EventEmitter.GLOBAL_TARGET; 14610 } 14611 14612 if (!Type.isObject(eventObject)) { 14613 console.error('The "eventObject" argument must be an object. Received type ' + babelHelpers.typeof(eventObject) + '.'); 14614 return; 14615 } 14616 14617 if (!Type.isStringFilled(eventName)) { 14618 console.error('The "eventName" argument must be a string.'); 14619 return; 14620 } 14621 14622 if (!Type.isFunction(eventHandler)) { 14623 console.error('The "eventHandler" argument must be a function. Received type ' + babelHelpers.typeof(eventHandler) + '.'); 14624 return; 14625 } 14626 14627 eventName = eventName.toLowerCase(); 14628 EventEmitter.subscribe(eventObject, eventName, eventHandler, { 14629 compatMode: true, 14630 useGlobalNaming: true 14631 }); 14632 } 14633 function onCustomEvent(eventObject, eventName, eventParams, secureParams) { 14634 if (Type.isString(eventObject)) { 14635 secureParams = eventParams; 14636 eventParams = eventName; 14637 eventName = eventObject; 14638 eventObject = EventEmitter.GLOBAL_TARGET; 14639 } 14640 14641 if (!Type.isObject(eventObject) || eventObject === window) { 14642 eventObject = EventEmitter.GLOBAL_TARGET;
14643 } 14644 14645 if (!eventParams) { 14646 eventParams = []; 14647 } 14648 14649 eventName = eventName.toLowerCase(); 14650 var event = new BaseEvent(); 14651 event.setData(eventParams); 14652 event.setCompatData(eventParams); 14653 EventEmitter.emit(eventObject, eventName, event, { 14654 cloneData: secureParams === true, 14655 useGlobalNaming: true 14656 }); 14657 } 14658 function removeCustomEvent(eventObject, eventName, eventHandler) { 14659 if (Type.isString(eventObject)) { 14660 eventHandler = eventName; 14661 eventName = eventObject; 14662 eventObject = EventEmitter.GLOBAL_TARGET; 14663 } 14664 14665 if (!Type.isFunction(eventHandler)) { 14666 console.error('The "eventHandler" argument must be a function. Received type ' + babelHelpers.typeof(eventHandler) + '.'); 14667 return; 14668 } 14669 14670 if (eventObject === window) { 14671 eventObject = EventEmitter.GLOBAL_TARGET; 14672 } 14673 14674 eventName = eventName.toLowerCase(); 14675 EventEmitter.unsubscribe(eventObject, eventName, eventHandler, { 14676 useGlobalNaming: true 14677 }); 14678 } 14679 function removeAllCustomEvents(eventObject, eventName) { 14680 if (Type.isString(eventObject)) { 14681 eventName = eventObject; 14682 eventObject = EventEmitter.GLOBAL_TARGET;
14683 } 14684 14685 if (eventObject === window) { 14686 eventObject = EventEmitter.GLOBAL_TARGET; 14687 } 14688 14689 eventName = eventName.toLowerCase(); 14690 EventEmitter.unsubscribeAll(eventObject, eventName, { 14691 useGlobalNaming: true 14692 }); 14693 } 14694 14695 if (global && global.window && global.window.BX) { 14696 Object.assign(global.window.BX, exports); 14697 } 14698 14699 exports.BaseError = BaseError; 14700 exports.Browser = Browser; 14701 exports.Cache = Cache; 14702 exports.Dom = Dom; 14703 exports.Event = Event; 14704 exports.Extension = Extension$1; 14705 exports.GetContext = GetContext; 14706 exports.GetWindowInnerSize = GetWindowInnerSize; 14707 exports.GetWindowScrollPos = GetWindowScrollPos; 14708 exports.GetWindowScrollSize = GetWindowScrollSize; 14709 exports.GetWindowSize = GetWindowSize; 14710 exports.Http = Http; 14711 exports.Loc = Loc; 14712 exports.Reflection = Reflection; 14713 exports.Runtime = Runtime; 14714 exports.Tag = Tag; 14715 exports.Text = Text; 14716 exports.Type = Type; 14717 exports.Uri = Uri; 14718 exports.Validation = Validation; 14719 exports.addClass = addClass; 14720 exports.addCustomEvent = addCustomEvent; 14721 exports.adjust = adjust; 14722 exports.ajax = ajax; 14723 exports.append = append; 14724 exports.bind = bind$1; 14725 exports.bindOnce = bindOnce$1; 14726 exports.browser = browser; 14727 exports.clean = clean; 14728 exports.cleanNode = cleanNode; 14729 exports.clone = clone$1; 14730 exports.create = create; 14731 exports.debounce = debounce; 14732 exports.debug = debug$1; 14733 exports.debugEnable = debugEnable; 14734 exports.debugEnableFlag = debugEnableFlag; 14735 exports.debugStatus = debugStatus; 14736 exports.getClass = getClass; 14737 exports.getCookie = getCookie; 14738 exports.hasClass = hasClass; 14739 exports.html = html; 14740 exports.insertAfter = insertAfter; 14741 exports.insertBefore = insertBefore; 14742 exports.isShown = isShown; 14743 exports.loadExt = loadExt; 14744 exports.message = message$1; 14745 exports.namespace = namespace; 14746 exports.onCustomEvent = onCustomEvent; 14747 exports.pos = pos; 14748 exports.prepend = prepend; 14749 exports.ready = ready$1; 14750 exports.remove = remove; 14751 exports.removeAllCustomEvents = removeAllCustomEvents; 14752 exports.removeClass = removeClass; 14753 exports.removeCustomEvent = removeCustomEvent; 14754 exports.replace = replace; 14755 exports.setCookie = setCookie; 14756 exports.style = style; 14757 exports.throttle = throttle; 14758 exports.toggleClass = toggleClass; 14759 exports.type = type; 14760 exports.unbind = unbind$1; 14761 exports.unbindAll = unbindAll$1; 14762 14763}(this.BX = this.BX || {})); 14764 14765 14766 14767(function(BX) { 14768 /* list of registered proxy functions */ 14769 var proxyList = new WeakMap(); 14770 var deferList = new WeakMap(); 14771 14772 /* List of denied event handlers */ 14773 var deniedEvents = []; 14774 14775 /* list of registered custom events */ 14776 var customEvents = new WeakMap(); 14777 var customEventsCnt = 0; 14778 14779 /* list of external garbage collectors */ 14780 var garbageCollectors = []; 14781 14782 /* list of loaded CSS files */ 14783 var cssList = []; 14784 var cssInit = false; 14785 14786 /* list of loaded JS files */ 14787 var jsList = []; 14788 var jsInit = false; 14789 14790 var eventTypes = { 14791 click: 'MouseEvent', 14792 dblclick: 'MouseEvent', 14793 mousedown: 'MouseEvent', 14794 mousemove: 'MouseEvent', 14795 mouseout: 'MouseEvent', 14796 mouseover: 'MouseEvent', 14797 mouseup: 'MouseEvent', 14798 focus: 'MouseEvent', 14799 blur: 'MouseEvent' 14800 }; 14801 14802 var lastWait = []; 14803 14804 var CHECK_FORM_ELEMENTS = {tagName: /^INPUT|SELECT|TEXTAREA|BUTTON$/i}; 14805 14806 var PRELOADING = 1; 14807 var PRELOADED = 2; 14808 var LOADING = 3; 14809 var LOADED = 4; 14810 var assets = {}; 14811 var isAsync = null; 14812 14813 BX.MSLEFT = 1; 14814 BX.MSMIDDLE = 2; 14815 BX.MSRIGHT = 4; 14816 14817 BX.AM_PM_UPPER = 1; 14818 BX.AM_PM_LOWER = 2; 14819 BX.AM_PM_NONE = false; 14820 14821 BX.ext = function(ob) 14822 { 14823 for (var i in ob) 14824 { 14825 if(ob.hasOwnProperty(i)) 14826 { 14827 this[i] = ob[i]; 14828 } 14829 } 14830 }; 14831 14832 var r = { 14833 script: /<script([^>]*)>/ig, 14834 script_end: /<\/script>/ig, 14835 script_src: /src=["\']([^"\']+)["\']/i, 14836 script_type: /type=["\']([^"\']+)["\']/i, 14837 space: /\s+/, 14838 ltrim: /^[\s\r\n]+/g, 14839 rtrim: /[\s\r\n]+$/g, 14840 style: /<link.*?(rel="stylesheet"|type="text\/css")[^>]*>/i, 14841 style_href: /href=["\']([^"\']+)["\']/i 14842 }; 14843 14844 BX.processHTML = function(data, scriptsRunFirst) 14845 { 14846 var matchScript, matchStyle, matchSrc, matchHref, matchType, scripts = [], styles = []; 14847 var textIndexes = []; 14848 var lastIndex = r.script.lastIndex = r.script_end.lastIndex = 0; 14849 14850 while ((matchScript = r.script.exec(data)) !== null) 14851 { 14852 r.script_end.lastIndex = r.script.lastIndex; 14853 var matchScriptEnd = r.script_end.exec(data); 14854 if (matchScriptEnd === null) 14855 { 14856 break; 14857 } 14858 14859 // skip script tags of special types 14860 var skipTag = false;
14861 if ((matchType = matchScript[1].match(r.script_type)) !== null) 14862 { 14863 if( 14864 matchType[1] == 'text/html' 14865 || matchType[1] == 'text/template' 14866 || matchType[1] == 'extension/settings' 14867 ) 14868 { 14869 skipTag = true; 14870 } 14871 } 14872 14873 if(skipTag) 14874 { 14875 textIndexes.push([lastIndex, r.script_end.lastIndex - lastIndex]); 14876 } 14877 else 14878 { 14879 textIndexes.push([lastIndex, matchScript.index - lastIndex]); 14880 14881 var bRunFirst = scriptsRunFirst || (matchScript[1].indexOf('bxrunfirst') != '-1'); 14882 14883 if ((matchSrc = matchScript[1].match(r.script_src)) !== null) 14884 { 14885 scripts.push({"bRunFirst": bRunFirst, "isInternal": false, "JS": matchSrc[1]}); 14886 } 14887 else 14888 { 14889 var start = matchScript.index + matchScript[0].length; 14890 var js = data.substr(start, matchScriptEnd.index-start); 14891 14892 scripts.push({"bRunFirst": bRunFirst, "isInternal": true, "JS": js}); 14893 } 14894 } 14895 14896 lastIndex = matchScriptEnd.index + 9; 14897 r.script.lastIndex = lastIndex; 14898 } 14899 14900 textIndexes.push([lastIndex, lastIndex === 0 ? data.length : data.length - lastIndex]); 14901 var pureData = ""; 14902 for (var i = 0, length = textIndexes.length; i < length; i++) 14903 { 14904 if (BX.type.isString(data) && BX.type.isFunction(data.substr)) 14905 { 14906 pureData += data.substr(textIndexes[i][0], textIndexes[i][1]); 14907 } 14908 } 14909 14910 while ((matchStyle = pureData.match(r.style)) !== null) 14911 { 14912 if ((matchHref = matchStyle[0].match(r.style_href)) !== null && matchStyle[0].indexOf('media="') < 0) 14913 { 14914 styles.push(matchHref[1]); 14915 } 14916 14917 pureData = pureData.replace(matchStyle[0], ''); 14918 } 14919 14920 return {'HTML': pureData, 'SCRIPT': scripts, 'STYLE': styles}; 14921 }; 14922 14923 /* OO emulation utility */ 14924 BX.extend = function(child, parent) 14925 { 14926 var f = function() {}; 14927 f.prototype = parent.prototype; 14928 14929 child.prototype = new f(); 14930 child.prototype.constructor = child; 14931 14932 child.superclass = parent.prototype; 14933 child.prototype.superclass = parent.prototype; 14934 if(parent.prototype.constructor == Object.prototype.constructor) 14935 { 14936 parent.prototype.constructor = parent; 14937 } 14938 }; 14939 14940 BX.is_subclass_of = function(ob, parent_class) 14941 { 14942 if (ob instanceof parent_class) 14943 return true; 14944 14945 if (parent_class.superclass) 14946 return BX.is_subclass_of(ob, parent_class.superclass); 14947 14948 return false; 14949 }; 14950 14951 BX.clearNodeCache = function() 14952 { 14953 return false; 14954 }; 14955 14956 BX.bitrix_sessid = function() {return BX.message("bitrix_sessid"); }; 14957 14958 /** 14959 * Creates document fragment with child nodes. 14960 * 14961 * @param {Node[]} nodes 14962 * @return {DocumentFragment} 14963 */ 14964 BX.createFragment = function(nodes) 14965 { 14966 var fragment = document.createDocumentFragment(); 14967 14968 if(!BX.type.isArray(nodes)) 14969 { 14970 return fragment; 14971 } 14972 for(var i = 0; i < nodes.length; i++) 14973 { 14974 fragment.appendChild(nodes[i]); 14975 } 14976 14977 return fragment; 14978 }; 14979 14980 /** 14981 * @deprecated 14982 * @use BX.style 14983 * @param element 14984 * @param opacity 14985 */ 14986 BX.setOpacity = function(element, opacity) 14987 { 14988 var opacityValue = parseFloat(opacity); 14989 14990 if (!isNaN(opacityValue) && BX.type.isDomNode(element)) 14991 { 14992 opacityValue = opacityValue < 1 ? opacityValue : opacityValue / 100; 14993 BX.style(element, 'opacity', opacityValue); 14994 } 14995 }; 14996 14997 /** 14998 * @deprecated 14999 * @param el 15000 * @return {*} 15001 */ 15002 BX.hoverEvents = function(el) 15003 { 15004 if (el) 15005 return BX.adjust(el, {events: BX.hoverEvents()}); 15006 else 15007 return {mouseover: BX.hoverEventsHover, mouseout: BX.hoverEventsHout}; 15008 }; 15009 15010 /** 15011 * @deprecated 15012 */ 15013 BX.hoverEventsHover = function(){BX.addClass(this,'bx-hover');this.BXHOVER=true;}; 15014 /** 15015 * @deprecated 15016 */ 15017 BX.hoverEventsHout = function(){BX.removeClass(this,'bx-hover');this.BXHOVER=false;}; 15018 15019 /** 15020 * @deprecated 15021 */ 15022 BX.focusEvents = function(el) 15023 { 15024 if (el) 15025 return BX.adjust(el, {events: BX.focusEvents()}); 15026 else 15027 return {mouseover: BX.focusEventsFocus, mouseout: BX.focusEventsBlur}; 15028 }; 15029 15030 /** 15031 * @deprecated 15032 */ 15033 BX.focusEventsFocus = function(){BX.addClass(this,'bx-focus');this.BXFOCUS=true;}; 15034 /** 15035 * @deprecated 15036 */ 15037 BX.focusEventsBlur = function(){BX.removeClass(this,'bx-focus');this.BXFOCUS=false;}; 15038 15039 BX.setUnselectable = function(node) 15040 { 15041 BX.style(node, { 15042 'userSelect': 'none', 15043 'MozUserSelect': 'none', 15044 'WebkitUserSelect': 'none', 15045 'KhtmlUserSelect': 'none', 15046 }); 15047 node.setAttribute('unSelectable', 'on'); 15048 }; 15049 15050 BX.setSelectable = function(node) 15051 { 15052 BX.style(node, { 15053 'userSelect': null, 15054 'MozUserSelect': null, 15055 'WebkitUserSelect': null, 15056 'KhtmlUserSelect': null, 15057 }); 15058 node.removeAttribute('unSelectable'); 15059 }; 15060 15061 BX.styleIEPropertyName = function(name) 15062 { 15063 if (name == 'float') 15064 name = BX.browser.IsIE() ? 'styleFloat' : 'cssFloat'; 15065 else 15066 { 15067 var res = BX.browser.isPropertySupported(name); 15068 if (res) 15069 { 15070 name = res; 15071 } 15072 else 15073 {
15074 var reg = /(\-([a-z]){1})/g; 15075 if (reg.test(name)) 15076 { 15077 name = name.replace(reg, function () {return arguments[2].toUpperCase();}); 15078 } 15079 } 15080 } 15081 return name; 15082 }; 15083 15084 BX.focus = function(el) 15085 { 15086 try 15087 { 15088 el.focus(); 15089 return true; 15090 } 15091 catch (e) 15092 { 15093 return false; 15094 } 15095 }; 15096 15097 BX.firstChild = function(el) 15098 { 15099 return BX.type.isDomNode(el) ? el.firstElementChild : null; 15100 }; 15101 15102 BX.lastChild = function(el) 15103 { 15104 return BX.type.isDomNode(el) ? el.lastElementChild : null; 15105 }; 15106 15107 BX.previousSibling = function(el) 15108 { 15109 return BX.type.isDomNode(el) ? el.previousElementSibling : null; 15110 }; 15111 15112 BX.nextSibling = function(el) 15113 { 15114 return BX.type.isDomNode(el) ? el.nextElementSibling : null; 15115 }; 15116 15117 /* 15118 params: { 15119 obj : html node 15120 className : className value 15121 recursive : used only for older browsers to optimize the tree traversal, in new browsers the search is always recursively, default - true 15122 } 15123 15124 Search all nodes with className 15125 */ 15126 /** 15127 * @deprecated 15128 * @use .querySelectorAll 15129 * @param obj 15130 * @param className 15131 * @param recursive 15132 * @return {*} 15133 */ 15134 BX.findChildrenByClassName = function(obj, className, recursive) 15135 { 15136 if(!obj || !obj.childNodes) return null; 15137 15138 var result = []; 15139 if (typeof(obj.getElementsByClassName) == 'undefined') 15140 { 15141 recursive = recursive !== false; 15142 result = BX.findChildren(obj, {className : className}, recursive); 15143 } 15144 else 15145 { 15146 var col = obj.getElementsByClassName(className); 15147 for (i=0,l=col.length;i<l;i++) 15148 { 15149 result[i] = col[i]; 15150 } 15151 } 15152 return result; 15153 }; 15154 15155 /* 15156 params: { 15157 obj : html node 15158 className : className value 15159 recursive : used only for older browsers to optimize the tree traversal, in new browsers the search is always recursively, default - true 15160 } 15161 15162 Search first node with className 15163 */ 15164 /** 15165 * @deprecated 15166 * @use .querySelector 15167 * @param obj 15168 * @param className 15169 * @param recursive 15170 * @return {*} 15171 */ 15172 BX.findChildByClassName = function(obj, className, recursive) 15173 { 15174 if(!obj || !obj.childNodes) return null; 15175 15176 var result = null; 15177 if (typeof(obj.getElementsByClassName) == 'undefined') 15178 { 15179 recursive = recursive !== false; 15180 result = BX.findChild(obj, {className : className}, recursive); 15181 } 15182 else 15183 { 15184 var col = obj.getElementsByClassName(className); 15185 if (col && typeof(col[0]) != 'undefined') 15186 { 15187 result = col[0]; 15188 } 15189 else 15190 { 15191 result = null; 15192 } 15193 } 15194 return result; 15195 }; 15196 15197 /* 15198 params: { 15199 tagName|tag : 'tagName', 15200 className|class : 'className', 15201 attribute : {attribute : value, attribute : value} | attribute | [attribute, attribute....], 15202 property : {prop: value, prop: value} | prop | [prop, prop] 15203 } 15204 15205 all values can be RegExps or strings 15206 */ 15207 /** 15208 * @deprecated 15209 * @use .querySelectorAll 15210 * @param obj 15211 * @param params 15212 * @param recursive 15213 * @return {*|Node} 15214 */ 15215 BX.findChildren = function(obj, params, recursive) 15216 { 15217 return BX.findChild(obj, params, recursive, true); 15218 }; 15219 15220 /** 15221 * @deprecated 15222 * @use .querySelectorAll 15223 * @param obj 15224 * @param params 15225 * @param recursive 15226 * @param get_all 15227 * @return {*} 15228 */ 15229 BX.findChild = function(obj, params, recursive, get_all) 15230 { 15231 if(!obj || !obj.childNodes) return null; 15232 15233 recursive = !!recursive; get_all = !!get_all; 15234 15235 var n = obj.childNodes.length, result = []; 15236 15237 for (var j=0; j<n; j++) 15238 { 15239 var child = obj.childNodes[j]; 15240 15241 if (_checkNode(child, params)) 15242 { 15243 if (get_all) 15244 result.push(child); 15245 else 15246 return child; 15247 } 15248 15249 if(recursive == true) 15250 { 15251 var res = BX.findChild(child, params, recursive, get_all); 15252 if (res) 15253 { 15254 if (get_all) 15255 result = BX.util.array_merge(result, res); 15256 else 15257 return res; 15258 } 15259 } 15260 } 15261 15262 if (get_all || result.length > 0) 15263 return result; 15264 else 15265 return null; 15266 }; 15267 15268 /** 15269 * @deprecated 15270 * @use .closest() 15271 * @param obj 15272 * @param params 15273 * @param maxParent 15274 * @return {*} 15275 */ 15276 BX.findParent = function(obj, params, maxParent) 15277 { 15278 if(!obj) 15279 return null; 15280 15281 var o = obj; 15282 while(o.parentNode) 15283 { 15284 var parent = o.parentNode; 15285 15286 if (_checkNode(parent, params)) 15287 return parent; 15288 15289 o = parent; 15290 15291 if (!!maxParent &&
15292 (BX.type.isFunction(maxParent) 15293 || typeof maxParent == 'object')) 15294 { 15295 if (BX.type.isElementNode(maxParent)) 15296 { 15297 if (o == maxParent) 15298 break; 15299 } 15300 else 15301 { 15302 if (_checkNode(o, maxParent)) 15303 break; 15304 } 15305 } 15306 } 15307 return null; 15308 }; 15309 15310 /** 15311 * @deprecated 15312 * @use .querySelector 15313 * @param obj 15314 * @param params 15315 * @return {*} 15316 */ 15317 BX.findNextSibling = function(obj, params) 15318 { 15319 if(!obj) 15320 return null; 15321 var o = obj; 15322 while(o.nextSibling) 15323 { 15324 var sibling = o.nextSibling; 15325 if (_checkNode(sibling, params)) 15326 return sibling; 15327 o = sibling; 15328 } 15329 return null; 15330 }; 15331 15332 /** 15333 * @deprecated 15334 * @use .querySelector 15335 * @param obj 15336 * @param params 15337 * @return {*} 15338 */ 15339 BX.findPreviousSibling = function(obj, params) 15340 { 15341 if(!obj) 15342 return null; 15343 15344 var o = obj; 15345 while(o.previousSibling) 15346 { 15347 var sibling = o.previousSibling; 15348 if(_checkNode(sibling, params)) 15349 return sibling; 15350 o = sibling; 15351 } 15352 return null; 15353 }; 15354 15355 BX.checkNode = function(obj, params) 15356 { 15357 return _checkNode(obj, params); 15358 }; 15359 15360 /** 15361 * @deprecated 15362 * @use .querySelectorAll 15363 * @param form 15364 * @return {Array} 15365 */ 15366 BX.findFormElements = function(form) 15367 { 15368 if (BX.type.isString(form)) 15369 form = document.forms[form]||BX(form); 15370 15371 var res = []; 15372 15373 if (BX.type.isElementNode(form)) 15374 { 15375 if (form.tagName.toUpperCase() == 'FORM') 15376 { 15377 res = form.elements; 15378 } 15379 else 15380 { 15381 res = BX.findChildren(form, CHECK_FORM_ELEMENTS, true); 15382 } 15383 } 15384 15385 return res; 15386 }; 15387 15388 /** 15389 * @deprecated 15390 * @use .contains() 15391 * @param whichNode 15392 * @param forNode 15393 * @return {boolean} 15394 */ 15395 BX.isParentForNode = function(whichNode, forNode) 15396 { 15397 if (BX.type.isDomNode(whichNode) && BX.type.isDomNode(forNode)) 15398 { 15399 return whichNode.contains(forNode); 15400 } 15401 15402 return false; 15403 }; 15404 15405 BX.getCaretPosition = function(node) 15406 { 15407 var pos = 0; 15408 15409 if(node.selectionStart || node.selectionStart == 0) 15410 { 15411 pos = node.selectionStart; 15412 } 15413 else if(document.selection) 15414 { 15415 node.focus(); 15416 var selection = document.selection.createRange(); 15417 selection.moveStart('character', -node.value.length); 15418 pos = selection.text.length; 15419 } 15420 15421 return (pos); 15422 }; 15423 15424 BX.setCaretPosition = function(node, pos) 15425 { 15426 if(!BX.isNodeInDom(node) || BX.isNodeHidden(node) || node.disabled) 15427 { 15428 return; 15429 } 15430 15431 if(node.setSelectionRange) 15432 { 15433 node.focus(); 15434 node.setSelectionRange(pos, pos); 15435 } 15436 else if(node.createTextRange) 15437 { 15438 var range = node.createTextRange(); 15439 range.collapse(true); 15440 range.moveEnd('character', pos); 15441 range.moveStart('character', pos); 15442 range.select(); 15443 } 15444 }; 15445 15446 // access private. use BX.mergeEx instead. 15447 // todo: refactor BX.merge, make it work through BX.mergeEx 15448 BX.merge = function(){ 15449 var arg = Array.prototype.slice.call(arguments); 15450 15451 if(arg.length < 2) 15452 return {}; 15453 15454 var result = arg.shift(); 15455 15456 for(var i = 0; i < arg.length; i++) 15457 { 15458 for(var k in arg[i]){ 15459 15460 if(typeof arg[i] == 'undefined' || arg[i] == null) 15461 continue; 15462 15463 if(arg[i].hasOwnProperty(k)){ 15464 15465 if(typeof arg[i][k] == 'undefined' || arg[i][k] == null) 15466 continue; 15467 15468 if(typeof arg[i][k] == 'object' && !BX.type.isDomNode(arg[i][k]) && (typeof arg[i][k]['isUIWidget'] == 'undefined')){ 15469 15470 // go deeper 15471 15472 var isArray = 'length' in arg[i][k]; 15473 15474 if(typeof result[k] != 'object') 15475 result[k] = isArray ? [] : {}; 15476 15477 if(isArray) 15478 BX.util.array_merge(result[k], arg[i][k]); 15479 else 15480 BX.merge(result[k], arg[i][k]); 15481 15482 }else 15483 result[k] = arg[i][k]; 15484 } 15485 } 15486 } 15487 15488 return result; 15489 }; 15490 15491 BX.mergeEx = function() 15492 { 15493 var arg = Array.prototype.slice.call(arguments); 15494 if(arg.length < 2) 15495 { 15496 return {}; 15497 } 15498 15499 var result = arg.shift(); 15500 for (var i = 0; i < arg.length; i++) 15501 { 15502 for (var k in arg[i]) 15503 { 15504 if (typeof arg[i] == "undefined" || arg[i] == null || !arg[i].hasOwnProperty(k)) 15505 { 15506 continue; 15507 } 15508 15509 if (BX.type.isPlainObject(arg[i][k]) && BX.type.isPlainObject(result[k])) 15510 { 15511 BX.mergeEx(result[k], arg[i][k]); 15512 } 15513 else 15514 { 15515 result[k] = BX.type.isPlainObject(arg[i][k]) ? BX.clone(arg[i][k]) : arg[i][k]; 15516 } 15517 } 15518 } 15519 15520 return result; 15521 }; 15522 15523 BX.getEventButton = function(e) 15524 { 15525 e = e || window.event; 15526 15527 var flags = 0; 15528 15529 if (typeof e.which != 'undefined') 15530 { 15531 switch (e.which) 15532 { 15533 case 1: flags = flags|BX.MSLEFT; break; 15534 case 2: flags = flags|BX.MSMIDDLE; break; 15535 case 3: flags = flags|BX.MSRIGHT; break; 15536 } 15537 } 15538 else if (typeof e.button != 'undefined') 15539 { 15540 flags = event.button; 15541 } 15542 15543 return flags || BX.MSLEFT; 15544 }; 15545 15546 var captured_events = null, _bind = null; 15547 BX.CaptureEvents = function(el_c, evname_c) 15548 { 15549 if (_bind) 15550 return; 15551 15552 _bind = BX.bind; 15553 captured_events = []; 15554 15555 BX.bind = function(el, evname, func) 15556 { 15557 if (el === el_c && evname === evname_c) 15558 captured_events.push(func); 15559 15560 _bind.apply(this, arguments); 15561 } 15562 }; 15563 15564 BX.CaptureEventsGet = function() 15565 { 15566 if (_bind) 15567 { 15568 BX.bind = _bind; 15569 15570 var captured = captured_events; 15571 15572 _bind = null; 15573 captured_events = null; 15574 return captured; 15575 } 15576 return null; 15577 }; 15578 15579 // Don't even try to use it for submit event! 15580 BX.fireEvent = function(ob,ev) 15581 { 15582 var result = false, e = null; 15583 if (BX.type.isDomNode(ob)) 15584 { 15585 result = true; 15586 if (document.createEventObject) 15587 { 15588 // IE 15589 if (eventTypes[ev] != 'MouseEvent') 15590 { 15591 e = document.createEventObject(); 15592 e.type = ev; 15593 result = ob.fireEvent('on' + ev, e); 15594 } 15595 15596 if (ob[ev]) 15597 { 15598 ob[ev](); 15599 } 15600 } 15601 else 15602 {
15603 // non-IE 15604 e = null; 15605 15606 switch (eventTypes[ev]) 15607 { 15608 case 'MouseEvent': 15609 e = document.createEvent('MouseEvent'); 15610 try 15611 { 15612 e.initMouseEvent(ev, true, true, top, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, null); 15613 } 15614 catch (initException) 15615 { 15616 e.initMouseEvent(ev, true, true, window, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, null); 15617 } 15618 15619 break; 15620 default: 15621 e = document.createEvent('Event'); 15622 e.initEvent(ev, true, true); 15623 } 15624 15625 result = ob.dispatchEvent(e); 15626 } 15627 } 15628 15629 return result; 15630 }; 15631 15632 BX.getWheelData = function(e) 15633 { 15634 e = e || window.event; 15635 e.wheelData = e.detail ? e.detail * -1 : e.wheelDelta / 40; 15636 return e.wheelData; 15637 }; 15638 15639 BX.proxy_context = null; 15640 15641 BX.delegate = function (func, thisObject) 15642 { 15643 if (!func || !thisObject) 15644 return func; 15645 15646 return function() { 15647 var cur = BX.proxy_context; 15648 BX.proxy_context = this; 15649 var res = func.apply(thisObject, arguments); 15650 BX.proxy_context = cur; 15651 return res; 15652 } 15653 }; 15654 15655 BX.delegateLater = function (func_name, thisObject, contextObject) 15656 { 15657 return function() 15658 { 15659 if (thisObject[func_name]) 15660 { 15661 var cur = BX.proxy_context; 15662 BX.proxy_context = this; 15663 var res = thisObject[func_name].apply(contextObject||thisObject, arguments); 15664 BX.proxy_context = cur; 15665 return res; 15666 } 15667 return null; 15668 } 15669 }; 15670 15671 BX.proxy = function(func, thisObject) 15672 { 15673 return getObjectDelegate(func, thisObject, proxyList); 15674 }; 15675 15676 BX.defer = function(func, thisObject) 15677 { 15678 if (!!thisObject) 15679 return BX.defer_proxy(func, thisObject); 15680 else 15681 return function() { 15682 var arg = arguments; 15683 setTimeout(function(){func.apply(this,arg)}, 10); 15684 }; 15685 }; 15686 15687 BX.defer_proxy = function(func, thisObject) 15688 { 15689 return getObjectDelegate(func, thisObject, deferList, BX.defer); 15690 }; 15691 15692 /** 15693 * 15694 * @private 15695 */ 15696 function getObjectDelegate(func, thisObject, collection, decorator) 15697 { 15698 if (!BX.type.isFunction(func) || !BX.type.isMapKey(thisObject)) 15699 { 15700 return func; 15701 } 15702 15703 var objectDelegates = collection.get(thisObject); 15704 if (!objectDelegates) 15705 { 15706 objectDelegates = new WeakMap(); 15707 collection.set(thisObject, objectDelegates); 15708 } 15709 15710 var delegate = objectDelegates.get(func); 15711 if (!delegate) 15712 { 15713 delegate = decorator ? decorator(BX.delegate(func, thisObject)) : BX.delegate(func, thisObject); 15714 objectDelegates.set(func, delegate); 15715 } 15716 15717 return delegate; 15718 } 15719 15720 BX.once = function(el, evname, func) 15721 { 15722 var fn = function() 15723 { 15724 BX.unbind(el, evname, fn); 15725 func.apply(this, arguments); 15726 }; 15727 15728 return fn; 15729 }; 15730 15731 BX.bindDelegate = function (elem, eventName, isTarget, handler) 15732 { 15733 var h = BX.delegateEvent(isTarget, handler); 15734 BX.bind(elem, eventName, h); 15735 return h; 15736 }; 15737 15738 BX.delegateEvent = function(isTarget, handler) 15739 { 15740 return function(e) 15741 { 15742 e = e || window.event; 15743 var target = e.target || e.srcElement; 15744 15745 while (target != this) 15746 { 15747 if (_checkNode(target, isTarget)) 15748 { 15749 return handler.call(target, e); 15750 } 15751 if (target && target.parentNode) 15752 target = target.parentNode; 15753 else 15754 break; 15755 } 15756 return null; 15757 } 15758 }; 15759 15760 BX.False = function() {return false;}; 15761 BX.DoNothing = function() {}; 15762 15763 // TODO: also check event handlers set via BX.bind() 15764 BX.denyEvent = function(el, ev) 15765 { 15766 deniedEvents.push([el, ev, el['on' + ev]]); 15767 el['on' + ev] = BX.DoNothing; 15768 }; 15769 15770 BX.allowEvent = function(el, ev) 15771 { 15772 for(var i=0, len=deniedEvents.length; i<len; i++) 15773 { 15774 if (deniedEvents[i][0] == el && deniedEvents[i][1] == ev) 15775 { 15776 el['on' + ev] = deniedEvents[i][2]; 15777 BX.util.deleteFromArray(deniedEvents, i); 15778 return; 15779 } 15780 } 15781 }; 15782 15783 BX.fixEventPageXY = function(event) 15784 { 15785 BX.fixEventPageX(event); 15786 BX.fixEventPageY(event); 15787 return event; 15788 }; 15789 15790 BX.fixEventPageX = function(event) 15791 { 15792 if (event.pageX == null && event.clientX != null) 15793 { 15794 event.pageX = 15795 event.clientX + 15796 (document.documentElement && document.documentElement.scrollLeft || document.body && document.body.scrollLeft || 0) - 15797 (document.documentElement.clientLeft || 0); 15798 } 15799 15800 return event; 15801 }; 15802 15803 BX.fixEventPageY = function(event) 15804 { 15805 if (event.pageY == null && event.clientY != null) 15806 { 15807 event.pageY = 15808 event.clientY + 15809 (document.documentElement && document.documentElement.scrollTop || document.body && document.body.scrollTop || 0) - 15810 (document.documentElement.clientTop || 0); 15811 } 15812 15813 return event; 15814 }; 15815 15816 /** 15817 * @deprecated 15818 * @see e.preventDefault() 15819 */ 15820 BX.PreventDefault = function(e) 15821 { 15822 if(!e) e = window.event; 15823 if(e.stopPropagation) 15824 { 15825 e.preventDefault(); 15826 e.stopPropagation(); 15827 } 15828 else 15829 { 15830 e.cancelBubble = true; 15831 e.returnValue = false;
15832 } 15833 return false; 15834 }; 15835 15836 /** 15837 * @deprecated 15838 * @see e.preventDefault(); 15839 * 15840 * @param e 15841 * @return {boolean} 15842 */ 15843 BX.eventReturnFalse = function(e) 15844 { 15845 e=e||window.event; 15846 if (e && e.preventDefault) e.preventDefault(); 15847 else e.returnValue = false; 15848 return false; 15849 }; 15850 15851 /** 15852 * @deprecated 15853 * @see e.stopPropagation() 15854 * @param e 15855 */ 15856 BX.eventCancelBubble = function(e) 15857 { 15858 e=e||window.event; 15859 if(e && e.stopPropagation) 15860 e.stopPropagation(); 15861 else 15862 e.cancelBubble = true; 15863 }; 15864 15865 BX.bindDebouncedChange = function(node, fn, fnInstant, timeout, ctx) 15866 { 15867 ctx = ctx || window; 15868 timeout = timeout || 300; 15869 15870 var dataTag = 'bx-dc-previous-value'; 15871 BX.data(node, dataTag, node.value); 15872 15873 var act = function(fn, val){ 15874 15875 var pVal = BX.data(node, dataTag); 15876 15877 if(typeof pVal == 'undefined' || pVal != val){ 15878 if(typeof ctx != 'object') 15879 fn(val); 15880 else 15881 fn.apply(ctx, [val]); 15882 } 15883 }; 15884 15885 var actD = BX.debounce(function(){ 15886 var val = node.value; 15887 act(fn, val); 15888 BX.data(node, dataTag, val); 15889 }, timeout); 15890 15891 BX.bind(node, 'keyup', actD); 15892 BX.bind(node, 'change', actD); 15893 BX.bind(node, 'input', actD); 15894 15895 if(BX.type.isFunction(fnInstant)){ 15896 15897 var actI = function(){ 15898 act(fnInstant, node.value); 15899 }; 15900 15901 BX.bind(node, 'keyup', actI); 15902 BX.bind(node, 'change', actI); 15903 BX.bind(node, 'input', actI); 15904 } 15905 }; 15906 15907 BX.parseJSON = function(data, context) 15908 { 15909 var result = null; 15910 if (BX.type.isNotEmptyString(data)) 15911 { 15912 try { 15913 if (data.indexOf("\n") >= 0) 15914 eval('result = ' + data); 15915 else 15916 result = (new Function("return " + data))(); 15917 } catch(e) { 15918 BX.onCustomEvent(context, 'onParseJSONFailure', [data, context]) 15919 } 15920 } 15921 else if(BX.type.isPlainObject(data)) 15922 { 15923 return data; 15924 } 15925 15926 return result; 15927 }; 15928 15929 BX.submit = function(obForm, action_name, action_value, onAfterSubmit) 15930 { 15931 action_name = action_name || 'save'; 15932 if (!obForm['BXFormSubmit_' + action_name]) 15933 { 15934 obForm['BXFormSubmit_' + action_name] = obForm.appendChild(BX.create('INPUT', { 15935 'props': { 15936 'type': 'submit', 15937 'name': action_name, 15938 'value': action_value || 'Y' 15939 }, 15940 'style': { 15941 'display': 'none' 15942 } 15943 })); 15944 } 15945 15946 if (obForm.sessid) 15947 obForm.sessid.value = BX.bitrix_sessid(); 15948 15949 setTimeout(BX.delegate(function() {BX.fireEvent(this, 'click'); if (onAfterSubmit) onAfterSubmit();}, obForm['BXFormSubmit_' + action_name]), 10); 15950 }; 15951 15952 BX.show = function(ob, displayType) 15953 { 15954 if (ob.BXDISPLAY || !_checkDisplay(ob, displayType)) 15955 { 15956 ob.style.display = ob.BXDISPLAY; 15957 } 15958 }; 15959 15960 BX.hide = function(ob, displayType) 15961 { 15962 if (!ob.BXDISPLAY) 15963 _checkDisplay(ob, displayType); 15964 15965 ob.style.display = 'none'; 15966 }; 15967 15968 BX.toggle = function(ob, values) 15969 { 15970 if (!values && BX.type.isElementNode(ob)) 15971 { 15972 var bShow = true; 15973 if (ob.BXDISPLAY) 15974 bShow = !_checkDisplay(ob); 15975 else 15976 bShow = ob.style.display == 'none'; 15977 15978 if (bShow) 15979 BX.show(ob); 15980 else 15981 BX.hide(ob); 15982 } 15983 else if (BX.type.isArray(values)) 15984 { 15985 for (var i=0,len=values.length; i<len; i++) 15986 { 15987 if (ob == values[i]) 15988 { 15989 ob = values[i==len-1 ? 0 : i+1]; 15990 break; 15991 } 15992 } 15993 if (i==len) 15994 ob = values[0]; 15995 } 15996 15997 return ob; 15998 }; 15999 16000 function _checkDisplay(ob, displayType) 16001 { 16002 if (typeof displayType != 'undefined') 16003 ob.BXDISPLAY = displayType; 16004 16005 var d = ob.style.display || BX.style(ob, 'display'); 16006 if (d != 'none') 16007 { 16008 ob.BXDISPLAY = ob.BXDISPLAY || d; 16009 return true; 16010 } 16011 else 16012 { 16013 ob.BXDISPLAY = ob.BXDISPLAY || 'block'; 16014 return false; 16015 } 16016 } 16017 16018 /* some useful util functions */ 16019 16020 BX.util = { 16021 /** 16022 * @deprecated 16023 * @use [].filter(value => !BX.Type.isNil(value)) 16024 * @param ar 16025 * @return {*} 16026 */ 16027 array_values: function(ar) 16028 { 16029 if (!BX.type.isArray(ar)) 16030 return BX.util._array_values_ob(ar); 16031 var arv = []; 16032 for(var i=0,l=ar.length;i<l;i++) 16033 if (ar[i] !== null && typeof ar[i] != 'undefined') 16034 arv.push(ar[i]); 16035 return arv; 16036 }, 16037 16038 /** 16039 * @deprecated 16040 * @use Object.values([]).filter(value => !BX.Type.isNil(value)) 16041 * @param ar 16042 * @return {Array} 16043 * @private 16044 */ 16045 _array_values_ob: function(ar) 16046 { 16047 var arv = []; 16048 for(var i in ar) 16049 if (ar[i] !== null && typeof ar[i] != 'undefined') 16050 arv.push(ar[i]); 16051 return arv; 16052 }, 16053 16054 /** 16055 * @deprecated 16056 * @use 16057 * @param ar 16058 * @return {*} 16059 */ 16060 array_keys: function(ar) 16061 { 16062 if (!BX.type.isArray(ar)) 16063 return BX.util._array_keys_ob(ar); 16064 var arv = []; 16065 for(var i=0,l=ar.length;i<l;i++) 16066 if (ar[i] !== null && typeof ar[i] != 'undefined') 16067 arv.push(i); 16068 return arv; 16069 }, 16070 16071 _array_keys_ob: function(ar) 16072 { 16073 var arv = []; 16074 for(var i in ar) 16075 if (ar[i] !== null && typeof ar[i] != 'undefined') 16076 arv.push(i); 16077 return arv; 16078 }, 16079 16080 object_keys: function(obj) 16081 { 16082 var arv = []; 16083 for(var k in obj) 16084 { 16085 if(obj.hasOwnProperty(k)) 16086 { 16087 arv.push(k); 16088 } 16089 } 16090 return arv; 16091 }, 16092 16093 /** 16094 * @deprecated 16095 * @use firstArr.concat(secondArr); 16096 * @param first 16097 * @param second 16098 * @return {*[]} 16099 */ 16100 array_merge: function(first, second) 16101 { 16102 if (!BX.type.isArray(first)) first = []; 16103 if (!BX.type.isArray(second)) second = []; 16104 16105 var i = first.length, j = 0; 16106 16107 if (typeof second.length === "number") 16108 { 16109 for (var l = second.length; j < l; j++) 16110 { 16111 first[i++] = second[j]; 16112 } 16113 } 16114 else 16115 {
16116 while (second[j] !== undefined) 16117 { 16118 first[i++] = second[j++]; 16119 } 16120 } 16121 16122 first.length = i; 16123 16124 return first; 16125 }, 16126 16127 array_flip: function (object) 16128 { 16129 var newObject = {}; 16130 16131 for (var key in object) 16132 { 16133 newObject[object[key]] = key; 16134 } 16135 16136 return newObject; 16137 }, 16138 16139 array_diff: function(ar1, ar2, hash) 16140 { 16141 hash = BX.type.isFunction(hash) ? hash : null; 16142 var i, length, v, h, map = {}, result = []; 16143 for(i = 0, length = ar2.length; i < length; i++) 16144 { 16145 v = ar2[i]; 16146 h = hash ? hash(v) : v; 16147 map[h] = true; 16148 } 16149 16150 for(i = 0, length = ar1.length; i < length; i++) 16151 { 16152 v = ar1[i]; 16153 h = hash ? hash(v) : v; 16154 if(typeof(map[h]) === "undefined") 16155 { 16156 result.push(v); 16157 } 16158 } 16159 return result; 16160 }, 16161 16162 /** 16163 * @deprecated 16164 * @use Set 16165 */ 16166 array_unique: function(ar) 16167 { 16168 var i=0,j,len=ar.length; 16169 if(len<2) return ar; 16170 16171 for (; i<len-1;i++) 16172 { 16173 for (j=i+1; j<len;j++) 16174 { 16175 if (ar[i]==ar[j]) 16176 { 16177 ar.splice(j--,1); len--; 16178 } 16179 } 16180 } 16181 16182 return ar; 16183 }, 16184 16185 /** 16186 * @deprecated 16187 * @use myArr.includes(needle) 16188 */ 16189 in_array: function(needle, haystack) 16190 { 16191 for(var i=0; i<haystack.length; i++) 16192 { 16193 if(haystack[i] == needle) 16194 return true; 16195 } 16196 return false; 16197 }, 16198 16199 /** 16200 * @deprecated 16201 * @use myArr.findIndex(item => item === needle); 16202 */ 16203 array_search: function(needle, haystack) 16204 { 16205 for(var i=0; i<haystack.length; i++) 16206 { 16207 if(haystack[i] == needle) 16208 return i; 16209 } 16210 return -1; 16211 }, 16212 16213 object_search_key: function(needle, haystack) 16214 { 16215 if (typeof haystack[needle] != 'undefined') 16216 return haystack[needle]; 16217 16218 for(var i in haystack) 16219 { 16220 if (typeof haystack[i] == "object") 16221 { 16222 var result = BX.util.object_search_key(needle, haystack[i]); 16223 if (result !== false) 16224 return result; 16225 } 16226 } 16227 return false; 16228 }, 16229 16230 trim: function(s) 16231 { 16232 if (BX.type.isString(s)) 16233 { 16234 return s.trim(); 16235 } 16236 16237 return s; 16238 }, 16239 16240 urlencode: function(s){return encodeURIComponent(s);}, 16241 16242 // it may also be useful. via sVD. 16243 deleteFromArray: function(ar, ind) {return ar.slice(0, ind).concat(ar.slice(ind + 1));}, 16244 insertIntoArray: function(ar, ind, el) {return ar.slice(0, ind).concat([el]).concat(ar.slice(ind));}, 16245 16246 htmlspecialchars: function(str) 16247 { 16248 return BX.Text.encode(str); 16249 }, 16250 16251 htmlspecialcharsback: function(str) 16252 { 16253 return BX.Text.decode(str); 16254 }, 16255 16256 // Quote regular expression characters plus an optional character 16257 preg_quote: function(str, delimiter) 16258 { 16259 if(!str.replace) 16260 return str; 16261 return str.replace(new RegExp('[.\\\\+*?\\[\\^\\]$(){}=!<>|:\\' + (delimiter || '') + '-]', 'g'), '\\$&'); 16262 }, 16263 16264 jsencode: function(str) 16265 { 16266 if (!str || !str.replace) 16267 return str; 16268 16269 var escapes = 16270 [ 16271 { c: "\\\\", r: "\\\\" }, // should be first 16272 { c: "\\t", r: "\\t" }, 16273 { c: "\\n", r: "\\n" }, 16274 { c: "\\r", r: "\\r" }, 16275 { c: "\"", r: "\\\"" }, 16276 { c: "'", r: "\\'" }, 16277 { c: "<", r: "\\x3C" }, 16278 { c: ">", r: "\\x3E" }, 16279 { c: "\\u2028", r: "\\u2028" }, 16280 { c: "\\u2029", r: "\\u2029" } 16281 ]; 16282 for (var i = 0; i < escapes.length; i++) 16283 str = str.replace(new RegExp(escapes[i].c, 'g'), escapes[i].r); 16284 return str; 16285 }, 16286 16287 getCssName: function(jsName) 16288 { 16289 if (!BX.type.isNotEmptyString(jsName)) 16290 { 16291 return ""; 16292 } 16293 16294 return jsName.replace(/[A-Z]/g, function(match) { 16295 return "-" + match.toLowerCase(); 16296 }); 16297 }, 16298 16299 getJsName: function(cssName) 16300 { 16301 var regex = /\-([a-z]){1}/g; 16302 if (regex.test(cssName)) 16303 { 16304 return cssName.replace(regex, function(match, letter) { 16305 return letter.toUpperCase(); 16306 }); 16307 } 16308 16309 return cssName; 16310 }, 16311 16312 nl2br: function(str) 16313 { 16314 if (!str || !str.replace) 16315 return str; 16316 16317 return str.replace(/([^>])\n/g, '$1<br/>'); 16318 }, 16319 16320 /** 16321 * @deprecated 16322 * @use .padStart() / .padEnd() 16323 * @param input 16324 * @param pad_length 16325 * @param pad_string 16326 * @param pad_type 16327 * @return {*} 16328 */ 16329 str_pad: function(input, pad_length, pad_string, pad_type) 16330 { 16331 pad_string = pad_string || ' '; 16332 pad_type = pad_type || 'right'; 16333 input = input.toString(); 16334 16335 if (pad_type === 'left') 16336 { 16337 return BX.util.str_pad_left(input, pad_length, pad_string); 16338 } 16339 16340 return BX.util.str_pad_right(input, pad_length, pad_string); 16341 }, 16342 16343 str_pad_left: function(input, pad_length, pad_string) 16344 { 16345 return input.toString().padStart(pad_length, pad_string); 16346 }, 16347 16348 str_pad_right: function(input, pad_length, pad_string) 16349 { 16350 return input.toString().padEnd(pad_length, pad_string); 16351 }, 16352 16353 strip_tags: function(str) 16354 { 16355 return str.split(/<[^>]+>/g).join(''); 16356 }, 16357 16358 strip_php_tags: function(str) 16359 { 16360 return str.replace(/<\?(.|[\r\n])*?\?>/g, ''); 16361 }, 16362 16363 popup: function(url, width, height) 16364 { 16365 var w, h; 16366 if(BX.browser.IsOpera()) 16367 { 16368 w = document.body.offsetWidth; 16369 h = document.body.offsetHeight; 16370 } 16371 else 16372 {
16373 w = screen.width; 16374 h = screen.height; 16375 } 16376 return window.open(url, '', 'status=no,scrollbars=yes,resizable=yes,width='+width+',height='+height+',top='+Math.floor((h - height)/2-14)+',left='+Math.floor((w - width)/2-5)); 16377 }, 16378 16379 shuffle: function(array) 16380 { 16381 var temporaryValue, randomIndex; 16382 var currentIndex = array.length; 16383 16384 while (0 !== currentIndex) 16385 { 16386 randomIndex = Math.floor(Math.random() * currentIndex); 16387 currentIndex -= 1; 16388 16389 temporaryValue = array[currentIndex]; 16390 array[currentIndex] = array[randomIndex]; 16391 array[randomIndex] = temporaryValue; 16392 } 16393 16394 return array; 16395 }, 16396 16397 // BX.util.objectSort(object, sortBy, sortDir) - Sort object by property 16398 // function params: 1 - object for sort, 2 - sort by property, 3 - sort direction (asc/desc) 16399 // return: sort array [[objectElement], [objectElement]] in sortDir direction 16400 16401 // example: BX.util.objectSort({'L1': {'name': 'Last'}, 'F1': {'name': 'First'}}, 'name', 'asc'); 16402 // return: [{'name' : 'First'}, {'name' : 'Last'}] 16403 objectSort: function(object, sortBy, sortDir) 16404 { 16405 sortDir = sortDir == 'asc'? 'asc': 'desc'; 16406 16407 var arItems = [], i; 16408 for (i in object) 16409 { 16410 if (object.hasOwnProperty(i) && object[i][sortBy]) 16411 { 16412 arItems.push([i, object[i][sortBy]]); 16413 } 16414 } 16415 16416 if (sortDir == 'asc') 16417 { 16418 arItems.sort(function(i, ii) { 16419 var s1, s2; 16420 if (BX.type.isDate(i[1])) 16421 { 16422 s1 = i[1].getTime(); 16423 } 16424 else if (!isNaN(i[1])) 16425 { 16426 s1 = parseInt(i[1]); 16427 } 16428 else 16429 { 16430 s1 = i[1].toString().toLowerCase(); 16431 } 16432 16433 if (BX.type.isDate(ii[1])) 16434 { 16435 s2 = ii[1].getTime(); 16436 } 16437 else if (!isNaN(ii[1])) 16438 { 16439 s2 = parseInt(ii[1]); 16440 } 16441 else 16442 { 16443 s2 = ii[1].toString().toLowerCase(); 16444 } 16445 16446 if (s1 > s2) 16447 return 1; 16448 else if (s1 < s2) 16449 return -1; 16450 else 16451 return 0; 16452 }); 16453 } 16454 else 16455 { 16456 arItems.sort(function(i, ii) { 16457 var s1, s2; 16458 if (BX.type.isDate(i[1])) 16459 { 16460 s1 = i[1].getTime(); 16461 } 16462 else if (!isNaN(i[1])) 16463 { 16464 s1 = parseInt(i[1]); 16465 } 16466 else 16467 { 16468 s1 = i[1].toString().toLowerCase(); 16469 } 16470 16471 if (BX.type.isDate(ii[1])) 16472 { 16473 s2 = ii[1].getTime(); 16474 } 16475 else if (!isNaN(ii[1])) 16476 { 16477 s2 = parseInt(ii[1]); 16478 } 16479 else 16480 { 16481 s2 = ii[1].toString().toLowerCase(); 16482 } 16483 16484 if (s1 < s2) 16485 return 1; 16486 else if (s1 > s2) 16487 return -1; 16488 else 16489 return 0; 16490 }); 16491 } 16492 16493 var arReturnArray = Array(); 16494 for (i = 0; i < arItems.length; i++) 16495 { 16496 arReturnArray.push(object[arItems[i][0]]); 16497 } 16498 16499 return arReturnArray; 16500 }, 16501 16502 objectMerge: function() 16503 { 16504 return BX.mergeEx.apply(window, arguments); 16505 }, 16506 16507 objectClone : function(object) 16508 { 16509 return BX.clone(object, true); 16510 }, 16511 16512 // #fdf9e5 => {r=253, g=249, b=229} 16513 hex2rgb: function(color) 16514 { 16515 var rgb = color.replace(/[# ]/g,"").replace(/^(.)(.)(.)$/,'$1$1$2$2$3$3').match(/.{2}/g); 16516 for (var i=0; i<3; i++) 16517 { 16518 rgb[i] = parseInt(rgb[i], 16); 16519 } 16520 return {'r':rgb[0],'g':rgb[1],'b':rgb[2]}; 16521 }, 16522 16523 /** 16524 * @deprecated 16525 * @use BX.Uri 16526 * @param url 16527 * @param param 16528 * @return {string} 16529 */ 16530 remove_url_param: function(url, param) 16531 { 16532 return BX.Uri.removeParam(url, param); 16533 }, 16534 16535 /* 16536 {'param1': 'value1', 'param2': 'value2'} 16537 */ 16538 /** 16539 * @deprecated 16540 * @use BX.Uri 16541 * @param url 16542 * @param params 16543 * @return {string} 16544 */ 16545 add_url_param: function(url, params) 16546 { 16547 var preparedParams = Object.entries(params).reduce(function(acc, item) { 16548 acc[item[0]] = BX.type.isArray(item[1]) ? item[1].join() : item[1]; 16549 return acc; 16550 }, {}); 16551 16552 return BX.Uri.addParam(url, preparedParams); 16553 }, 16554 16555 /* 16556 {'param1': 'value1', 'param2': 'value2'} 16557 */ 16558 buildQueryString: function(params) 16559 { 16560 var result = ''; 16561 for (var key in params) 16562 { 16563 var value = params[key]; 16564 if(BX.type.isArray(value)) 16565 { 16566 value.forEach(function(valueElement, index) 16567 { 16568 result += encodeURIComponent(key + "[" + index + "]") + "=" + encodeURIComponent(valueElement) + "&"; 16569 }); 16570 } 16571 else 16572 { 16573 result += encodeURIComponent(key) + "=" + encodeURIComponent(value) + "&"; 16574 } 16575 } 16576 16577 if(result.length > 0) 16578 { 16579 result = result.substr(0, result.length - 1); 16580 } 16581 return result; 16582 }, 16583 16584 even: function(digit) 16585 { 16586 return (parseInt(digit) % 2 == 0); 16587 }, 16588 16589 hashCode: function(str) 16590 { 16591 if(!BX.type.isNotEmptyString(str)) 16592 { 16593 return 0; 16594 } 16595 16596 var hash = 0; 16597 for (var i = 0; i < str.length; i++) 16598 { 16599 var c = str.charCodeAt(i); 16600 hash = ((hash << 5) - hash) + c; 16601 hash = hash & hash; 16602 } 16603 return hash; 16604 }, 16605 16606 getRandomString: function (length) 16607 { 16608 return BX.Text.getRandom(length); 16609 }, 16610 16611 number_format: function(number, decimals, dec_point, thousands_sep) 16612 { 16613 var i, j, kw, kd, km, sign = ''; 16614 decimals = Math.abs(decimals); 16615 if (isNaN(decimals) || decimals < 0) 16616 { 16617 decimals = 2; 16618 } 16619 dec_point = dec_point || ','; 16620 if (typeof thousands_sep === 'undefined') 16621 thousands_sep = '.'; 16622 16623 number = (+number || 0).toFixed(decimals); 16624 if (number < 0) 16625 { 16626 sign = '-'; 16627 number = -number; 16628 } 16629 16630 i = parseInt(number, 10) + ''; 16631 j = (i.length > 3 ? i.length % 3 : 0); 16632 16633 km = (j ? i.substr(0, j) + thousands_sep : ''); 16634 kw = i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thousands_sep); 16635 kd = (decimals ? dec_point + Math.abs(number - i).toFixed(decimals).replace(/-/, '0').slice(2) : ''); 16636 16637 return sign + km + kw + kd; 16638 }, 16639 16640 getExtension: function (url) 16641 { 16642 url = url || ""; 16643 var items = url.split("?")[0].split("."); 16644 return items[items.length-1].toLowerCase(); 16645 }, 16646 addObjectToForm: function(object, form, prefix) 16647 { 16648 if(!BX.type.isString(prefix)) 16649 { 16650 prefix = ""; 16651 } 16652 16653 for(var key in object) 16654 { 16655 if(!object.hasOwnProperty(key)) 16656 { 16657 continue; 16658 } 16659 16660 var value = object[key]; 16661 var name = prefix !== "" ? (prefix + "[" + key + "]") : key; 16662 if(BX.type.isArray(value)) 16663 { 16664 var obj = {}; 16665 for(var i = 0; i < value.length; i++) 16666 { 16667 obj[i] = value[i]; 16668 } 16669 16670 BX.util.addObjectToForm(obj, form, name); 16671 } 16672 else if(BX.type.isPlainObject(value)) 16673 { 16674 BX.util.addObjectToForm(value, form, name); 16675 } 16676 else 16677 { 16678 value = BX.type.isFunction(value.toString) ? value.toString() : ""; 16679 if(value !== "") 16680 { 16681 form.appendChild(BX.create("INPUT", { attrs: { type: "hidden", name: name, value: value } })); 16682 } 16683 } 16684 } 16685 }, 16686 16687 observe: function(object, enable) 16688 {
16689 console.error('BX.util.observe: function is no longer supported by browser.'); 16690 return false; 16691 }, 16692 16693 escapeRegExp: function(str) 16694 { 16695 return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"); 16696 } 16697 }; 16698 16699 BX.validation = { 16700 checkIfEmail: function(s) 16701 { 16702 var atom = "[=a-z0-9_+~'!$&*^`|#%/?{}-]"; 16703 return (new RegExp('^\\s*'+atom+'+(\\.'+atom+'+)*@([a-z0-9-]+\\.)+[a-z0-9-]{2,20}\\s*$', 'i')).test(s); 16704 }, 16705 checkIfPhone: function(s) 16706 { 16707 var regexp = new RegExp( 16708 typeof(BX.PhoneNumber) === "undefined" 16709 ? BX.PhoneNumber.getValidNumberPattern() 16710 : '^\\s*\\+?\s*[0-9(-)\\s]+\\s*$', 16711 'i' 16712 ); 16713 return regexp.test(s); 16714 } 16715 }; 16716 16717 BX.prop = 16718 { 16719 get: function(object, key, defaultValue) 16720 { 16721 return object && object.hasOwnProperty(key) ? object[key] : defaultValue; 16722 }, 16723 getObject: function(object, key, defaultValue) 16724 { 16725 return object && BX.type.isPlainObject(object[key]) ? object[key] : defaultValue; 16726 }, 16727 getElementNode: function(object, key, defaultValue) 16728 { 16729 return object && BX.type.isElementNode(object[key]) ? object[key] : defaultValue; 16730 }, 16731 getArray: function(object, key, defaultValue) 16732 { 16733 return object && BX.type.isArray(object[key]) ? object[key] : defaultValue; 16734 }, 16735 getFunction: function(object, key, defaultValue) 16736 { 16737 return object && BX.type.isFunction(object[key]) ? object[key] : defaultValue; 16738 }, 16739 getNumber: function(object, key, defaultValue) 16740 { 16741 if(!(object && object.hasOwnProperty(key))) 16742 { 16743 return defaultValue; 16744 } 16745 16746 var value = object[key]; 16747 if(BX.type.isNumber(value)) 16748 { 16749 return value; 16750 } 16751 16752 value = parseFloat(value); 16753 return !isNaN(value) ? value : defaultValue; 16754 }, 16755 getInteger: function(object, key, defaultValue) 16756 { 16757 if(!(object && object.hasOwnProperty(key))) 16758 { 16759 return defaultValue; 16760 } 16761 16762 var value = object[key]; 16763 if(BX.type.isNumber(value)) 16764 { 16765 return value; 16766 } 16767 16768 value = parseInt(value); 16769 return !isNaN(value) ? value : defaultValue; 16770 }, 16771 getBoolean: function(object, key, defaultValue) 16772 { 16773 if(!(object && object.hasOwnProperty(key))) 16774 { 16775 return defaultValue; 16776 } 16777 16778 var value = object[key]; 16779 return (BX.type.isBoolean(value) 16780 ? value 16781 : (BX.type.isString(value) ? (value.toLowerCase() === "true") : !!value) 16782 ); 16783 }, 16784 getString: function(object, key, defaultValue) 16785 { 16786 if(!(object && object.hasOwnProperty(key))) 16787 { 16788 return defaultValue; 16789 } 16790 16791 var value = object[key]; 16792 return BX.type.isString(value) ? value : (value ? value.toString() : ''); 16793 }, 16794 extractDate: function(datetime) 16795 { 16796 if(!BX.type.isDate(datetime)) 16797 { 16798 datetime = new Date(); 16799 } 16800 16801 datetime.setHours(0); 16802 datetime.setMinutes(0); 16803 datetime.setSeconds(0); 16804 datetime.setMilliseconds(0); 16805 16806 return datetime; 16807 } 16808 }; 16809 16810 BX.isNodeInDom = function(node, doc) 16811 { 16812 return node === (doc || document) ? true : 16813 (node.parentNode ? BX.isNodeInDom(node.parentNode) : false); 16814 }; 16815 16816 BX.isNodeHidden = function(node) 16817 { 16818 if (node === document) 16819 return false; 16820 else if (BX.style(node, 'display') == 'none') 16821 return true; 16822 else 16823 return (node.parentNode ? BX.isNodeHidden(node.parentNode) : true); 16824 }; 16825 16826 BX.evalPack = function(code) 16827 { 16828 while (code.length > 0) 16829 { 16830 var c = code.shift(); 16831 16832 if (c.TYPE == 'SCRIPT_EXT' || c.TYPE == 'SCRIPT_SRC') 16833 { 16834 BX.loadScript(c.DATA, function() {BX.evalPack(code)}); 16835 return; 16836 } 16837 else if (c.TYPE == 'SCRIPT') 16838 { 16839 BX.evalGlobal(c.DATA); 16840 } 16841 } 16842 }; 16843 16844 BX.evalGlobal = function(data) 16845 { 16846 if (data) 16847 { 16848 var head = document.getElementsByTagName("head")[0] || document.documentElement, 16849 script = document.createElement("script"); 16850 16851 script.type = "text/javascript"; 16852 16853 if (!BX.browser.IsIE()) 16854 { 16855 script.appendChild(document.createTextNode(data)); 16856 } 16857 else 16858 { 16859 script.text = data; 16860 } 16861 16862 head.insertBefore(script, head.firstChild); 16863 head.removeChild(script); 16864 } 16865 }; 16866 16867 BX.garbage = function(call, thisObject) 16868 { 16869 garbageCollectors.push({callback: call, context: thisObject}); 16870 }; 16871 16872 BX.GetDocElement = function (pDoc) 16873 { 16874 pDoc = pDoc || document; 16875 return (BX.browser.IsDoctype(pDoc) ? pDoc.documentElement : pDoc.body); 16876 }; 16877 16878 BX.scrollTop = function(node, val){ 16879 if(typeof val != 'undefined'){ 16880 16881 if(node == window){ 16882 throw new Error('scrollTop() for window is not implemented'); 16883 }else 16884 node.scrollTop = parseInt(val); 16885 16886 }else{ 16887 16888 if(node == window) 16889 return BX.GetWindowScrollPos().scrollTop; 16890 16891 return node.scrollTop; 16892 } 16893 }; 16894 16895 BX.scrollLeft = function(node, val){ 16896 if(typeof val != 'undefined'){ 16897 16898 if(node == window){ 16899 throw new Error('scrollLeft() for window is not implemented'); 16900 }else 16901 node.scrollLeft = parseInt(val); 16902 16903 }else{ 16904 16905 if(node == window) 16906 return BX.GetWindowScrollPos().scrollLeft; 16907 16908 return node.scrollLeft; 16909 } 16910 }; 16911 16912 BX.hide_object = function(ob) 16913 { 16914 ob = BX(ob); 16915 ob.style.position = 'absolute'; 16916 ob.style.top = '-1000px'; 16917 ob.style.left = '-1000px'; 16918 ob.style.height = '10px'; 16919 ob.style.width = '10px'; 16920 }; 16921 16922 BX.is_relative = function(el) 16923 { 16924 var p = BX.style(el, 'position'); 16925 return p == 'relative' || p == 'absolute'; 16926 }; 16927 16928 BX.is_float = function(el) 16929 { 16930 var p = BX.style(el, 'float'); 16931 return p == 'right' || p == 'left'; 16932 }; 16933 16934 BX.is_fixed = function(el) 16935 { 16936 var p = BX.style(el, 'position'); 16937 return p == 'fixed'; 16938 }; 16939 16940 BX.width = function(node, val){ 16941 if(typeof val != 'undefined') 16942 BX.style(node, 'width', parseInt(val)+'px'); 16943 else{ 16944 16945 if(node == window) 16946 return window.innerWidth; 16947 16948 //return parseInt(BX.style(node, 'width')); 16949 return BX.pos(node).width; 16950 } 16951 }; 16952 16953 BX.height = function(node, val){ 16954 if(typeof val != 'undefined') 16955 BX.style(node, 'height', parseInt(val)+'px'); 16956 else{ 16957 16958 if(node == window) 16959 return window.innerHeight; 16960 16961 //return parseInt(BX.style(node, 'height')); 16962 return BX.pos(node).height; 16963 } 16964 }; 16965 16966 BX.align = function(pos, w, h, type) 16967 { 16968 if (type) 16969 type = type.toLowerCase(); 16970 else 16971 type = ''; 16972 16973 var pDoc = document; 16974 if (BX.type.isElementNode(pos)) 16975 { 16976 pDoc = pos.ownerDocument; 16977 pos = BX.pos(pos); 16978 } 16979 16980 var x = pos["left"], y = pos["bottom"]; 16981 16982 var scroll = BX.GetWindowScrollPos(pDoc); 16983 var size = BX.GetWindowInnerSize(pDoc); 16984 16985 if((size.innerWidth + scroll.scrollLeft) - (pos["left"] + w) < 0) 16986 { 16987 if(pos["right"] - w >= 0 ) 16988 x = pos["right"] - w; 16989 else 16990 x = scroll.scrollLeft; 16991 } 16992
16993 if(((size.innerHeight + scroll.scrollTop) - (pos["bottom"] + h) < 0) || ~type.indexOf('top')) 16994 { 16995 if(pos["top"] - h >= 0 || ~type.indexOf('top')) 16996 y = pos["top"] - h; 16997 else 16998 y = scroll.scrollTop; 16999 } 17000 17001 return {'left':x, 'top':y}; 17002 }; 17003 17004 BX.scrollToNode = function(node) 17005 { 17006 var obNode = BX(node); 17007 17008 if (obNode.scrollIntoView) 17009 obNode.scrollIntoView(true); 17010 else 17011 { 17012 var arNodePos = BX.pos(obNode); 17013 window.scrollTo(arNodePos.left, arNodePos.top); 17014 } 17015 }; 17016 17017 /* non-xhr loadings */ 17018 BX.showWait = function(node, msg) 17019 { 17020 node = BX(node) || document.body || document.documentElement; 17021 msg = msg || BX.message('JS_CORE_LOADING'); 17022 17023 var container_id = node.id || Math.random(); 17024 17025 var obMsg = node.bxmsg = document.body.appendChild(BX.create('DIV', { 17026 props: { 17027 id: 'wait_' + container_id 17028 }, 17029 style: { 17030 background: 'url("/bitrix/js/main/core/images/wait.gif") no-repeat scroll 10px center #fcf7d1', 17031 border: '1px solid #E1B52D', 17032 color: 'black', 17033 fontFamily: 'Verdana,Arial,sans-serif', 17034 fontSize: '11px', 17035 padding: '10px 30px 10px 37px', 17036 position: 'absolute', 17037 zIndex:'10000', 17038 textAlign:'center' 17039 }, 17040 text: msg 17041 })); 17042 17043 setTimeout(BX.delegate(_adjustWait, node), 10); 17044 17045 lastWait[lastWait.length] = obMsg; 17046 return obMsg; 17047 }; 17048 17049 BX.closeWait = function(node, obMsg) 17050 { 17051 if(node && !obMsg) 17052 obMsg = node.bxmsg; 17053 if(node && !obMsg && BX.hasClass(node, 'bx-core-waitwindow')) 17054 obMsg = node; 17055 if(node && !obMsg) 17056 obMsg = BX('wait_' + node.id); 17057 if(!obMsg) 17058 obMsg = lastWait.pop(); 17059 17060 if (obMsg && obMsg.parentNode) 17061 { 17062 for (var i=0,len=lastWait.length;i<len;i++) 17063 { 17064 if (obMsg == lastWait[i]) 17065 { 17066 lastWait = BX.util.deleteFromArray(lastWait, i); 17067 break; 17068 } 17069 } 17070 17071 obMsg.parentNode.removeChild(obMsg); 17072 if (node) node.bxmsg = null; 17073 BX.cleanNode(obMsg, true); 17074 } 17075 }; 17076 17077 BX.setJSList = function(scripts) 17078 { 17079 if (BX.type.isArray(scripts)) 17080 { 17081 scripts = scripts.map(function(script) { 17082 return normalizeUrl(script) 17083 }); 17084 17085 jsList = jsList.concat(scripts); 17086 } 17087 }; 17088 17089 BX.getJSList = function() 17090 { 17091 initJsList(); 17092 return jsList; 17093 }; 17094 17095 BX.setCSSList = function(cssFiles) 17096 { 17097 if (BX.type.isArray(cssFiles)) 17098 { 17099 cssFiles = cssFiles.map(function(cssFile) { 17100 return normalizeUrl(cssFile); 17101 }); 17102 17103 cssList = cssList.concat(cssFiles); 17104 } 17105 }; 17106 17107 BX.getCSSList = function() 17108 { 17109 initCssList(); 17110 return cssList; 17111 }; 17112 17113 BX.getJSPath = function(js) 17114 { 17115 return js.replace(/^(http[s]*:)*\/\/[^\/]+/i, ''); 17116 }; 17117 17118 BX.getCSSPath = function(css) 17119 { 17120 return css.replace(/^(http[s]*:)*\/\/[^\/]+/i, ''); 17121 }; 17122 17123 BX.getCDNPath = function(path) 17124 { 17125 return path; 17126 }; 17127 17128 BX.loadScript = function(script, callback, doc) 17129 { 17130 if (BX.type.isString(script)) 17131 { 17132 script = [script]; 17133 } 17134 17135 return BX.load(script, callback, doc); 17136 }; 17137 17138 BX.loadCSS = function(css, doc, win) 17139 { 17140 if (BX.type.isString(css)) 17141 { 17142 css = [css]; 17143 } 17144 17145 if (BX.type.isArray(css)) 17146 { 17147 css = css.map(function(url) { 17148 return { url: url, ext: "css" } 17149 }); 17150 17151 BX.load(css, null, doc); 17152 } 17153 }; 17154 17155 BX.load = function(items, callback, doc) 17156 { 17157 if (!BX.isReady) 17158 { 17159 var _args = arguments; 17160 BX.ready(function() { 17161 BX.load.apply(this, _args); 17162 }); 17163 return null; 17164 } 17165 17166 doc = doc || document; 17167 if (isAsync === null) 17168 { 17169 isAsync = "async" in doc.createElement("script") || "MozAppearance" in doc.documentElement.style || window.opera; 17170 } 17171 17172 return isAsync ? loadAsync(items, callback, doc) : loadAsyncEmulation(items, callback, doc); 17173 }; 17174 17175 BX.convert = 17176 { 17177 toNumber: function(value) 17178 { 17179 if(BX.type.isNumber(value)) 17180 { 17181 return value; 17182 } 17183 17184 value = Number(value); 17185 return !isNaN(value) ? value : 0; 17186 }, 17187 nodeListToArray: function(nodes) 17188 { 17189 try 17190 { 17191 return (Array.prototype.slice.call(nodes, 0)); 17192 } 17193 catch (ex) 17194 { 17195 var ary = []; 17196 for(var i = 0, l = nodes.length; i < l; i++) 17197 { 17198 ary.push(nodes[i]); 17199 } 17200 return ary; 17201 } 17202 } 17203 }; 17204 17205 function loadAsync(items, callback, doc) 17206 { 17207 if (!BX.type.isArray(items)) 17208 { 17209 return; 17210 } 17211 17212 function allLoaded(items) 17213 { 17214 items = items || assets; 17215 for (var name in items) 17216 { 17217 if (items.hasOwnProperty(name) && items[name].state !== LOADED) 17218 { 17219 return false;
17220 } 17221 } 17222 17223 return true; 17224 } 17225 17226 if (!BX.type.isFunction(callback)) 17227 { 17228 callback = null; 17229 } 17230 17231 var itemSet = {}, item, i; 17232 for (i = 0; i < items.length; i++) 17233 { 17234 item = items[i]; 17235 item = getAsset(item); 17236 itemSet[item.name] = item; 17237 } 17238 17239 var callbackWasCalled = false; 17240 if (items.length > 0) 17241 { 17242 for (i = 0; i < items.length; i++) 17243 { 17244 item = items[i]; 17245 item = getAsset(item); 17246 load(item, function () { 17247 if (allLoaded(itemSet)) 17248 { 17249 if (!callbackWasCalled) 17250 { 17251 callback && callback(); 17252 callbackWasCalled = true; 17253 } 17254 17255 } 17256 }, doc); 17257 } 17258 } 17259 else 17260 { 17261 if (typeof callback === 'function') 17262 { 17263 callback(); 17264 callbackWasCalled = true; 17265 } 17266 } 17267 } 17268 17269 function loadAsyncEmulation(items, callback, doc) 17270 { 17271 function onPreload(asset) 17272 { 17273 asset.state = PRELOADED; 17274 if (BX.type.isArray(asset.onpreload) && asset.onpreload) 17275 { 17276 for (var i = 0; i < asset.onpreload.length; i++) 17277 { 17278 asset.onpreload[i].call(); 17279 } 17280 } 17281 } 17282 17283 function preLoad(asset) 17284 { 17285 if (asset.state === undefined) 17286 { 17287 asset.state = PRELOADING; 17288 asset.onpreload = []; 17289 17290 loadAsset( 17291 { url: asset.url, type: "cache", ext: asset.ext}, 17292 function () { onPreload(asset); }, 17293 doc 17294 ); 17295 } 17296 } 17297 17298 if (!BX.type.isArray(items)) 17299 { 17300 return; 17301 } 17302 17303 if (!BX.type.isFunction(callback)) 17304 { 17305 callback = null; 17306 } 17307 17308 var rest = [].slice.call(items, 1); 17309 for (var i = 0; i < rest.length; i++) 17310 { 17311 preLoad(getAsset(rest[i])); 17312 } 17313 17314 load(getAsset(items[0]), items.length === 1 ? callback : function () { 17315 loadAsyncEmulation.apply(null, [rest, callback, doc]); 17316 }, doc); 17317 } 17318 17319 function load(asset, callback, doc) 17320 { 17321 callback = callback || BX.DoNothing; 17322 17323 if (asset.state === LOADED) 17324 { 17325 callback(); 17326 return; 17327 } 17328 17329 if (asset.state === PRELOADING) 17330 { 17331 asset.onpreload.push(function () { 17332 load(asset, callback, doc); 17333 }); 17334 return; 17335 } 17336 17337 asset.state = LOADING; 17338 17339 loadAsset( 17340 asset, 17341 function () { 17342 asset.state = LOADED; 17343 callback(); 17344 }, 17345 doc 17346 ); 17347 } 17348 17349 function loadAsset(asset, callback, doc) 17350 { 17351 callback = callback || BX.DoNothing; 17352 17353 function error(event) 17354 { 17355 ele.onload = ele.onreadystatechange = ele.onerror = null; 17356 callback(); 17357 } 17358 17359 function process(event) 17360 { 17361 event = event || window.event; 17362 if (event.type === "load" || (/loaded|complete/.test(ele.readyState) && (!doc.documentMode || doc.documentMode < 9))) 17363 { 17364 window.clearTimeout(asset.errorTimeout); 17365 window.clearTimeout(asset.cssTimeout); 17366 ele.onload = ele.onreadystatechange = ele.onerror = null; 17367 callback(); 17368 } 17369 } 17370 17371 function isCssLoaded() 17372 { 17373 if (asset.state !== LOADED && asset.cssRetries <= 20) 17374 { 17375 for (var i = 0, l = doc.styleSheets.length; i < l; i++) 17376 { 17377 if (doc.styleSheets[i].href === ele.href) 17378 { 17379 process({"type": "load"}); 17380 return; 17381 } 17382 } 17383 17384 asset.cssRetries++; 17385 asset.cssTimeout = window.setTimeout(isCssLoaded, 250); 17386 } 17387 } 17388 17389 var ele; 17390 var ext = BX.type.isNotEmptyString(asset.ext) ? asset.ext : BX.util.getExtension(asset.url); 17391 17392 if (ext === "css") 17393 { 17394 ele = doc.createElement("link"); 17395 ele.type = "text/" + (asset.type || "css"); 17396 ele.rel = "stylesheet"; 17397 ele.href = asset.url; 17398 17399 asset.cssRetries = 0; 17400 asset.cssTimeout = window.setTimeout(isCssLoaded, 500); 17401 } 17402 else 17403 { 17404 ele = doc.createElement("script"); 17405 ele.type = "text/" + (asset.type || "javascript"); 17406 ele.src = asset.url; 17407 } 17408 17409 ele.onload = ele.onreadystatechange = process; 17410 ele.onerror = error; 17411 17412 ele.async = false; 17413 ele.defer = false; 17414 17415 asset.errorTimeout = window.setTimeout(function () { 17416 error({type: "timeout"}); 17417 }, 7000); 17418 17419 if (ext === "css") 17420 { 17421 cssList.push(normalizeMinUrl(normalizeUrl(asset.url))); 17422 } 17423 else 17424 { 17425 jsList.push(normalizeMinUrl(normalizeUrl(asset.url))); 17426 } 17427 17428 var templateLink = null; 17429 var head = doc.head || doc.getElementsByTagName("head")[0]; 17430 if (ext === "css" && (templateLink = getTemplateLink(head)) !== null) 17431 { 17432 templateLink.parentNode.insertBefore(ele, templateLink); 17433 } 17434 else 17435 { 17436 head.insertBefore(ele, head.lastChild); 17437 } 17438 } 17439 17440 function getAsset(item) 17441 { 17442 var asset = {}; 17443 if (typeof item === "object") 17444 { 17445 asset = item; 17446 asset.name = asset.name ? asset.name : BX.util.hashCode(item.url); 17447 } 17448 else 17449 { 17450 asset = { name: BX.util.hashCode(item), url : item }; 17451 } 17452 17453 var ext = BX.type.isNotEmptyString(asset.ext) ? asset.ext : BX.util.getExtension(asset.url); 17454 if ((ext === "css" && isCssLoaded(asset.url)) || isScriptLoaded(asset.url)) 17455 { 17456 asset.state = LOADED; 17457 } 17458 17459 var existing = assets[asset.name]; 17460 if (existing && existing.url === asset.url) 17461 { 17462 return existing; 17463 } 17464 17465 assets[asset.name] = asset; 17466 return asset; 17467 } 17468 17469 function normalizeUrl(url) 17470 { 17471 if (!BX.type.isNotEmptyString(url)) 17472 { 17473 return ""; 17474 } 17475 17476 url = BX.getJSPath(url); 17477 url = url.replace(/\?[0-9]*$/, ""); 17478 17479 return url; 17480 } 17481 17482 function normalizeMinUrl(url) 17483 { 17484 if (!BX.type.isNotEmptyString(url)) 17485 { 17486 return ""; 17487 } 17488 17489 var minPos = url.indexOf(".min"); 17490 return minPos >= 0 ? url.substr(0, minPos) + url.substr(minPos + 4) : url; 17491 } 17492 17493 function isCssLoaded(fileSrc) 17494 { 17495 initCssList(); 17496 17497 fileSrc = normalizeUrl(fileSrc); 17498 var fileSrcMin = normalizeMinUrl(fileSrc); 17499 17500 return (fileSrc !== fileSrcMin && BX.util.in_array(fileSrcMin, cssList)) || BX.util.in_array(fileSrc, cssList); 17501 } 17502 17503 function initCssList() 17504 { 17505 if(!cssInit) 17506 { 17507 var linksCol = document.getElementsByTagName('link'); 17508 17509 if(!!linksCol && linksCol.length > 0) 17510 { 17511 for(var i = 0; i < linksCol.length; i++) 17512 { 17513 var href = linksCol[i].getAttribute('href'); 17514 if (BX.type.isNotEmptyString(href)) 17515 { 17516 href = normalizeMinUrl(normalizeUrl(href)); 17517 cssList.push(href); 17518 } 17519 } 17520 } 17521 cssInit = true; 17522 } 17523 } 17524 17525 function getTemplateLink(head) 17526 { 17527 var findLink = function(tag) 17528 { 17529 var links = head.getElementsByTagName(tag); 17530 for (var i = 0, length = links.length; i < length; i++) 17531 { 17532 var templateStyle = links[i].getAttribute("data-template-style"); 17533 if (BX.type.isNotEmptyString(templateStyle) && templateStyle == "true") 17534 { 17535 return links[i]; 17536 } 17537 } 17538 17539 return null; 17540 }; 17541 17542 var link = findLink("link"); 17543 if (link === null) 17544 { 17545 link = findLink("style"); 17546 } 17547 17548 return link; 17549 } 17550 17551 function isScriptLoaded(fileSrc) 17552 { 17553 initJsList(); 17554 17555 fileSrc = normalizeUrl(fileSrc); 17556 var fileSrcMin = normalizeMinUrl(fileSrc); 17557 17558 return (fileSrc !== fileSrcMin && BX.util.in_array(fileSrcMin, jsList)) || BX.util.in_array(fileSrc, jsList); 17559 } 17560 17561 function initJsList() 17562 { 17563 if(!jsInit) 17564 { 17565 var scriptCol = document.getElementsByTagName('script'); 17566 17567 if(!!scriptCol && scriptCol.length > 0) 17568 { 17569 for(var i=0; i<scriptCol.length; i++) 17570 { 17571 var src = scriptCol[i].getAttribute('src'); 17572 17573 if (BX.type.isNotEmptyString(src)) 17574 { 17575 src = normalizeMinUrl(normalizeUrl(src)); 17576 jsList.push(src); 17577 } 17578 } 17579 } 17580 jsInit = true; 17581 } 17582 } 17583 17584 function reloadInternal(back_url, bAddClearCache) 17585 { 17586 if (back_url === true) 17587 { 17588 bAddClearCache = true; 17589 back_url = null; 17590 } 17591 17592 var topWindow = BX.PageObject.getRootWindow(); 17593 var new_href = back_url || topWindow.location.href; 17594 17595 var hashpos = new_href.indexOf('#'), hash = ''; 17596 17597 if (hashpos != -1) 17598 { 17599 hash = new_href.substr(hashpos); 17600 new_href = new_href.substr(0, hashpos); 17601 } 17602 17603 if (bAddClearCache && new_href.indexOf('clear_cache=Y') < 0) 17604 new_href += (new_href.indexOf('?') == -1 ? '?' : '&') + 'clear_cache=Y'; 17605 17606 if (hash) 17607 { 17608 // hack for clearing cache in ajax mode components with history emulation 17609 if (bAddClearCache && (hash.substr(0, 5) == 'view/' || hash.substr(0, 6) == '#view/') && hash.indexOf('clear_cache%3DY') < 0) 17610 hash += (hash.indexOf('%3F') == -1 ? '%3F' : '%26') + 'clear_cache%3DY'; 17611 17612 new_href = new_href.replace(/(\?|\&)_r=[\d]*/, ''); 17613 new_href += (new_href.indexOf('?') == -1 ? '?' : '&') + '_r='+Math.round(Math.random()*10000) + hash; 17614 } 17615 17616 topWindow.location.href = new_href; 17617 } 17618 17619 BX.reload = function(back_url, bAddClearCache) 17620 { 17621 if (window !== window.top) 17622 { 17623 BX.Runtime 17624 .loadExtension('main.pageobject') 17625 .then(function() { 17626 reloadInternal(back_url, bAddClearCache); 17627 }); 17628 } 17629 else 17630 { 17631 reloadInternal(back_url, bAddClearCache); 17632 } 17633 }; 17634 17635 BX.clearCache = function() 17636 { 17637 BX.showWait(); 17638 BX.reload(true); 17639 }; 17640 17641 BX.template = function(tpl, callback, bKillTpl) 17642 { 17643 BX.ready(function() { 17644 _processTpl(BX(tpl), callback, bKillTpl); 17645 }); 17646 }; 17647 17648 BX.isAmPmMode = function(returnConst) 17649 { 17650 if (returnConst === true) 17651 { 17652 return BX.message.AMPM_MODE; 17653 } 17654 return BX.message.AMPM_MODE !== false; 17655 }; 17656 17657 BX.formatDate = function(date, format) 17658 { 17659 date = date || new Date(); 17660 17661 var bTime = date.getHours() || date.getMinutes() || date.getSeconds(), 17662 str = !!format 17663 ? format : 17664 (bTime ? BX.message('FORMAT_DATETIME') : BX.message('FORMAT_DATE') 17665 ); 17666 17667 return str.replace(/YYYY/ig, date.getFullYear()) 17668 .replace(/MMMM/ig, BX.util.str_pad_left((date.getMonth()+1).toString(), 2, '0')) 17669 .replace(/MM/ig, BX.util.str_pad_left((date.getMonth()+1).toString(), 2, '0')) 17670 .replace(/DD/ig, BX.util.str_pad_left(date.getDate().toString(), 2, '0')) 17671 .replace(/HH/ig, BX.util.str_pad_left(date.getHours().toString(), 2, '0')) 17672 .replace(/MI/ig, BX.util.str_pad_left(date.getMinutes().toString(), 2, '0')) 17673 .replace(/SS/ig, BX.util.str_pad_left(date.getSeconds().toString(), 2, '0')); 17674 }; 17675 BX.formatName = function(user, template, login) 17676 { 17677 user = user || {}; 17678 template = (template || ''); 17679 var replacement = { 17680 TITLE : (user["TITLE"] || ''), 17681 NAME : (user["NAME"] || ''),
17682 LAST_NAME : (user["LAST_NAME"] || ''), 17683 SECOND_NAME : (user["SECOND_NAME"] || ''), 17684 LOGIN : (user["LOGIN"] || ''), 17685 NAME_SHORT : user["NAME"] ? user["NAME"].substr(0, 1) + '.' : '', 17686 LAST_NAME_SHORT : user["LAST_NAME"] ? user["LAST_NAME"].substr(0, 1) + '.' : '', 17687 SECOND_NAME_SHORT : user["SECOND_NAME"] ? user["SECOND_NAME"].substr(0, 1) + '.' : '', 17688 EMAIL : (user["EMAIL"] || ''), 17689 ID : (user["ID"] || ''), 17690 NOBR : "", 17691 '/NOBR' : "" 17692 }, result = template; 17693 for (var ii in replacement) 17694 { 17695 if (replacement.hasOwnProperty(ii)) 17696 { 17697 result = result.replace("#" + ii+ "#", replacement[ii]) 17698 } 17699 } 17700 result = result.replace(/([\s]+)/gi, " ").trim(); 17701 if (result == "") 17702 { 17703 result = (login == "Y" ? replacement["LOGIN"] : ""); 17704 result = (result == "" ? "Noname" : result); 17705 } 17706 return result; 17707 }; 17708 17709 BX.getNumMonth = function(month) 17710 { 17711 var wordMonthCut = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec']; 17712 var wordMonth = ['january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december']; 17713 17714 var q = month.toUpperCase(); 17715 for (i = 1; i <= 12; i++) 17716 { 17717 if (q == BX.message('MON_'+i).toUpperCase() || q == BX.message('MONTH_'+i).toUpperCase() || q == wordMonthCut[i-1].toUpperCase() || q == wordMonth[i-1].toUpperCase()) 17718 { 17719 return i; 17720 } 17721 } 17722 return month; 17723 }; 17724 17725 BX.parseDate = function(str, bUTC, formatDate, formatDatetime) 17726 { 17727 if (BX.type.isNotEmptyString(str)) 17728 { 17729 if (!formatDate) 17730 formatDate = BX.message('FORMAT_DATE'); 17731 if (!formatDatetime) 17732 formatDatetime = BX.message('FORMAT_DATETIME'); 17733 17734 var regMonths = ''; 17735 for (i = 1; i <= 12; i++) 17736 { 17737 regMonths = regMonths + '|' + BX.message('MON_'+i); 17738 } 17739
17740 var expr = new RegExp('([0-9]+|[a-z]+' + regMonths + ')', 'ig'); 17741 var aDate = str.match(expr), 17742 aFormat = formatDate.match(/(DD|MI|MMMM|MM|M|YYYY)/ig), 17743 i, cnt, 17744 aDateArgs=[], aFormatArgs=[], 17745 aResult={}; 17746 17747 if (!aDate) 17748 return null; 17749 17750 if(aDate.length > aFormat.length) 17751 { 17752 aFormat = formatDatetime.match(/(DD|MI|MMMM|MM|M|YYYY|HH|H|SS|TT|T|GG|G)/ig); 17753 } 17754 17755 for(i = 0, cnt = aDate.length; i < cnt; i++) 17756 { 17757 if(BX.util.trim(aDate[i]) != '') 17758 { 17759 aDateArgs[aDateArgs.length] = aDate[i]; 17760 } 17761 } 17762 17763 for(i = 0, cnt = aFormat.length; i < cnt; i++) 17764 { 17765 if(BX.util.trim(aFormat[i]) != '') 17766 { 17767 aFormatArgs[aFormatArgs.length] = aFormat[i]; 17768 } 17769 } 17770 17771 17772 var m = BX.util.array_search('MMMM', aFormatArgs); 17773 if (m > 0) 17774 { 17775 aDateArgs[m] = BX.getNumMonth(aDateArgs[m]); 17776 aFormatArgs[m] = "MM"; 17777 } 17778 else 17779 { 17780 m = BX.util.array_search('M', aFormatArgs); 17781 if (m > 0) 17782 { 17783 aDateArgs[m] = BX.getNumMonth(aDateArgs[m]); 17784 aFormatArgs[m] = "MM"; 17785 } 17786 } 17787 17788 for(i = 0, cnt = aFormatArgs.length; i < cnt; i++) 17789 { 17790 var k = aFormatArgs[i].toUpperCase(); 17791 aResult[k] = k == 'T' || k == 'TT' ? aDateArgs[i] : parseInt(aDateArgs[i], 10); 17792 } 17793 17794 if(aResult['DD'] > 0 && aResult['MM'] > 0 && aResult['YYYY'] > 0) 17795 { 17796 var d = new Date(); 17797 17798 if(bUTC) 17799 { 17800 d.setUTCDate(1); 17801 d.setUTCFullYear(aResult['YYYY']); 17802 d.setUTCMonth(aResult['MM'] - 1); 17803 d.setUTCDate(aResult['DD']); 17804 d.setUTCHours(0, 0, 0, 0); 17805 } 17806 else 17807 { 17808 d.setDate(1); 17809 d.setFullYear(aResult['YYYY']); 17810 d.setMonth(aResult['MM'] - 1); 17811 d.setDate(aResult['DD']); 17812 d.setHours(0, 0, 0, 0); 17813 } 17814 17815 if( 17816 (!isNaN(aResult['HH']) || !isNaN(aResult['GG']) || !isNaN(aResult['H']) || !isNaN(aResult['G'])) 17817 && !isNaN(aResult['MI']) 17818 ) 17819 { 17820 if (!isNaN(aResult['H']) || !isNaN(aResult['G'])) 17821 { 17822 var bPM = (aResult['T']||aResult['TT']||'am').toUpperCase()=='PM'; 17823 var h = parseInt(aResult['H']||aResult['G']||0, 10); 17824 if(bPM) 17825 { 17826 aResult['HH'] = h + (h == 12 ? 0 : 12); 17827 } 17828 else 17829 { 17830 aResult['HH'] = h < 12 ? h : 0; 17831 } 17832 } 17833 else 17834 { 17835 aResult['HH'] = parseInt(aResult['HH']||aResult['GG']||0, 10); 17836 } 17837 17838 if (isNaN(aResult['SS'])) 17839 aResult['SS'] = 0; 17840 17841 if(bUTC) 17842 { 17843 d.setUTCHours(aResult['HH'], aResult['MI'], aResult['SS']); 17844 } 17845 else 17846 { 17847 d.setHours(aResult['HH'], aResult['MI'], aResult['SS']); 17848 } 17849 } 17850 17851 return d; 17852 } 17853 } 17854 17855 return null; 17856 }; 17857 17858 BX.selectUtils = 17859 { 17860 addNewOption: function(oSelect, opt_value, opt_name, do_sort, check_unique) 17861 { 17862 oSelect = BX(oSelect); 17863 if(oSelect) 17864 { 17865 var n = oSelect.length; 17866 if(check_unique !== false) 17867 { 17868 for(var i=0;i<n;i++) 17869 { 17870 if(oSelect[i].value==opt_value) 17871 { 17872 return; 17873 } 17874 } 17875 } 17876 17877 oSelect.options[n] = new Option(opt_name, opt_value, false, false); 17878 } 17879 17880 if(do_sort === true) 17881 { 17882 this.sortSelect(oSelect); 17883 } 17884 }, 17885 17886 deleteOption: function(oSelect, opt_value) 17887 { 17888 oSelect = BX(oSelect); 17889 if(oSelect) 17890 { 17891 for(var i=0;i<oSelect.length;i++) 17892 { 17893 if(oSelect[i].value==opt_value) 17894 { 17895 oSelect.remove(i); 17896 break; 17897 } 17898 } 17899 } 17900 }, 17901 17902 deleteSelectedOptions: function(oSelect) 17903 { 17904 oSelect = BX(oSelect); 17905 if(oSelect) 17906 { 17907 var i=0; 17908 while(i<oSelect.length) 17909 { 17910 if(oSelect[i].selected) 17911 { 17912 oSelect[i].selected=false; 17913 oSelect.remove(i); 17914 } 17915 else 17916 { 17917 i++; 17918 } 17919 } 17920 } 17921 }, 17922 17923 deleteAllOptions: function(oSelect) 17924 { 17925 oSelect = BX(oSelect); 17926 if(oSelect) 17927 { 17928 for(var i=oSelect.length-1; i>=0; i--) 17929 { 17930 oSelect.remove(i); 17931 } 17932 } 17933 }, 17934 17935 optionCompare: function(record1, record2) 17936 { 17937 var value1 = record1.optText.toLowerCase(); 17938 var value2 = record2.optText.toLowerCase(); 17939 if (value1 > value2) return(1); 17940 if (value1 < value2) return(-1); 17941 return(0); 17942 }, 17943 17944 sortSelect: function(oSelect) 17945 { 17946 oSelect = BX(oSelect); 17947 if(oSelect) 17948 { 17949 var myOptions = []; 17950 var n = oSelect.options.length; 17951 var i; 17952 for (i=0;i<n;i++) 17953 { 17954 myOptions[i] = { 17955 optText:oSelect[i].text, 17956 optValue:oSelect[i].value 17957 }; 17958 } 17959 myOptions.sort(this.optionCompare); 17960 oSelect.length=0; 17961 n = myOptions.length; 17962 for(i=0;i<n;i++) 17963 { 17964 oSelect[i] = new Option(myOptions[i].optText, myOptions[i].optValue, false, false); 17965 } 17966 } 17967 }, 17968 17969 selectAllOptions: function(oSelect) 17970 { 17971 oSelect = BX(oSelect); 17972 if(oSelect) 17973 { 17974 var n = oSelect.length; 17975 for(var i=0;i<n;i++) 17976 { 17977 oSelect[i].selected=true; 17978 } 17979 } 17980 }, 17981 17982 selectOption: function(oSelect, opt_value) 17983 { 17984 oSelect = BX(oSelect); 17985 if(oSelect) 17986 { 17987 var n = oSelect.length; 17988 for(var i=0;i<n;i++) 17989 { 17990 oSelect[i].selected = (oSelect[i].value == opt_value); 17991 } 17992 } 17993 }, 17994 17995 addSelectedOptions: function(oSelect, to_select_id, check_unique, do_sort) 17996 { 17997 oSelect = BX(oSelect); 17998 if(!oSelect) 17999 return; 18000 var n = oSelect.length; 18001 for(var i=0; i<n; i++) 18002 if(oSelect[i].selected) 18003 this.addNewOption(to_select_id, oSelect[i].value, oSelect[i].text, do_sort, check_unique); 18004 }, 18005 18006 moveOptionsUp: function(oSelect) 18007 { 18008 oSelect = BX(oSelect); 18009 if(!oSelect) 18010 return; 18011 var n = oSelect.length; 18012 for(var i=0; i<n; i++) 18013 { 18014 if(oSelect[i].selected && i>0 && oSelect[i-1].selected == false) 18015 { 18016 var option = new Option(oSelect[i].text, oSelect[i].value); 18017 oSelect[i] = new Option(oSelect[i-1].text, oSelect[i-1].value); 18018 oSelect[i].selected = false;
18019 oSelect[i-1] = option; 18020 oSelect[i-1].selected = true; 18021 } 18022 } 18023 }, 18024 18025 moveOptionsDown: function(oSelect) 18026 { 18027 oSelect = BX(oSelect); 18028 if(!oSelect) 18029 return; 18030 var n = oSelect.length; 18031 for(var i=n-1; i>=0; i--) 18032 { 18033 if(oSelect[i].selected && i<n-1 && oSelect[i+1].selected == false) 18034 { 18035 var option = new Option(oSelect[i].text, oSelect[i].value); 18036 oSelect[i] = new Option(oSelect[i+1].text, oSelect[i+1].value); 18037 oSelect[i].selected = false; 18038 oSelect[i+1] = option; 18039 oSelect[i+1].selected = true; 18040 } 18041 } 18042 } 18043 }; 18044 18045 BX.getEventTarget = function(e) 18046 { 18047 if(e.target) 18048 { 18049 return e.target; 18050 } 18051 else if(e.srcElement) 18052 { 18053 return e.srcElement; 18054 } 18055 return null; 18056 }; 18057 18058 /******* HINT ***************/ 18059// if function has 2 params - the 2nd one is hint html. otherwise hint_html is third and hint_title - 2nd; 18060// '<div onmouseover="BX.hint(this, 'This is <b>Hint</b>')"'>; 18061// BX.hint(el, 'This is <b>Hint</b>') - this won't work, use constructor 18062 BX.hint = function(el, hint_title, hint_html, hint_id) 18063 { 18064 if (null == hint_html) 18065 { 18066 hint_html = hint_title; 18067 hint_title = ''; 18068 } 18069 18070 if (null == el.BXHINT) 18071 { 18072 el.BXHINT = new BX.CHint({ 18073 parent: el, hint: hint_html, title: hint_title, id: hint_id 18074 }); 18075 el.BXHINT.Show(); 18076 } 18077 }; 18078 18079 BX.hint_replace = function(el, hint_title, hint_html) 18080 { 18081 if (null == hint_html) 18082 { 18083 hint_html = hint_title; 18084 hint_title = ''; 18085 } 18086 18087 if (!el || !el.parentNode || !hint_html) 18088 return null; 18089 18090 var obHint = new BX.CHint({ 18091 hint: hint_html, 18092 title: hint_title 18093 }); 18094 18095 obHint.CreateParent(); 18096 18097 el.parentNode.insertBefore(obHint.PARENT, el); 18098 el.parentNode.removeChild(el); 18099 18100 obHint.PARENT.style.marginLeft = '5px'; 18101 18102 return el; 18103 }; 18104 18105 BX.CHint = function(params) 18106 { 18107 this.PARENT = BX(params.parent); 18108 18109 this.HINT = params.hint; 18110 this.HINT_TITLE = params.title; 18111 18112 this.PARAMS = {}; 18113 for (var i in this.defaultSettings) 18114 { 18115 if (null == params[i]) 18116 this.PARAMS[i] = this.defaultSettings[i]; 18117 else 18118 this.PARAMS[i] = params[i]; 18119 } 18120 18121 if (null != params.id) 18122 this.ID = params.id; 18123 18124 this.timer = null; 18125 this.bInited = false; 18126 this.msover = true; 18127 18128 if (this.PARAMS.showOnce) 18129 { 18130 this.__show(); 18131 this.msover = false; 18132 this.timer = setTimeout(BX.proxy(this.__hide, this), this.PARAMS.hide_timeout); 18133 } 18134 else if (this.PARENT) 18135 { 18136 BX.bind(this.PARENT, 'mouseover', BX.proxy(this.Show, this)); 18137 BX.bind(this.PARENT, 'mouseout', BX.proxy(this.Hide, this)); 18138 } 18139 }; 18140 18141 BX.CHint.openHints = new Set(); 18142 18143 BX.CHint.globalDisabled = false; 18144 18145 BX.CHint.handleMenuOpen = function() { 18146 BX.CHint.globalDisabled = true; 18147 18148 BX.CHint.openHints.forEach(function(hint) { 18149 hint.__hide_immediately(); 18150 }); 18151 }; 18152 18153 BX.CHint.handleMenuClose = function() { 18154 BX.CHint.globalDisabled = false; 18155 }; 18156 18157 BX.addCustomEvent('onMenuOpen', BX.CHint.handleMenuOpen); 18158 BX.addCustomEvent('onMenuClose', BX.CHint.handleMenuClose); 18159 18160 BX.CHint.prototype.defaultSettings = { 18161 show_timeout: 1000, 18162 hide_timeout: 500, 18163 dx: 2, 18164 showOnce: false, 18165 preventHide: true, 18166 min_width: 250 18167 }; 18168 18169 BX.CHint.prototype.CreateParent = function(element, params) 18170 { 18171 if (this.PARENT) 18172 { 18173 BX.unbind(this.PARENT, 'mouseover', BX.proxy(this.Show, this)); 18174 BX.unbind(this.PARENT, 'mouseout', BX.proxy(this.Hide, this)); 18175 } 18176 18177 if (!params) params = {}; 18178 var type = 'icon'; 18179 18180 if (params.type && (params.type == "link" || params.type == "icon")) 18181 type = params.type; 18182 18183 if (element) 18184 type = "element"; 18185 18186 if (type == "icon") 18187 { 18188 element = BX.create('IMG', { 18189 props: { 18190 src: params.iconSrc 18191 ? params.iconSrc 18192 : "/bitrix/js/main/core/images/hint.gif" 18193 } 18194 }); 18195 } 18196 else if (type == "link") 18197 { 18198 element = BX.create("A", { 18199 props: {href: 'javascript:void(0)'}, 18200 html: '[?]' 18201 }); 18202 } 18203 18204 this.PARENT = element; 18205 18206 BX.bind(this.PARENT, 'mouseover', BX.proxy(this.Show, this)); 18207 BX.bind(this.PARENT, 'mouseout', BX.proxy(this.Hide, this)); 18208 18209 return this.PARENT; 18210 }; 18211 18212 BX.CHint.prototype.Show = function() 18213 { 18214 this.msover = true; 18215 18216 if (null != this.timer) 18217 clearTimeout(this.timer); 18218 18219 this.timer = setTimeout(BX.proxy(this.__show, this), this.PARAMS.show_timeout); 18220 }; 18221 18222 BX.CHint.prototype.Hide = function() 18223 { 18224 this.msover = false;
18225 18226 if (null != this.timer) 18227 clearTimeout(this.timer); 18228 18229 this.timer = setTimeout(BX.proxy(this.__hide, this), this.PARAMS.hide_timeout); 18230 }; 18231 18232 BX.CHint.prototype.__show = function() 18233 { 18234 if (!this.msover || this.disabled || BX.CHint.globalDisabled) return; 18235 if (!this.bInited) this.Init(); 18236 18237 if (this.prepareAdjustPos()) 18238 { 18239 this.DIV.style.display = 'block'; 18240 this.adjustPos(); 18241 18242 BX.CHint.openHints.add(this); 18243 18244 BX.bind(window, 'scroll', BX.proxy(this.__onscroll, this)); 18245 18246 if (this.PARAMS.showOnce) 18247 { 18248 this.timer = setTimeout(BX.proxy(this.__hide, this), this.PARAMS.hide_timeout); 18249 } 18250 } 18251 }; 18252 18253 BX.CHint.prototype.__onscroll = function() 18254 { 18255 if (!BX.admin || !BX.admin.panel || !BX.admin.panel.isFixed()) return; 18256 18257 if (this.scrollTimer) clearTimeout(this.scrollTimer); 18258 18259 this.DIV.style.display = 'none'; 18260 this.scrollTimer = setTimeout(BX.proxy(this.Reopen, this), this.PARAMS.show_timeout); 18261 }; 18262 18263 BX.CHint.prototype.Reopen = function() 18264 { 18265 if (null != this.timer) clearTimeout(this.timer); 18266 this.timer = setTimeout(BX.proxy(this.__show, this), 50); 18267 }; 18268 18269 BX.CHint.prototype.__hide = function() 18270 { 18271 if (this.msover) return; 18272 if (!this.bInited) return; 18273 18274 BX.unbind(window, 'scroll', BX.proxy(this.Reopen, this)); 18275 18276 BX.CHint.openHints.delete(this); 18277 18278 if (this.PARAMS.showOnce) 18279 { 18280 this.Destroy(); 18281 } 18282 else 18283 { 18284 this.DIV.style.display = 'none'; 18285 } 18286 }; 18287 18288 BX.CHint.prototype.__hide_immediately = function() 18289 { 18290 this.msover = false; 18291 this.__hide(); 18292 }; 18293 18294 BX.CHint.prototype.Init = function() 18295 { 18296 this.DIV = document.body.appendChild(BX.create('DIV', { 18297 props: {className: 'bx-panel-tooltip'}, 18298 style: {display: 'none'}, 18299 children: [ 18300 BX.create('DIV', { 18301 props: {className: 'bx-panel-tooltip-top-border'}, 18302 html: '<div class="bx-panel-tooltip-corner bx-panel-tooltip-left-corner"></div><div class="bx-panel-tooltip-border"></div><div class="bx-panel-tooltip-corner bx-panel-tooltip-right-corner"></div>' 18303 }), 18304 (this.CONTENT = BX.create('DIV', { 18305 props: {className: 'bx-panel-tooltip-content'}, 18306 children: [ 18307 BX.create('DIV', { 18308 props: {className: 'bx-panel-tooltip-underlay'}, 18309 children: [ 18310 BX.create('DIV', {props: {className: 'bx-panel-tooltip-underlay-bg'}}) 18311 ] 18312 }) 18313 ] 18314 })), 18315 18316 BX.create('DIV', { 18317 props: {className: 'bx-panel-tooltip-bottom-border'}, 18318 html: '<div class="bx-panel-tooltip-corner bx-panel-tooltip-left-corner"></div><div class="bx-panel-tooltip-border"></div><div class="bx-panel-tooltip-corner bx-panel-tooltip-right-corner"></div>' 18319 }) 18320 ] 18321 })); 18322 18323 if (this.ID) 18324 { 18325 this.CONTENT.insertBefore(BX.create('A', { 18326 attrs: {href: 'javascript:void(0)'}, 18327 props: {className: 'bx-panel-tooltip-close'}, 18328 events: {click: BX.delegate(this.Close, this)} 18329 }), this.CONTENT.firstChild) 18330 } 18331 18332 if (this.HINT_TITLE) 18333 { 18334 this.CONTENT.appendChild( 18335 BX.create('DIV', { 18336 props: {className: 'bx-panel-tooltip-title'}, 18337 text: this.HINT_TITLE 18338 }) 18339 ) 18340 } 18341 18342 if (this.HINT) 18343 { 18344 this.CONTENT_TEXT = this.CONTENT.appendChild(BX.create('DIV', {props: {className: 'bx-panel-tooltip-text'}})).appendChild(BX.create('SPAN', {html: this.HINT})); 18345 } 18346 18347 if (this.PARAMS.preventHide) 18348 { 18349 BX.bind(this.DIV, 'mouseout', BX.proxy(this.Hide, this)); 18350 BX.bind(this.DIV, 'mouseover', BX.proxy(this.Show, this)); 18351 } 18352 18353 this.bInited = true; 18354 }; 18355 18356 BX.CHint.prototype.setContent = function(content) 18357 { 18358 this.HINT = content; 18359 18360 if (this.CONTENT_TEXT) 18361 this.CONTENT_TEXT.innerHTML = this.HINT; 18362 else 18363 this.CONTENT_TEXT = this.CONTENT.appendChild(BX.create('DIV', {props: {className: 'bx-panel-tooltip-text'}})).appendChild(BX.create('SPAN', {html: this.HINT})); 18364 }; 18365 18366 BX.CHint.prototype.prepareAdjustPos = function() 18367 { 18368 this._wnd = {scrollPos: BX.GetWindowScrollPos(),scrollSize:BX.GetWindowScrollSize()}; 18369 return BX.style(this.PARENT, 'display') != 'none'; 18370 }; 18371 18372 BX.CHint.prototype.getAdjustPos = function() 18373 { 18374 var res = {}, pos = BX.pos(this.PARENT), min_top = 0; 18375 18376 res.top = pos.bottom + this.PARAMS.dx; 18377 18378 if (BX.admin && BX.admin.panel.DIV) 18379 { 18380 min_top = BX.admin.panel.DIV.offsetHeight + this.PARAMS.dx; 18381 18382 if (BX.admin.panel.isFixed()) 18383 { 18384 min_top += this._wnd.scrollPos.scrollTop; 18385 } 18386 } 18387 18388 if (res.top < min_top) 18389 res.top = min_top; 18390 else 18391 { 18392 if (res.top + this.DIV.offsetHeight > this._wnd.scrollSize.scrollHeight) 18393 res.top = pos.top - this.PARAMS.dx - this.DIV.offsetHeight; 18394 } 18395 18396 res.left = pos.left; 18397 if (pos.left < this.PARAMS.dx) 18398 pos.left = this.PARAMS.dx; 18399 else 18400 { 18401 var floatWidth = this.DIV.offsetWidth; 18402 18403 var max_left = this._wnd.scrollSize.scrollWidth - floatWidth - this.PARAMS.dx; 18404 18405 if (res.left > max_left) 18406 res.left = max_left; 18407 } 18408 18409 return res; 18410 }; 18411 18412 BX.CHint.prototype.adjustWidth = function() 18413 { 18414 if (this.bWidthAdjusted) return; 18415 18416 var w = this.DIV.offsetWidth, h = this.DIV.offsetHeight; 18417 18418 if (w > this.PARAMS.min_width) 18419 w = Math.round(Math.sqrt(1.618*w*h)); 18420 18421 if (w < this.PARAMS.min_width) 18422 w = this.PARAMS.min_width; 18423 18424 this.DIV.style.width = w + "px"; 18425 18426 if (this._adjustWidthInt) 18427 clearInterval(this._adjustWidthInt); 18428 this._adjustWidthInt = setInterval(BX.delegate(this._adjustWidthInterval, this), 5); 18429 18430 this.bWidthAdjusted = true; 18431 }; 18432 18433 BX.CHint.prototype._adjustWidthInterval = function() 18434 { 18435 if (!this.DIV || this.DIV.style.display == 'none') 18436 clearInterval(this._adjustWidthInt); 18437 18438 var
18439 dW = 20, 18440 maxWidth = 1500, 18441 w = this.DIV.offsetWidth, 18442 w1 = this.CONTENT_TEXT.offsetWidth; 18443 18444 if (w > 0 && w1 > 0 && w - w1 < dW && w < maxWidth) 18445 { 18446 this.DIV.style.width = (w + dW) + "px"; 18447 return; 18448 } 18449 18450 clearInterval(this._adjustWidthInt); 18451 }; 18452 18453 BX.CHint.prototype.adjustPos = function() 18454 { 18455 this.adjustWidth(); 18456 18457 var pos = this.getAdjustPos(); 18458 18459 this.DIV.style.top = pos.top + 'px'; 18460 this.DIV.style.left = pos.left + 'px'; 18461 }; 18462 18463 BX.CHint.prototype.Close = function() 18464 { 18465 if (this.ID && BX.WindowManager) 18466 BX.WindowManager.saveWindowOptions(this.ID, {display: 'off'}); 18467 this.__hide_immediately(); 18468 this.Destroy(); 18469 }; 18470 18471 BX.CHint.prototype.Destroy = function() 18472 { 18473 if (this.PARENT) 18474 { 18475 BX.unbind(this.PARENT, 'mouseover', BX.proxy(this.Show, this)); 18476 BX.unbind(this.PARENT, 'mouseout', BX.proxy(this.Hide, this)); 18477 } 18478 18479 if (this.DIV) 18480 { 18481 BX.unbind(this.DIV, 'mouseover', BX.proxy(this.Show, this)); 18482 BX.unbind(this.DIV, 'mouseout', BX.proxy(this.Hide, this)); 18483 18484 BX.cleanNode(this.DIV, true); 18485 } 18486 }; 18487 18488 BX.CHint.prototype.enable = function(){this.disabled = false;}; 18489 BX.CHint.prototype.disable = function(){this.__hide_immediately(); this.disabled = true;}; 18490 18491 18492 function _adjustWait() 18493 { 18494 if (!this.bxmsg) return; 18495 18496 var arContainerPos = BX.pos(this), 18497 div_top = arContainerPos.top; 18498 18499 if (div_top < BX.GetDocElement().scrollTop) 18500 div_top = BX.GetDocElement().scrollTop + 5; 18501 18502 this.bxmsg.style.top = (div_top + 5) + 'px'; 18503 18504 if (this == BX.GetDocElement()) 18505 { 18506 this.bxmsg.style.right = '5px'; 18507 } 18508 else 18509 { 18510 this.bxmsg.style.left = (arContainerPos.right - this.bxmsg.offsetWidth - 5) + 'px'; 18511 } 18512 } 18513 18514 function _processTpl(tplNode, cb, bKillTpl) 18515 { 18516 if (tplNode) 18517 { 18518 if (bKillTpl) 18519 tplNode.parentNode.removeChild(tplNode); 18520 18521 var res = {}, nodes = BX.findChildren(tplNode, {attribute: 'data-role'}, true); 18522 18523 for (var i = 0, l = nodes.length; i < l; i++) 18524 { 18525 res[nodes[i].getAttribute('data-role')] = nodes[i]; 18526 } 18527 18528 cb.apply(tplNode, [res]); 18529 } 18530 } 18531 18532 function _checkNode(obj, params) 18533 { 18534 params = params || {}; 18535 18536 if (BX.type.isFunction(params)) 18537 return params.call(window, obj); 18538 18539 if (!params.allowTextNodes && !BX.type.isElementNode(obj)) 18540 return false; 18541 var i,j,len; 18542 for (i in params) 18543 { 18544 if(params.hasOwnProperty(i)) 18545 { 18546 switch(i) 18547 { 18548 case 'tag': 18549 case 'tagName': 18550 if (BX.type.isString(params[i])) 18551 { 18552 if (obj.tagName.toUpperCase() != params[i].toUpperCase()) 18553 return false; 18554 } 18555 else if (params[i] instanceof RegExp) 18556 { 18557 if (!params[i].test(obj.tagName)) 18558 return false; 18559 } 18560 break; 18561 18562 case 'class': 18563 case 'className': 18564 if (BX.type.isString(params[i])) 18565 { 18566 if (!BX.hasClass(obj, params[i])) 18567 return false; 18568 } 18569 else if (params[i] instanceof RegExp) 18570 { 18571 if (!BX.type.isString(obj.className) || !params[i].test(obj.className)) 18572 return false; 18573 } 18574 break; 18575 18576 case 'attr': 18577 case 'attrs': 18578 case 'attribute': 18579 if (BX.type.isString(params[i])) 18580 { 18581 if (!obj.getAttribute(params[i])) 18582 return false; 18583 } 18584 else if (BX.type.isArray(params[i])) 18585 { 18586 for (j = 0, len = params[i].length; j < len; j++) 18587 { 18588 if (params[i] && !obj.getAttribute(params[i])) 18589 return false; 18590 } 18591 } 18592 else 18593 { 18594 for (j in params[i]) 18595 { 18596 if(params[i].hasOwnProperty(j)) 18597 { 18598 var q = obj.getAttribute(j); 18599 if (params[i][j] instanceof RegExp) 18600 { 18601 if (!BX.type.isString(q) || !params[i][j].test(q)) 18602 { 18603 return false; 18604 } 18605 } 18606 else 18607 { 18608 if (q != '' + params[i][j]) 18609 { 18610 return false; 18611 } 18612 } 18613 } 18614 } 18615 } 18616 break; 18617 18618 case 'property': 18619 case 'props': 18620 if (BX.type.isString(params[i])) 18621 { 18622 if (!obj[params[i]]) 18623 return false; 18624 } 18625 else if (BX.type.isArray(params[i])) 18626 { 18627 for (j = 0, len = params[i].length; j < len; j++) 18628 { 18629 if (params[i] && !obj[params[i]]) 18630 return false;
18631 } 18632 } 18633 else 18634 { 18635 for (j in params[i]) 18636 { 18637 if (BX.type.isString(params[i][j])) 18638 { 18639 if (obj[j] != params[i][j]) 18640 return false; 18641 } 18642 else if (params[i][j] instanceof RegExp) 18643 { 18644 if (!BX.type.isString(obj[j]) || !params[i][j].test(obj[j])) 18645 return false; 18646 } 18647 } 18648 } 18649 break; 18650 18651 case 'callback': 18652 return params[i](obj); 18653 } 18654 } 18655 } 18656 18657 return true; 18658 } 18659 18660 /* garbage collector */ 18661 function Trash() 18662 { 18663 var i,len; 18664 18665 for (i = 0, len = garbageCollectors.length; i<len; i++) 18666 { 18667 try { 18668 garbageCollectors[i].callback.apply(garbageCollectors[i].context || window); 18669 delete garbageCollectors[i]; 18670 garbageCollectors[i] = null; 18671 } catch (e) {} 18672 } 18673 } 18674 18675 if(window.attachEvent) // IE 18676 window.attachEvent("onunload", Trash); 18677 else if(window.addEventListener) // Gecko / W3C 18678 window.addEventListener('unload', Trash, false); 18679 else 18680 window.onunload = Trash; 18681 /* \garbage collector */ 18682 18683// set empty ready handler 18684 BX(BX.DoNothing); 18685 window.BX = BX; 18686 18687 BX.browser.addGlobalClass(); 18688 18689 /* data storage */ 18690 BX.data = function(node, key, value) 18691 { 18692 if(typeof node == 'undefined') 18693 return undefined; 18694 18695 if(typeof key == 'undefined') 18696 return undefined; 18697 18698 if(typeof value != 'undefined') 18699 { 18700 // write to manager 18701 dataStorage.set(node, key, value); 18702 } 18703 else 18704 { 18705 var data; 18706 18707 // from manager 18708 if((data = dataStorage.get(node, key)) != undefined) 18709 { 18710 return data; 18711 } 18712 else 18713 { 18714 // from attribute data-* 18715 if('getAttribute' in node) 18716 { 18717 data = node.getAttribute('data-'+key.toString()); 18718 if(data === null) 18719 { 18720 return undefined; 18721 } 18722 return data; 18723 } 18724 } 18725 18726 return undefined; 18727 } 18728 }; 18729 18730 BX.DataStorage = function() 18731 { 18732 18733 this.keyOffset = 1; 18734 this.data = {}; 18735 this.uniqueTag = 'BX-'+Math.random(); 18736 18737 this.resolve = function(owner, create){ 18738 if(typeof owner[this.uniqueTag] == 'undefined') 18739 if(create) 18740 { 18741 try 18742 { 18743 Object.defineProperty(owner, this.uniqueTag, { 18744 value: this.keyOffset++ 18745 }); 18746 } 18747 catch(e) 18748 { 18749 owner[this.uniqueTag] = this.keyOffset++; 18750 } 18751 } 18752 else 18753 return undefined; 18754 18755 return owner[this.uniqueTag]; 18756 }; 18757 this.get = function(owner, key){ 18758 if((owner != document && !BX.type.isElementNode(owner)) || typeof key == 'undefined') 18759 return undefined; 18760 18761 owner = this.resolve(owner, false); 18762 18763 if(typeof owner == 'undefined' || typeof this.data[owner] == 'undefined') 18764 return undefined; 18765 18766 return this.data[owner][key]; 18767 }; 18768 this.set = function(owner, key, value){ 18769 18770 if((owner != document && !BX.type.isElementNode(owner)) || typeof value == 'undefined') 18771 return; 18772 18773 var o = this.resolve(owner, true); 18774 18775 if(typeof this.data[o] == 'undefined') 18776 this.data[o] = {}; 18777 18778 this.data[o][key] = value; 18779 }; 18780 }; 18781 18782// some internal variables for new logic 18783 var dataStorage = new BX.DataStorage(); // manager which BX.data() uses to keep data 18784})(window.BX); 18785 18786;(function(window) 18787{ 18788 /****************** ATTENTION ******************************* 18789 * Please do not use Bitrix CoreJS in this class. 18790 * This class can be called on page without Bitrix Framework 18791 *************************************************************/ 18792 18793 if (!window.BX) 18794 { 18795 window.BX = {}; 18796 } 18797 18798 var BX = window.BX; 18799 18800 BX.Promise = function(fn, ctx) // fn is future-reserved 18801 { 18802 this.state = null; 18803 this.value = null; 18804 this.reason = null; 18805 this.next = null; 18806 this.ctx = ctx || this; 18807 18808 this.onFulfilled = []; 18809 this.onRejected = []; 18810 }; 18811 BX.Promise.prototype.fulfill = function(value) 18812 { 18813 this.checkState(); 18814 18815 this.value = value; 18816 this.state = true; 18817 this.execute(); 18818 }; 18819 BX.Promise.prototype.reject = function(reason) 18820 { 18821 this.checkState(); 18822 18823 this.reason = reason; 18824 this.state = false; 18825 this.execute(); 18826 }; 18827 BX.Promise.prototype.then = function(onFulfilled, onRejected) 18828 { 18829 if(typeof (onFulfilled) == "function" || onFulfilled instanceof Function) 18830 { 18831 this.onFulfilled.push(onFulfilled); 18832 } 18833 if(typeof (onRejected) == "function" || onRejected instanceof Function) 18834 { 18835 this.onRejected.push(onRejected); 18836 } 18837 18838 if(this.next === null) 18839 { 18840 this.next = new BX.Promise(null, this.ctx); 18841 } 18842 18843 if(this.state !== null) // if promise was already resolved, execute immediately 18844 { 18845 this.execute(); 18846 } 18847 18848 return this.next; 18849 }; 18850 18851 BX.Promise.prototype.catch = function(onRejected) 18852 { 18853 if(typeof (onRejected) == "function" || onRejected instanceof Function) 18854 { 18855 this.onRejected.push(onRejected); 18856 } 18857 18858 if(this.next === null) 18859 { 18860 this.next = new BX.Promise(null, this.ctx); 18861 } 18862 18863 if(this.state !== null) // if promise was already resolved, execute immediately 18864 { 18865 this.execute(); 18866 } 18867 18868 return this.next; 18869 }; 18870 18871 BX.Promise.prototype.setAutoResolve = function(way, ms) 18872 { 18873 this.timer = setTimeout(function(){ 18874 if(this.state === null) 18875 { 18876 this[way ? 'fulfill' : 'reject'](); 18877 } 18878 }.bind(this), ms || 15); 18879 };
18880 BX.Promise.prototype.cancelAutoResolve = function() 18881 { 18882 clearTimeout(this.timer); 18883 }; 18884 /** 18885 * Resolve function. This function allows promise chaining, like ..then().then()... 18886 * Typical usage: 18887 * 18888 * var p = new Promise(); 18889 * 18890 * p.then(function(value){ 18891 * return someValue; // next promise in the chain will be fulfilled with someValue 18892 * }).then(function(value){ 18893 * 18894 * var p1 = new Promise(); 18895 * *** some async code here, that eventually resolves p1 *** 18896 * 18897 * return p1; // chain will resume when p1 resolved (fulfilled or rejected) 18898 * }).then(function(value){ 18899 * 18900 * // you can also do 18901 * var e = new Error(); 18902 * throw e; 18903 * // it will cause next promise to be rejected with e 18904 * 18905 * return someOtherValue; 18906 * }).then(function(value){ 18907 * ... 18908 * }, function(reason){ 18909 * // promise was rejected with reason 18910 * })...; 18911 * 18912 * p.fulfill('let`s start this chain'); 18913 * 18914 * @param x 18915 */ 18916 BX.Promise.prototype.resolve = function(x) 18917 { 18918 var this_ = this; 18919 18920 if(this === x) 18921 { 18922 this.reject(new TypeError('Promise cannot fulfill or reject itself')); // avoid recursion 18923 } 18924 // allow "pausing" promise chaining until promise x is fulfilled or rejected 18925 else if(x && x.toString() === "[object BX.Promise]") 18926 { 18927 x.then(function(value){ 18928 this_.fulfill(value); 18929 }, function(reason){ 18930 this_.reject(reason); 18931 }); 18932 } 18933 else // auto-fulfill this promise 18934 { 18935 this.fulfill(x); 18936 } 18937 }; 18938 18939 BX.Promise.prototype.toString = function() 18940 { 18941 return "[object BX.Promise]"; 18942 }; 18943 18944 BX.Promise.prototype.execute = function() 18945 { 18946 if(this.state === null) 18947 { 18948 //then() must not be called before BX.Promise resolve() happens 18949 return; 18950 } 18951 18952 var value = undefined; 18953 var reason = undefined; 18954 var x = undefined; 18955 var k; 18956 if(this.state === true) // promise was fulfill()-ed 18957 { 18958 if(this.onFulfilled.length) 18959 { 18960 try 18961 { 18962 for(k = 0; k < this.onFulfilled.length; k++) 18963 {
18964 x = this.onFulfilled[k].apply(this.ctx, [this.value]); 18965 if(typeof x != 'undefined') 18966 { 18967 value = x; 18968 } 18969 } 18970 } 18971 catch(e) 18972 { 18973 if('console' in window) 18974 { 18975 console.dir(e); 18976 } 18977 18978 if (typeof BX.debug !== 'undefined') 18979 { 18980 BX.debug(e); 18981 } 18982 18983 reason = e; // reject next 18984 } 18985 } 18986 else 18987 { 18988 value = this.value; // resolve next 18989 } 18990 } 18991 else if(this.state === false) // promise was reject()-ed 18992 { 18993 if(this.onRejected.length) 18994 { 18995 try 18996 { 18997 for(k = 0; k < this.onRejected.length; k++) 18998 { 18999 x = this.onRejected[k].apply(this.ctx, [this.reason]); 19000 if(typeof x != 'undefined') 19001 { 19002 value = x; 19003 } 19004 } 19005 } 19006 catch(e) 19007 { 19008 if('console' in window) 19009 { 19010 console.dir(e); 19011 } 19012 19013 if (typeof BX.debug !== 'undefined') 19014 { 19015 BX.debug(e); 19016 } 19017 19018 reason = e; // reject next 19019 } 19020 } 19021 else 19022 { 19023 reason = this.reason; // reject next 19024 } 19025 } 19026 19027 if(this.next !== null) 19028 { 19029 if(typeof reason != 'undefined') 19030 { 19031 this.next.reject(reason); 19032 } 19033 else if(typeof value != 'undefined') 19034 { 19035 this.next.resolve(value); 19036 } 19037 } 19038 }; 19039 BX.Promise.prototype.checkState = function() 19040 { 19041 if(this.state !== null) 19042 { 19043 throw new Error('You can not do fulfill() or reject() multiple times'); 19044 } 19045 }; 19046})(window); 19047 19048 19049 19050;(function(window){ 19051 19052if (window.BX.ajax) 19053 return; 19054 19055var 19056 BX = window.BX, 19057 19058 tempDefaultConfig = {}, 19059 defaultConfig = { 19060 method: 'GET', // request method: GET|POST 19061 dataType: 'html', // type of data loading: html|json|script 19062 timeout: 0, // request timeout in seconds. 0 for browser-default 19063 async: true, // whether request is asynchronous or not 19064 processData: true, // any data processing is disabled if false, only callback call 19065 scriptsRunFirst: false, // whether to run _all_ found scripts before onsuccess call. script tag can have an attribute "bxrunfirst" to turn this flag on only for itself 19066 emulateOnload: true, 19067 skipAuthCheck: false, // whether to check authorization failure (SHOUD be set to true for CORS requests) 19068 start: true, // send request immediately (if false, request can be started manually via XMLHttpRequest object returned) 19069 cache: true, // whether NOT to add random addition to URL 19070 preparePost: true, // whether set Content-Type x-www-form-urlencoded in POST 19071 headers: false, // add additional headers, example: [{'name': 'If-Modified-Since', 'value': 'Wed, 15 Aug 2012 08:59:08 GMT'}, {'name': 'If-None-Match', 'value': '0'}] 19072 lsTimeout: 30, //local storage data TTL. useless without lsId. 19073 lsForce: false //wheter to force query instead of using localStorage data. useless without lsId. 19074/* 19075other parameters: 19076 url: url to get/post 19077 data: data to post 19078 onsuccess: successful request callback. BX.proxy may be used. 19079 onfailure: request failure callback. BX.proxy may be used. 19080 onprogress: request progress callback. BX.proxy may be used. 19081 19082 lsId: local storage id - for constantly updating queries which can communicate via localStorage. core_ls.js needed 19083 19084any of the default parameters can be overridden. defaults can be changed by BX.ajax.Setup() - for all further requests! 19085*/ 19086 }, 19087 ajax_session = null, 19088 loadedScripts = {}, 19089 loadedScriptsQueue = [], 19090 r = { 19091 'url_utf': /[^\034-\254]+/g, 19092 'script_self': /\/bitrix\/js\/main\/core\/core(_ajax)*.js$/i, 19093 'script_self_window': /\/bitrix\/js\/main\/core\/core_window.js$/i, 19094 'script_self_admin': /\/bitrix\/js\/main\/core\/core_admin.js$/i, 19095 'script_onload': /window.onload/g 19096 }; 19097 19098// low-level method 19099BX.ajax = function(config) 19100{ 19101 var status, data; 19102
19103 if (!config || !config.url || !BX.type.isString(config.url)) 19104 { 19105 return false; 19106 } 19107 19108 for (var i in tempDefaultConfig) 19109 if (typeof (config[i]) == "undefined") config[i] = tempDefaultConfig[i]; 19110 19111 tempDefaultConfig = {}; 19112 19113 for (i in defaultConfig) 19114 if (typeof (config[i]) == "undefined") config[i] = defaultConfig[i]; 19115 19116 config.method = config.method.toUpperCase(); 19117 19118 if (!BX.localStorage) 19119 config.lsId = null; 19120 19121 if (BX.browser.IsIE()) 19122 { 19123 var result = r.url_utf.exec(config.url); 19124 if (result) 19125 { 19126 do 19127 { 19128 config.url = config.url.replace(result, BX.util.urlencode(result)); 19129 result = r.url_utf.exec(config.url); 19130 } while (result); 19131 } 19132 } 19133 19134 if(config.dataType == 'json') 19135 config.emulateOnload = false; 19136 19137 if (!config.cache && config.method == 'GET') 19138 config.url = BX.ajax._uncache(config.url); 19139 19140 if (config.method == 'POST') 19141 { 19142 if (config.preparePost) 19143 { 19144 config.data = BX.ajax.prepareData(config.data); 19145 } 19146 else if (getLastContentTypeHeader(config.headers) === 'application/json') 19147 { 19148 config.data = JSON.stringify(config.data); 19149 } 19150 } 19151 19152 var bXHR = true; 19153 if (config.lsId && !config.lsForce) 19154 { 19155 var v = BX.localStorage.get('ajax-' + config.lsId); 19156 if (v !== null) 19157 { 19158 bXHR = false; 19159 19160 var lsHandler = function(lsData) { 19161 if (lsData.key == 'ajax-' + config.lsId && lsData.value != 'BXAJAXWAIT') 19162 { 19163 var data = lsData.value, 19164 bRemove = !!lsData.oldValue && data == null; 19165 if (!bRemove) 19166 BX.ajax.__run(config, data); 19167 else if (config.onfailure) 19168 config.onfailure("timeout"); 19169 19170 BX.removeCustomEvent('onLocalStorageChange', lsHandler); 19171 } 19172 }; 19173 19174 if (v == 'BXAJAXWAIT') 19175 { 19176 BX.addCustomEvent('onLocalStorageChange', lsHandler); 19177 } 19178 else 19179 { 19180 setTimeout(function() {lsHandler({key: 'ajax-' + config.lsId, value: v})}, 10); 19181 } 19182 } 19183 } 19184 19185 if (bXHR) 19186 { 19187 config.xhr = BX.ajax.xhr(); 19188 if (!config.xhr) return; 19189 19190 if (config.lsId) 19191 { 19192 BX.localStorage.set('ajax-' + config.lsId, 'BXAJAXWAIT', config.lsTimeout); 19193 } 19194 19195 config.xhr.open(config.method, config.url, config.async); 19196 19197 if (!config.skipBxHeader && !BX.ajax.isCrossDomain(config.url)) 19198 { 19199 config.xhr.setRequestHeader('Bx-ajax', 'true'); 19200 } 19201 19202 if (config.method == 'POST' && config.preparePost) 19203 { 19204 config.xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); 19205 } 19206 if (typeof(config.headers) == "object") 19207 { 19208 for (i = 0; i < config.headers.length; i++) 19209 config.xhr.setRequestHeader(config.headers[i].name, config.headers[i].value); 19210 } 19211 19212 if(!!config.onprogress) 19213 { 19214 BX.bind(config.xhr, 'progress', config.onprogress); 19215 } 19216 19217 var bRequestCompleted = false; 19218 var onreadystatechange = config.xhr.onreadystatechange = function(additional) 19219 { 19220 if (bRequestCompleted) 19221 return; 19222 19223 if (additional === 'timeout') 19224 { 19225 if (config.onfailure) 19226 { 19227 config.onfailure("timeout"); 19228 } 19229 19230 BX.onCustomEvent(config.xhr, 'onAjaxFailure', ['timeout', '', config]); 19231 19232 config.xhr.onreadystatechange = BX.DoNothing; 19233 config.xhr.abort(); 19234 19235 if (config.async) 19236 { 19237 config.xhr = null; 19238 } 19239 } 19240 else 19241 { 19242 if (config.xhr.readyState == 4 || additional == 'run') 19243 { 19244 status = BX.ajax.xhrSuccess(config.xhr) ? "success" : "error"; 19245 bRequestCompleted = true; 19246 config.xhr.onreadystatechange = BX.DoNothing; 19247 19248 if (status == 'success') 19249 { 19250 var authHeader = (!!config.skipAuthCheck || BX.ajax.isCrossDomain(config.url)) 19251 ? false 19252 : config.xhr.getResponseHeader('X-Bitrix-Ajax-Status'); 19253 19254 if(!!authHeader && authHeader == 'Authorize') 19255 { 19256 if (config.onfailure) 19257 { 19258 config.onfailure("auth", config.xhr.status); 19259 } 19260 19261 BX.onCustomEvent(config.xhr, 'onAjaxFailure', ['auth', config.xhr.status, config]); 19262 } 19263 else 19264 { 19265 var data = config.xhr.responseText; 19266 19267 if (config.lsId) 19268 { 19269 BX.localStorage.set('ajax-' + config.lsId, data, config.lsTimeout); 19270 } 19271 19272 BX.ajax.__run(config, data); 19273 } 19274 } 19275 else 19276 { 19277 if (config.onfailure) 19278 { 19279 config.onfailure("status", config.xhr.status); 19280 } 19281 19282 BX.onCustomEvent(config.xhr, 'onAjaxFailure', ['status', config.xhr.status, config]); 19283 } 19284 19285 if (config.async) 19286 { 19287 config.xhr = null; 19288 } 19289 } 19290 } 19291 }; 19292 19293 if (config.async && config.timeout > 0) 19294 { 19295 setTimeout(function() { 19296 if (config.xhr && !bRequestCompleted) 19297 { 19298 onreadystatechange("timeout"); 19299 } 19300 }, config.timeout * 1000); 19301 } 19302 19303 if (config.start) 19304 {
19305 config.xhr.send(config.data); 19306 19307 if (!config.async) 19308 { 19309 onreadystatechange('run'); 19310 } 19311 } 19312 19313 return config.xhr; 19314 } 19315}; 19316 19317BX.ajax.xhr = function() 19318{ 19319 if (window.XMLHttpRequest) 19320 { 19321 try {return new XMLHttpRequest();} catch(e){} 19322 } 19323 else if (window.ActiveXObject) 19324 { 19325 try { return new window.ActiveXObject("Msxml2.XMLHTTP.6.0"); } 19326 catch(e) {} 19327 try { return new window.ActiveXObject("Msxml2.XMLHTTP.3.0"); } 19328 catch(e) {} 19329 try { return new window.ActiveXObject("Msxml2.XMLHTTP"); } 19330 catch(e) {} 19331 try { return new window.ActiveXObject("Microsoft.XMLHTTP"); } 19332 catch(e) {} 19333 throw new Error("This browser does not support XMLHttpRequest."); 19334 } 19335 19336 return null; 19337}; 19338 19339BX.ajax.isCrossDomain = function(url, location) 19340{ 19341 location = location || window.location; 19342 19343 //Relative URL gets a current protocol 19344 if (url.indexOf("//") === 0) 19345 { 19346 url = location.protocol + url; 19347 } 19348 19349 //Fast check 19350 if (url.indexOf("http") !== 0) 19351 { 19352 return false; 19353 } 19354 19355 var link = window.document.createElement("a"); 19356 link.href = url; 19357 19358 return link.protocol !== location.protocol || 19359 link.hostname !== location.hostname || 19360 BX.ajax.getHostPort(link.protocol, link.host) !== BX.ajax.getHostPort(location.protocol, location.host); 19361}; 19362 19363BX.ajax.getHostPort = function(protocol, host) 19364{ 19365 var match = /:(\d+)$/.exec(host); 19366 if (match) 19367 { 19368 return match[1]; 19369 } 19370 else 19371 { 19372 if (protocol === "http:") 19373 { 19374 return "80"; 19375 } 19376 else if (protocol === "https:") 19377 { 19378 return "443"; 19379 } 19380 } 19381 19382 return ""; 19383}; 19384 19385BX.ajax.__prepareOnload = function(scripts) 19386{ 19387 if (scripts.length > 0) 19388 { 19389 BX.ajax['onload_' + ajax_session] = null; 19390 19391 for (var i=0,len=scripts.length;i<len;i++) 19392 { 19393 if (scripts[i].isInternal) 19394 { 19395 scripts[i].JS = scripts[i].JS.replace(r.script_onload, 'BX.aja
19395x.onload_' + ajax_session); 19396 } 19397 } 19398 } 19399 19400 BX.CaptureEventsGet(); 19401 BX.CaptureEvents(window, 'load'); 19402}; 19403 19404BX.ajax.__runOnload = function() 19405{ 19406 if (null != BX.ajax['onload_' + ajax_session]) 19407 { 19408 BX.ajax['onload_' + ajax_session].apply(window); 19409 BX.ajax['onload_' + ajax_session] = null; 19410 } 19411 19412 var h = BX.CaptureEventsGet(); 19413 19414 if (h) 19415 { 19416 for (var i=0; i<h.length; i++) 19417 h[i].apply(window); 19418 } 19419}; 19420 19421BX.ajax.__run = function(config, data) 19422{ 19423 if (!config.processData) 19424 { 19425 if (config.onsuccess) 19426 { 19427 config.onsuccess(data); 19428 } 19429 19430 BX.onCustomEvent(config.xhr, 'onAjaxSuccess', [data, config]); 19431 } 19432 else 19433 { 19434 data = BX.ajax.processRequestData(data, config); 19435 } 19436}; 19437 19438 19439BX.ajax._onParseJSONFailure = function(data) 19440{ 19441 this.jsonFailure = true; 19442 this.jsonResponse = data; 19443 this.jsonProactive = /^\[WAF\]/.test(data); 19444}; 19445 19446BX.ajax.processRequestData = function(data, config) 19447{ 19448 var result, scripts = [], styles = []; 19449 switch (config.dataType.toUpperCase()) 19450 { 19451 case 'JSON': 19452 19453 var context = config.xhr || {}; 19454 BX.addCustomEvent(context, 'onParseJSONFailure', BX.proxy(BX.ajax._onParseJSONFailure, config)); 19455 result = BX.parseJSON(data, context); 19456 BX.removeCustomEvent(context, 'onParseJSONFailure', BX.proxy(BX.ajax._onParseJSONFailure, config)); 19457 19458 if(!!result && BX.type.isArray(result['bxjs'])) 19459 { 19460 for(var i = 0; i < result['bxjs'].length; i++) 19461 { 19462 if(BX.type.isNotEmptyString(result['bxjs'][i])) 19463 { 19464 scripts.push({ 19465 "isInternal": false, 19466 "JS": result['bxjs'][i], 19467 "bRunFirst": config.scriptsRunFirst 19468 }); 19469 } 19470 else 19471 { 19472 scripts.push(result['bxjs'][i]) 19473 } 19474 } 19475 } 19476 19477 if(!!result && BX.type.isArray(result['bxcss'])) 19478 { 19479 styles = result['bxcss']; 19480 } 19481 19482 break; 19483 case 'SCRIPT': 19484 scripts.push({"isInternal": true, "JS": data, "bRunFirst": config.scriptsRunFirst}); 19485 result = data; 19486 break; 19487 19488 default: // HTML 19489 var ob = BX.processHTML(data, config.scriptsRunFirst); 19490 result = ob.HTML; scripts = ob.SCRIPT; styles = ob.STYLE; 19491 break; 19492 } 19493 19494 var bSessionCreated = false; 19495 if (null == ajax_session) 19496 { 19497 ajax_session = parseInt(Math.random() * 1000000); 19498 bSessionCreated = true; 19499 } 19500 19501 if (styles.length > 0) 19502 BX.loadCSS(styles); 19503 19504 if (config.emulateOnload) 19505 BX.ajax.__prepareOnload(scripts); 19506 19507 var cb = BX.DoNothing; 19508 if(config.emulateOnload || bSessionCreated) 19509 { 19510 cb = BX.defer(function() 19511 { 19512 if (config.emulateOnload) 19513 BX.ajax.__runOnload(); 19514 if (bSessionCreated) 19515 ajax_session = null; 19516 BX.onCustomEvent(config.xhr, 'onAjaxSuccessFinish', [config]); 19517 }); 19518 } 19519 19520 try 19521 { 19522 if (!!config.jsonFailure) 19523 { 19524 throw {type: 'json_failure', data: config.jsonResponse, bProactive: config.jsonProactive}; 19525 } 19526 19527 config.scripts = scripts; 19528 19529 BX.ajax.processScripts(config.scripts, true); 19530 19531 if (config.onsuccess) 19532 { 19533 config.onsuccess(result); 19534 } 19535 19536 BX.onCustomEvent(config.xhr, 'onAjaxSuccess', [result, config]); 19537 19538 BX.ajax.processScripts(config.scripts, false, cb); 19539 } 19540 catch (e) 19541 { 19542 if (config.onfailure) 19543 config.onfailure("processing", e); 19544 BX.onCustomEvent(config.xhr, 'onAjaxFailure', ['processing', e, config]); 19545 } 19546}; 19547 19548BX.ajax.processScripts = function(scripts, bRunFirst, cb) 19549{ 19550 var scriptsExt = [], scriptsInt = ''; 19551 19552 cb = cb || BX.DoNothing; 19553 19554 for (var i = 0, length = scripts.length; i < length; i++) 19555 { 19556 if (typeof bRunFirst != 'undefined' && bRunFirst != !!scripts[i].bRunFirst) 19557 continue; 19558 19559 if (scripts[i].isInternal) 19560 scriptsInt += ';' + scripts[i].JS; 19561 else 19562 scriptsExt.push(scripts[i].JS); 19563 } 19564 19565 scriptsExt = BX.util.array_unique(scriptsExt); 19566 var inlineScripts = scriptsInt.length > 0 ? function() { BX.evalGlobal(scriptsInt); } : BX.DoNothing; 19567 19568 if (scriptsExt.length > 0) 19569 { 19570 BX.load(scriptsExt, function() { 19571 inlineScripts(); 19572 cb(); 19573 }); 19574 } 19575 else 19576 { 19577 inlineScripts(); 19578 cb(); 19579 } 19580}; 19581 19582// TODO: extend this function to use with any data objects or forms 19583BX.ajax.prepareData = function(arData, prefix) 19584{ 19585 var data = ''; 19586 if (BX.type.isString(arData)) 19587 data = arData; 19588 else if (null != arData) 19589 { 19590 for(var i in arData) 19591 { 19592 if (arData.hasOwnProperty(i)) 19593 { 19594 if (data.length > 0) 19595 data += '&'; 19596 var name = BX.util.urlencode(i); 19597 if(prefix)
19598 name = prefix + '[' + name + ']'; 19599 if(typeof arData[i] == 'object') 19600 data += BX.ajax.prepareData(arData[i], name); 19601 else 19602 data += name + '=' + BX.util.urlencode(arData[i]); 19603 } 19604 } 19605 } 19606 return data; 19607}; 19608 19609BX.ajax.xhrSuccess = function(xhr) 19610{ 19611 return (xhr.status >= 200 && xhr.status < 300) || xhr.status === 304 || xhr.status === 1223 || xhr.status === 0; 19612}; 19613 19614BX.ajax.Setup = function(config, bTemp) 19615{ 19616 bTemp = !!bTemp; 19617 19618 for (var i in config) 19619 { 19620 if (bTemp) 19621 tempDefaultConfig[i] = config[i]; 19622 else 19623 defaultConfig[i] = config[i]; 19624 } 19625}; 19626 19627BX.ajax.replaceLocalStorageValue = function(lsId, data, ttl) 19628{ 19629 if (!!BX.localStorage) 19630 BX.localStorage.set('ajax-' + lsId, data, ttl); 19631}; 19632 19633 19634BX.ajax._uncache = function(url) 19635{ 19636 return url + ((url.indexOf('?') !== -1 ? "&" : "?") + '_=' + (new Date()).getTime()); 19637}; 19638 19639/* simple interface */ 19640BX.ajax.get = function(url, data, callback) 19641{ 19642 if (BX.type.isFunction(data)) 19643 { 19644 callback = data; 19645 data = ''; 19646 } 19647 19648 data = BX.ajax.prepareData(data); 19649 19650 if (data) 19651 { 19652 url += (url.indexOf('?') !== -1 ? "&" : "?") + data; 19653 data = ''; 19654 } 19655 19656 return BX.ajax({ 19657 'method': 'GET', 19658 'dataType': 'html', 19659 'url': url, 19660 'data': '', 19661 'onsuccess': callback 19662 }); 19663}; 19664 19665BX.ajax.getCaptcha = function(callback) 19666{ 19667 return BX.ajax.loadJSON('/bitrix/tools/ajax_captcha.php', callback); 19668}; 19669 19670BX.ajax.insertToNode = function(url, node) 19671{ 19672 node = BX(node); 19673 if (!!node) 19674 { 19675 var eventArgs = { cancel: false }; 19676 BX.onCustomEvent('onAjaxInsertToNode', [{ url: url, node: node, eventArgs: eventArgs }]); 19677 if(eventArgs.cancel === true) 19678 { 19679 return; 19680 } 19681 19682 var show = null; 19683 if (!tempDefaultConfig.denyShowWait) 19684 { 19685 show = BX.showWait(node); 19686 delete tempDefaultConfig.denyShowWait; 19687 } 19688 19689 return BX.ajax.get(url, function(data) { 19690 node.innerHTML = data; 19691 BX.closeWait(node, show); 19692 }); 19693 } 19694}; 19695 19696BX.ajax.post = function(url, data, callback) 19697{ 19698 data = BX.ajax.prepareData(data); 19699 19700 return BX.ajax({ 19701 'method': 'POST', 19702 'dataType': 'html', 19703 'url': url, 19704 'data': data, 19705 'onsuccess': callback 19706 }); 19707}; 19708 19709/** 19710 * BX.ajax with BX.Promise 19711 * 19712 * @param config 19713 * @returns {BX.Promise|false} 19714 */ 19715BX.ajax.promise = function(config) 19716{ 19717 var result = new BX.Promise(); 19718 19719 config.onsuccess = function(data) 19720 { 19721 result.fulfill(data); 19722 }; 19723 config.onfailure = function(reason, data) 19724 { 19725 result.reject({ 19726 reason: reason, 19727 data: data 19728 }); 19729 }; 19730 config.onprogress = function(data) 19731 { 19732 if (data.position == 0 && data.totalSize == 0) 19733 { 19734 result.reject({ 19735 reason: 'progress', 19736 data: data 19737 }); 19738 } 19739 }; 19740 19741 var xhr = BX.ajax(config); 19742 if (xhr) 19743 { 19744 if (typeof config.onrequeststart === 'function') 19745 { 19746 config.onrequeststart(xhr); 19747 } 19748 } 19749 else 19750 { 19751 result.reject({ 19752 reason: "init", 19753 data: false 19754 }); 19755 } 19756 19757 return result; 19758}; 19759 19760/* load and execute external file script with onload emulation */ 19761BX.ajax.loadScriptAjax = function(script_src, callback, bPreload) 19762{ 19763 if (BX.type.isArray(script_src)) 19764 { 19765 for (var i=0,len=script_src.length;i<len;i++) 19766 { 19767 BX.ajax.loadScriptAjax(script_src[i], callback, bPreload); 19768 } 19769 } 19770 else 19771 { 19772 var script_src_test = script_src.replace(/\.js\?.*/, '.js'); 19773 19774 if (r.script_self.test(script_src_test)) return; 19775 if (r.script_self_window.test(script_src_test) && BX.CWindow) return; 19776 if (r.script_self_admin.test(script_src_test) && BX.admin) return; 19777 19778 if (typeof loadedScripts[script_src_test] == 'undefined') 19779 { 19780 if (!!bPreload) 19781 { 19782 loadedScripts[script_src_test] = ''; 19783 return BX.loadScript(script_src); 19784 } 19785 else 19786 { 19787 return BX.ajax({ 19788 url: script_src, 19789 method: 'GET', 19790 dataType: 'script', 19791 processData: true, 19792 emulateOnload: false, 19793 scriptsRunFirst: true, 19794 async: false, 19795 start: true, 19796 onsuccess: function(result) { 19797 loadedScripts[script_src_test] = result; 19798 if (callback) 19799 callback(result); 19800 } 19801 }); 19802 } 19803 } 19804 else if (callback) 19805 { 19806 callback(loadedScripts[script_src_test]); 19807 } 19808 } 19809}; 19810 19811/* non-xhr loadings */ 19812BX.ajax.loadJSON = function(url, data, callback, callback_failure) 19813{ 19814 if (BX.type.isFunction(data)) 19815 { 19816 callback_failure = callback; 19817 callback = data; 19818 data = ''; 19819 } 19820
19821 data = BX.ajax.prepareData(data); 19822 19823 if (data) 19824 { 19825 url += (url.indexOf('?') !== -1 ? "&" : "?") + data; 19826 data = ''; 19827 } 19828 19829 return BX.ajax({ 19830 'method': 'GET', 19831 'dataType': 'json', 19832 'url': url, 19833 'onsuccess': callback, 19834 'onfailure': callback_failure 19835 }); 19836}; 19837 19838var getLastContentTypeHeader = function (headers) { 19839 if (!BX.Type.isArray(headers)) 19840 { 19841 return null; 19842 } 19843 var lastHeader = headers 19844 .filter(function (header) { 19845 return header.name === 'Content-Type'; 19846 }) 19847 .pop(); 19848 19849 return lastHeader ? lastHeader.value : null; 19850}; 19851 19852var prepareAjaxGetParameters = function(config) 19853{ 19854 var getParameters = config.getParameters || {}; 19855 if (BX.type.isNotEmptyString(config.analyticsLabel)) 19856 { 19857 getParameters.analyticsLabel = config.analyticsLabel; 19858 } 19859 else if (BX.type.isNotEmptyObject(config.analyticsLabel)) 19860 { 19861 getParameters.analyticsLabel = config.analyticsLabel; 19862 } 19863 if (typeof config.mode !== 'undefined') 19864 { 19865 getParameters.mode = config.mode; 19866 } 19867 if (config.navigation) 19868 { 19869 if(config.navigation.page) 19870 { 19871 getParameters.nav = 'page-' + config.navigation.page; 19872 } 19873 if(config.navigation.size) 19874 { 19875 if(getParameters.nav) 19876 { 19877 getParameters.nav += '-'; 19878 } 19879 else 19880 { 19881 getParameters.nav = ''; 19882 } 19883 getParameters.nav += 'size-' + config.navigation.size; 19884 } 19885 } 19886 19887 return getParameters; 19888}; 19889 19890var prepareAjaxConfig = function(config) 19891{ 19892 config = BX.type.isPlainObject(config) ? config : {}; 19893 19894 if (typeof config.json !== 'undefined') 19895 { 19896 if (!BX.type.isPlainObject(config.json)) 19897 { 19898 throw new Error('Wrong `config.json`, plain object expected.') 19899 } 19900 19901 config.headers = config.headers || []; 19902 config.headers.push({name: 'Content-Type', value: 'application/json'}); 19903 config.headers.push({name: 'X-Bitrix-Csrf-Token', value: BX.bitrix_sessid()}); 19904 if (BX.message.SITE_ID) 19905 { 19906 config.headers.push({name: 'X-Bitrix-Site-Id', value: BX.message.SITE_ID}); 19907 } 19908 19909 config.data = config.json; 19910 config.preparePost = false; 19911 } 19912 else if (config.data instanceof FormData) 19913 { 19914 config.preparePost = false; 19915 19916 config.data.append('sessid', BX.bitrix_sessid()); 19917 if (BX.message.SITE_ID) 19918 { 19919 config.data.append('SITE_ID', BX.message.SITE_ID); 19920 } 19921 if (typeof config.signedParameters !== 'undefined') 19922 { 19923 config.data.append('signedParameters', config.signedParameters); 19924 } 19925 } 19926 else 19927 { 19928 config.data = BX.type.isPlainObject(config.data) ? config.data : {}; 19929 if (BX.message.SITE_ID) 19930 { 19931 config.data.SITE_ID = BX.message.SITE_ID; 19932 } 19933 config.data.sessid = BX.bitrix_sessid(); 19934 if (typeof config.signedParameters !== 'undefined') 19935 { 19936 config.data.signedParameters = config.signedParameters; 19937 } 19938 } 19939 19940 if (!config.method) 19941 { 19942 config.method = 'POST' 19943 } 19944 19945 return config; 19946}; 19947 19948var buildAjaxPromiseToRestoreCsrf = function(config, withoutRestoringCsrf) 19949{ 19950 withoutRestoringCsrf = withoutRestoringCsrf || false; 19951 var originalConfig = BX.clone(config); 19952 var request = null; 19953 19954 var onrequeststart = config.onrequeststart; 19955 config.onrequeststart = function(xhr) { 19956 request = xhr; 19957 if (BX.type.isFunction(onrequeststart)) 19958 { 19959 onrequeststart(xhr); 19960 } 19961 }; 19962 var onrequeststartOrig = originalConfig.onrequeststart; 19963 originalConfig.onrequeststart = function(xhr) { 19964 request = xhr; 19965 if (BX.type.isFunction(onrequeststartOrig)) 19966 { 19967 onrequeststartOrig(xhr); 19968 } 19969 }; 19970 19971 var promise = BX.ajax.promise(config); 19972 19973 return promise.then(function(response) { 19974 if (!withoutRestoringCsrf && BX.type.isPlainObject(response) && BX.type.isArray(response.errors)) 19975 { 19976 var csrfProblem = false; 19977 response.errors.forEach(function(error) { 19978 if (error.code === 'invalid_csrf' && error.customData.csrf) 19979 { 19980 BX.message({'bitrix_sessid': error.customData.csrf}); 19981 originalConfig.data.sessid = BX.bitrix_sessid(); 19982 19983 csrfProblem = true; 19984 } 19985 }); 19986 19987 if (csrfProblem) 19988 { 19989 return buildAjaxPromiseToRestoreCsrf(originalConfig, true); 19990 } 19991 } 19992 19993 if (!BX.type.isPlainObject(response) || response.status !== 'success') 19994 { 19995 var errorPromise = new BX.Promise(); 19996 errorPromise.reject(response); 19997 19998 return errorPromise; 19999 } 20000 20001 return response; 20002 }).catch(function(data) { 20003 var ajaxReject = new BX.Promise(); 20004 20005 if (BX.type.isPlainObject(data) && data.status && data.hasOwnProperty('data')) 20006 { 20007 ajaxReject.reject(data); 20008 } 20009 else 20010 { 20011 ajaxReject.reject({ 20012 status: 'error', 20013 data: { 20014 ajaxRejectData: data 20015 }, 20016 errors: [ 20017 {
20018 code: 'NETWORK_ERROR', 20019 message: 'Network error' 20020 } 20021 ] 20022 }); 20023 } 20024 20025 return ajaxReject; 20026 }).then(function(response){ 20027 20028 var assetsLoaded = new BX.Promise(); 20029 20030 var headers = request.getAllResponseHeaders().trim().split(/[\r\n]+/); 20031 var headerMap = {}; 20032 headers.forEach(function (line) { 20033 var parts = line.split(': '); 20034 var header = parts.shift().toLowerCase(); 20035 headerMap[header] = parts.join(': '); 20036 }); 20037 20038 if (!headerMap['x-process-assets']) 20039 { 20040 assetsLoaded.fulfill(response); 20041 20042 return assetsLoaded; 20043 } 20044 20045 var assets = BX.prop.getObject(BX.prop.getObject(response, "data", {}), "assets", {}); 20046 var promise = new Promise(function(resolve, reject) { 20047 var css = BX.prop.getArray(assets, "css", []); 20048 BX.load(css, function(){ 20049 BX.loadScript( 20050 BX.prop.getArray(assets, "js", []), 20051 resolve 20052 ); 20053 }); 20054 }); 20055 promise.then(function(){ 20056 var strings = BX.prop.getArray(assets, "string", []); 20057 var stringAsset = strings.join('\n'); 20058 BX.html(null, stringAsset).then(function(){ 20059 assetsLoaded.fulfill(response); 20060 }); 20061 }); 20062 20063 return assetsLoaded; 20064 }); 20065}; 20066 20067/** 20068 * 20069 * @param {string} action 20070 * @param {Object} config 20071 * @param {?string|?Object} [config.analyticsLabel] 20072 * @param {string} [config.method='POST'] 20073 * @param {Object} [config.data] 20074 * @param {?Object} [config.getParameters] 20075 * @param {?Object} [config.headers] 20076 * @param {?Object} [config.timeout] 20077 * @param {Object} [config.navigation] 20078 * @param {number} [config.navigation.page] 20079 */ 20080BX.ajax.runAction = function(action, config) 20081{ 20082 config = prepareAjaxConfig(config); 20083 var getParameters = prepareAjaxGetParameters(config); 20084 getParameters.action = action; 20085
20086 var url = '/bitrix/services/main/ajax.php?' + BX.ajax.prepareData(getParameters); 20087 return buildAjaxPromiseToRestoreCsrf({ 20088 method: config.method, 20089 dataType: 'json', 20090 url: url, 20091 data: config.data, 20092 timeout: config.timeout, 20093 preparePost: config.preparePost, 20094 headers: config.headers, 20095 onrequeststart: config.onrequeststart 20096 }); 20097}; 20098 20099/** 20100 * 20101 * @param {string} component 20102 * @param {string} action 20103 * @param {Object} config 20104 * @param {?string|?Object} [config.analyticsLabel] 20105 * @param {?string} [config.signedParameters] 20106 * @param {string} [config.method='POST'] 20107 * @param {string} [config.mode='ajax'] Ajax or class. 20108 * @param {Object} [config.data] 20109 * @param {?Object} [config.getParameters] 20110 * @param {?array} [config.headers] 20111 * @param {?number} [config.timeout] 20112 * @param {Object} [config.navigation] 20113 */ 20114BX.ajax.runComponentAction = function (component, action, config) 20115{ 20116 config = prepareAjaxConfig(config); 20117 config.mode = config.mode || 'ajax'; 20118 20119 var getParameters = prepareAjaxGetParameters(config); 20120 getParameters.c = component; 20121 getParameters.action = action; 20122
20123 var url = '/bitrix/services/main/ajax.php?' + BX.ajax.prepareData(getParameters); 20124 20125 return buildAjaxPromiseToRestoreCsrf({ 20126 method: config.method, 20127 dataType: 'json', 20128 url: url, 20129 data: config.data, 20130 timeout: config.timeout, 20131 preparePost: config.preparePost, 20132 headers: config.headers, 20133 onrequeststart: (config.onrequeststart ? config.onrequeststart : null) 20134 }); 20135}; 20136 20137/* 20138arObs = [{ 20139 url: url, 20140 type: html|script|json|css, 20141 callback: function 20142}] 20143*/ 20144BX.ajax.load = function(arObs, callback) 20145{ 20146 if (!BX.type.isArray(arObs)) 20147 arObs = [arObs]; 20148 20149 var cnt = 0; 20150 20151 if (!BX.type.isFunction(callback)) 20152 callback = BX.DoNothing; 20153 20154 var handler = function(data) 20155 { 20156 if (BX.type.isFunction(this.callback)) 20157 this.callback(data); 20158 20159 if (++cnt >= len) 20160 callback(); 20161 }; 20162 20163 for (var i = 0, len = arObs.length; i<len; i++) 20164 { 20165 switch(arObs[i].type.toUpperCase()) 20166 { 20167 case 'SCRIPT': 20168 BX.loadScript([arObs[i].url], BX.proxy(handler, arObs[i])); 20169 break; 20170 case 'CSS': 20171 BX.loadCSS([arObs[i].url]); 20172 20173 if (++cnt >= len) 20174 callback(); 20175 break; 20176 case 'JSON': 20177 BX.ajax.loadJSON(arObs[i].url, BX.proxy(handler, arObs[i])); 20178 break; 20179 20180 default: 20181 BX.ajax.get(arObs[i].url, '', BX.proxy(handler, arObs[i])); 20182 break; 20183 } 20184 } 20185}; 20186 20187/* ajax form sending */ 20188BX.ajax.submit = function(obForm, callback) 20189{ 20190 if (!obForm.target) 20191 { 20192 if (null == obForm.BXFormTarget) 20193 { 20194 var frame_name = 'formTarget_' + Math.random(); 20195 obForm.BXFormTarget = document.body.appendChild(BX.create('IFRAME', { 20196 props: { 20197 name: frame_name, 20198 id: frame_name, 20199 src: 'javascript:void(0)' 20200 }, 20201 style: { 20202 display: 'none' 20203 } 20204 })); 20205 } 20206 20207 obForm.target = obForm.BXFormTarget.name; 20208 } 20209 20210 obForm.BXFormCallback = callback; 20211 BX.bind(obForm.BXFormTarget, 'load', BX.proxy(BX.ajax._submit_callback, obForm)); 20212 20213 BX.submit(obForm); 20214 20215 return false; 20216}; 20217 20218BX.ajax.submitComponentForm = function(obForm, container, bWait) 20219{ 20220 if (!obForm.target) 20221 { 20222 if (null == obForm.BXFormTarget) 20223 { 20224 var frame_name = 'formTarget_' + Math.random(); 20225 obForm.BXFormTarget = document.body.appendChild(BX.create('IFRAME', { 20226 props: { 20227 name: frame_name, 20228 id: frame_name, 20229 src: 'javascript:void(0)' 20230 }, 20231 style: { 20232 display: 'none' 20233 } 20234 })); 20235 } 20236 20237 obForm.target = obForm.BXFormTarget.name; 20238 } 20239 20240 if (!!bWait) 20241 var w = BX.showWait(container); 20242 20243 obForm.BXFormCallback = function(d) { 20244 if (!!bWait) 20245 BX.closeWait(w); 20246 20247 var callOnload = function(){ 20248 if(!!window.bxcompajaxframeonload) 20249 { 20250 setTimeout(function(){window.bxcompajaxframeonload();window.bxcompajaxframeonload=null;}, 10); 20251 } 20252 }; 20253 20254 BX(container).innerHTML = d; 20255 BX.onCustomEvent('onAjaxSuccess', [null,null,callOnload]); 20256 }; 20257 20258 BX.bind(obForm.BXFormTarget, 'load', BX.proxy(BX.ajax._submit_callback, obForm)); 20259 20260 return true; 20261}; 20262 20263// func will be executed in form context 20264BX.ajax._submit_callback = function() 20265{ 20266 //opera and IE8 triggers onload event even on empty iframe 20267 try 20268 { 20269 if(this.BXFormTarget.contentWindow.location.href.indexOf('http') != 0) 20270 return; 20271 } catch (e) { 20272 return; 20273 } 20274 20275 if (this.BXFormCallback) 20276 this.BXFormCallback.apply(this, [this.BXFormTarget.contentWindow.document.body.innerHTML]); 20277 20278 BX.unbindAll(this.BXFormTarget); 20279}; 20280 20281BX.ajax.prepareForm = function(obForm, data) 20282{ 20283 data = (!!data ? data : {}); 20284 var i, ii, el, 20285 _data = [], 20286 n = obForm.elements.length, 20287 files = 0, length = 0; 20288 if(!!obForm) 20289 { 20290 for (i = 0; i < n; i++) 20291 { 20292 el = obForm.elements[i]; 20293 if (el.disabled) 20294 continue; 20295 20296 if(!el.type) 20297 continue; 20298 20299 switch(el.type.toLowerCase()) 20300 { 20301 case 'text': 20302 case 'textarea': 20303 case 'password': 20304 case 'number': 20305 case 'hidden': 20306 case 'select-one': 20307 _data.push({name: el.name, value: el.value}); 20308 length += (el.name.length + el.value.length); 20309 break; 20310 case 'file': 20311 if (!!el.files) 20312 { 20313 for (ii = 0; ii < el.files.length; ii++) 20314 { 20315 files++; 20316 _data.push({name: el.name, value: el.files[ii], file : true}); 20317 length += el.files[ii].size; 20318 } 20319 } 20320 break; 20321 case 'radio': 20322 case 'checkbox': 20323 if(el.checked) 20324 { 20325 _data.push({name: el.name, value: el.value}); 20326 length += (el.name.length + el.value.length); 20327 } 20328 break; 20329 case 'select-multiple': 20330 for (var j = 0; j < el.options.length; j++) 20331 { 20332 if (el.options[j].selected) 20333 { 20334 _data.push({name : el.name, value : el.options[j].value}); 20335 length += (el.name.length + el.options[j].length); 20336 } 20337 } 20338 break; 20339 default: 20340 break; 20341 } 20342 } 20343 20344 i = 0; length = 0; 20345 var current = data, name, rest, pp, tmpKey; 20346 20347 while(i < _data.length) 20348 { 20349 var p = _data[i].name.indexOf('['); 20350 if (tmpKey) 20351 { 20352 current[_data[i].name] = {}; 20353 current[_data[i].name][tmpKey.replace(/\[|\]/gi, '')] = _data[i].value; 20354 current = data; 20355 tmpKey = null; 20356 i++; 20357 } 20358 else if (p == -1) 20359 { 20360 current[_data[i].name] = _data[i].value; 20361 current = data; 20362 i++; 20363 } 20364 else 20365 {
20366 name = _data[i].name.substring(0, p); 20367 rest = _data[i].name.substring(p+1); 20368 pp = rest.indexOf(']'); 20369 20370 if(pp == -1) 20371 { 20372 if (!current[name]) 20373 current[name] = []; 20374 current = data; 20375 i++; 20376 } 20377 else if(pp == 0) 20378 { 20379 if (!current[name]) 20380 current[name] = []; 20381 //No index specified - so take the next integer 20382 current = current[name]; 20383 _data[i].name = '' + current.length; 20384 if (rest.substring(pp+1).indexOf('[') === 0) 20385 tmpKey = rest.substring(0, pp) + rest.substring(pp+1); 20386 } 20387 else 20388 { 20389 if (!current[name]) 20390 current[name] = {}; 20391 //Now index name becomes and name and we go deeper into the array 20392 current = current[name]; 20393 _data[i].name = rest.substring(0, pp) + rest.substring(pp+1); 20394 } 20395 } 20396 } 20397 } 20398 return {data : data, filesCount : files, roughSize : length}; 20399}; 20400BX.ajax.submitAjax = function(obForm, config) 20401{ 20402 config = (config !== null && typeof config == "object" ? config : {}); 20403 config.url = (config["url"] || obForm.getAttribute("action")); 20404 20405 var additionalData = (config["data"] || {}); 20406 config.data = BX.ajax.prepareForm(obForm).data; 20407 for (var ii in additionalData) 20408 { 20409 if (additionalData.hasOwnProperty(ii)) 20410 { 20411 config.data[ii] = additionalData[ii]; 20412 } 20413 } 20414 20415 if (!window["FormData"]) 20416 { 20417 BX.ajax(config); 20418 } 20419 else 20420 { 20421 var isFile = function(item) 20422 { 20423 var res = Object.prototype.toString.call(item); 20424 return (res == '[object File]' || res == '[object Blob]'); 20425 }, 20426 appendToForm = function(fd, key, val) 20427 { 20428 if (!!val && typeof val == "object" && !isFile(val)) 20429 { 20430 for (var ii in val) 20431 { 20432 if (val.hasOwnProperty(ii)) 20433 { 20434 appendToForm(fd, (key == '' ? ii : key + '[' + ii + ']'), val[ii]); 20435 } 20436 } 20437 } 20438 else 20439 fd.append(key, (!!val ? val : '')); 20440 }, 20441 prepareData = function(arData) 20442 { 20443 var data = {}; 20444 if (null != arData) 20445 { 20446 if(typeof arData == 'object') 20447 { 20448 for(var i in arData) 20449 { 20450 if (arData.hasOwnProperty(i)) 20451 { 20452 var name = BX.util.urlencode(i); 20453 if(typeof arData[i] == 'object' && arData[i]["file"] !== true) 20454 data[name] = prepareData(arData[i]); 20455 else if (arData[i]["file"] === true) 20456 data[name] = arData[i]["value"]; 20457 else 20458 data[name] = BX.util.urlencode(arData[i]); 20459 } 20460 } 20461 } 20462 else 20463 data = BX.util.urlencode(arData); 20464 } 20465 return data; 20466 }, 20467 fd = new window.FormData(); 20468 20469 if (config.method !== 'POST') 20470 { 20471 config.data = BX.ajax.prepareData(config.data); 20472 if (config.data) 20473 { 20474 config.url += (config.url.indexOf('?') !== -1 ? "&" : "?") + config.data; 20475 config.data = ''; 20476 } 20477 } 20478 else 20479 { 20480 if (config.preparePost === true) 20481 config.data = prepareData(config.data); 20482 appendToForm(fd, '', config.data); 20483 config.data = fd; 20484 } 20485 20486 config.preparePost = false; 20487 config.start = false;
20488 20489 var xhr = BX.ajax(config); 20490 if (!!config["onprogress"]) 20491 xhr.upload.addEventListener( 20492 'progress', 20493 function(e){ 20494 var percent = null; 20495 if(e.lengthComputable && (e.total || e["totalSize"])) { 20496 percent = e.loaded * 100 / (e.total || e["totalSize"]); 20497 } 20498 config["onprogress"](e, percent); 20499 } 20500 ); 20501 xhr.send(fd); 20502 } 20503}; 20504 20505BX.ajax.UpdatePageData = function (arData) 20506{ 20507 if (arData.TITLE) 20508 BX.ajax.UpdatePageTitle(arData.TITLE); 20509 if (arData.WINDOW_TITLE || arData.TITLE) 20510 BX.ajax.UpdateWindowTitle(arData.WINDOW_TITLE || arData.TITLE); 20511 if (arData.NAV_CHAIN) 20512 BX.ajax.UpdatePageNavChain(arData.NAV_CHAIN); 20513 if (arData.CSS && arData.CSS.length > 0) 20514 BX.loadCSS(arData.CSS); 20515 if (arData.SCRIPTS && arData.SCRIPTS.length > 0) 20516 { 20517 var f = function(result,config,cb){ 20518 20519 if(!!config && BX.type.isArray(config.scripts)) 20520 { 20521 for(var i=0,l=arData.SCRIPTS.length;i<l;i++) 20522 { 20523 config.scripts.push({isInternal:false,JS:arData.SCRIPTS[i]}); 20524 } 20525 } 20526 else 20527 { 20528 BX.loadScript(arData.SCRIPTS,cb); 20529 } 20530 20531 BX.removeCustomEvent('onAjaxSuccess',f); 20532 }; 20533 BX.addCustomEvent('onAjaxSuccess',f); 20534 } 20535 else 20536 { 20537 var f1 = function(result,config,cb){ 20538 if(BX.type.isFunction(cb)) 20539 { 20540 cb(); 20541 } 20542 BX.removeCustomEvent('onAjaxSuccess',f1); 20543 }; 20544 BX.addCustomEvent('onAjaxSuccess', f1); 20545 } 20546}; 20547 20548BX.ajax.UpdatePageTitle = function(title) 20549{ 20550 var obTitle = BX('pagetitle'); 20551 if (obTitle) 20552 { 20553 obTitle.removeChild(obTitle.firstChild); 20554 if (!obTitle.firstChild) 20555 obTitle.appendChild(document.createTextNode(title)); 20556 else 20557 obTitle.insertBefore(document.createTextNode(title), obTitle.firstChild); 20558 } 20559}; 20560 20561BX.ajax.UpdateWindowTitle = function(title) 20562{ 20563 document.title = title; 20564}; 20565 20566BX.ajax.UpdatePageNavChain = function(nav_chain) 20567{ 20568 var obNavChain = BX('navigation'); 20569 if (obNavChain) 20570 { 20571 obNavChain.innerHTML = nav_chain; 20572 } 20573}; 20574 20575/* user options handling */ 20576BX.userOptions = { 20577 options: null, 20578 bSend: false, 20579 delay: 5000, 20580 path: '/bitrix/admin/user_options.php?' 20581}; 20582 20583BX.userOptions.setAjaxPath = function(url) 20584{ 20585 BX.userOptions.path = url.indexOf('?') == -1? url+'?': url+'&'; 20586} 20587BX.userOptions.save = function(sCategory, sName, sValName, sVal, bCommon) 20588{ 20589 if (null == BX.userOptions.options) 20590 BX.userOptions.options = {}; 20591 20592 bCommon = !!bCommon; 20593 BX.userOptions.options[sCategory+'.'+sName+'.'+sValName] = [sCategory, sName, sValName, sVal, bCommon]; 20594 20595 var sParam = BX.userOptions.__get(); 20596 if (sParam != '') 20597 document.cookie = BX.message('COOKIE_PREFIX')+"_LAST_SETTINGS=" + encodeURIComponent(sParam) + "&sessid="+BX.bitrix_sessid()+"; expires=Thu, 31 Dec 2020 23:59:59 GMT; path=/;"; 20598 20599 if(!BX.userOptions.bSend) 20600 { 20601 BX.userOptions.bSend = true; 20602 setTimeout(function(){BX.userOptions.send(null)}, BX.userOptions.delay); 20603 } 20604}; 20605 20606BX.userOptions.send = function(callback) 20607{ 20608 var sParam = BX.userOptions.__get(); 20609 BX.userOptions.options = null; 20610 BX.userOptions.bSend = false; 20611 20612 if (sParam != '') 20613 { 20614 document.cookie = BX.message('COOKIE_PREFIX') + "_LAST_SETTINGS=; path=/;"; 20615 BX.ajax({ 20616 'method': 'GET', 20617 'dataType': 'html', 20618 'processData': false, 20619 'cache': false, 20620 'url': BX.userOptions.path+sParam+'&sessid='+BX.bitrix_sessid(), 20621 'onsuccess': callback 20622 }); 20623 } 20624}; 20625 20626BX.userOptions.del = function(sCategory, sName, bCommon, callback) 20627{ 20628 BX.ajax.get(BX.userOptions.path+'action=delete&c='+sCategory+'&n='+sName+(bCommon == true? '&common=Y':'')+'&sessid='+BX.bitrix_sessid(), callback); 20629}; 20630 20631BX.userOptions.__get = function() 20632{ 20633 if (!BX.userOptions.options) return ''; 20634 20635 var sParam = '', n = -1, prevParam = '', aOpt, i; 20636 20637 for (i in BX.userOptions.options) 20638 { 20639 if(BX.userOptions.options.hasOwnProperty(i)) 20640 { 20641 aOpt = BX.userOptions.options[i]; 20642 20643 if (prevParam != aOpt[0]+'.'+aOpt[1]) 20644 { 20645 n++; 20646 sParam += '&p['+n+'][c]='+BX.util.urlencode(aOpt[0]); 20647 sParam += '&p['+n+'][n]='+BX.util.urlencode(aOpt[1]); 20648 if (aOpt[4] == true) 20649 sParam += '&p['+n+'][d]=Y'; 20650 prevParam = aOpt[0]+'.'+aOpt[1]; 20651 } 20652 20653 var valueName = aOpt[2]; 20654 var value = aOpt[3]; 20655 20656 if (valueName === null) 20657 { 20658 sParam += '&p['+n+'][v]='+BX.util.urlencode(value); 20659 } 20660 else 20661 {
20662 sParam += '&p['+n+'][v]['+BX.util.urlencode(valueName)+']='+BX.util.urlencode(value); 20663 } 20664 } 20665 } 20666 20667 return sParam.substr(1); 20668}; 20669 20670BX.ajax.history = { 20671 expected_hash: '', 20672 20673 obParams: null, 20674 20675 obFrame: null, 20676 obImage: null, 20677 20678 obTimer: null, 20679 20680 bInited: false, 20681 bHashCollision: false, 20682 bPushState: !!(history.pushState && BX.type.isFunction(history.pushState)), 20683 20684 startState: null, 20685 20686 init: function(obParams) 20687 { 20688 if (BX.ajax.history.bInited) 20689 return; 20690 20691 this.obParams = obParams; 20692 var obCurrentState = this.obParams.getState(); 20693 20694 if (BX.ajax.history.bPushState) 20695 { 20696 BX.ajax.history.expected_hash = window.location.pathname; 20697 if (window.location.search) 20698 BX.ajax.history.expected_hash += window.location.search; 20699 20700 BX.ajax.history.put(obCurrentState, BX.ajax.history.expected_hash, '', true); 20701 // due to some strange thing, chrome calls popstate event on page start. so we should delay it 20702 setTimeout(function(){BX.bind(window, 'popstate', BX.ajax.history.__hashListener);}, 500); 20703 } 20704 else 20705 { 20706 BX.ajax.history.expected_hash = window.location.hash; 20707 20708 if (!BX.ajax.history.expected_hash || BX.ajax.history.expected_hash == '#') 20709 BX.ajax.history.expected_hash = '__bx_no_hash__'; 20710 20711 jsAjaxHistoryContainer.put(BX.ajax.history.expected_hash, obCurrentState); 20712 BX.ajax.history.obTimer = setTimeout(BX.ajax.history.__hashListener, 500); 20713 20714 if (BX.browser.IsIE()) 20715 { 20716 BX.ajax.history.obFrame = document.createElement('IFRAME'); 20717 BX.hide_object(BX.ajax.history.obFrame); 20718 20719 document.body.appendChild(BX.ajax.history.obFrame); 20720 20721 BX.ajax.history.obFrame.contentWindow.document.open(); 20722 BX.ajax.history.obFrame.contentWindow.document.write(BX.ajax.history.expected_hash); 20723 BX.ajax.history.obFrame.contentWindow.document.close(); 20724 } 20725 else if (BX.browser.IsOpera()) 20726 { 20727 BX.ajax.history.obImage = document.createElement('IMG'); 20728 BX.hide_object(BX.ajax.history.obImage); 20729 20730 document.body.appendChild(BX.ajax.history.obImage); 20731 20732 BX.ajax.history.obImage.setAttribute('src', 'javascript:location.href = \'javascript:BX.ajax.history.__hashListener();\';'); 20733 } 20734 } 20735 20736 BX.ajax.history.bInited = true; 20737 }, 20738 20739 __hashListener: function(e) 20740 { 20741 e = e || window.event || {state:false}; 20742 20743 if (BX.ajax.history.bPushState) 20744 { 20745 BX.ajax.history.obParams.setState(e.state||BX.ajax.history.startState); 20746 } 20747 else 20748 { 20749 if (BX.ajax.history.obTimer) 20750 { 20751 window.clearTimeout(BX.ajax.history.obTimer); 20752 BX.ajax.history.obTimer = null; 20753 } 20754 20755 var current_hash; 20756 if (null != BX.ajax.history.obFrame) 20757 current_hash = BX.ajax.history.obFrame.contentWindow.document.body.innerText; 20758 else 20759 current_hash = window.location.hash; 20760 20761 if (!current_hash || current_hash == '#') 20762 current_hash = '__bx_no_hash__'; 20763 20764 if (current_hash.indexOf('#') == 0) 20765 current_hash = current_hash.substring(1); 20766 20767 if (current_hash != BX.ajax.history.expected_hash) 20768 { 20769 var state = jsAjaxHistoryContainer.get(current_hash); 20770 if (state) 20771 { 20772 BX.ajax.history.obParams.setState(state); 20773 20774 BX.ajax.history.expected_hash = current_hash; 20775 if (null != BX.ajax.history.obFrame) 20776 { 20777 var __hash = current_hash == '__bx_no_hash__' ? '' : current_hash; 20778 if (window.location.hash != __hash && window.location.hash != '#' + __hash) 20779 window.location.hash = __hash; 20780 } 20781 } 20782 } 20783 20784 BX.ajax.history.obTimer = setTimeout(BX.ajax.history.__hashListener, 500); 20785 } 20786 }, 20787 20788 put: function(state, new_hash, new_hash1, bStartState) 20789 { 20790 if (this.bPushState) 20791 { 20792 if(!bStartState) 20793 { 20794 history.pushState(state, '', new_hash); 20795 } 20796 else 20797 { 20798 BX.ajax.history.startState = state; 20799 } 20800 } 20801 else 20802 { 20803 if (typeof new_hash1 != 'undefined') 20804 new_hash = new_hash1; 20805 else 20806 new_hash = 'view' + new_hash; 20807 20808 jsAjaxHistoryContainer.put(new_hash, state); 20809 BX.ajax.history.expected_hash = new_hash; 20810 20811 window.location.hash = BX.util.urlencode(new_hash); 20812 20813 if (null != BX.ajax.history.obFrame) 20814 { 20815 BX.ajax.history.obFrame.contentWindow.document.open(); 20816 BX.ajax.history.obFrame.contentWindow.document.write(new_hash); 20817 BX.ajax.history.obFrame.contentWindow.document.close(); 20818 } 20819 } 20820 }, 20821 20822 checkRedirectStart: function(param_name, param_value) 20823 { 20824 var current_hash = window.location.hash; 20825 if (current_hash.substring(0, 1) == '#') current_hash = current_hash.substring(1); 20826 20827 var test = current_hash.substring(0, 5); 20828 if (test == 'view/' || test == 'view%') 20829 { 20830 BX.ajax.history.bHashCollision = true;
20831 document.write('<' + 'div id="__ajax_hash_collision_' + param_value + '" style="display: none;">'); 20832 } 20833 }, 20834 20835 checkRedirectFinish: function(param_name, param_value) 20836 { 20837 document.write('</div>'); 20838 20839 var current_hash = window.location.hash; 20840 if (current_hash.substring(0, 1) == '#') current_hash = current_hash.substring(1); 20841 20842 BX.ready(function () 20843 { 20844 var test = current_hash.substring(0, 5); 20845 if (test == 'view/' || test == 'view%') 20846 { 20847 var obColNode = BX('__ajax_hash_collision_' + param_value); 20848 var obNode = obColNode.firstChild; 20849 BX.cleanNode(obNode); 20850 obColNode.style.display = 'block'; 20851 20852 // IE, Opera and Chrome automatically modifies hash with urlencode, but FF doesn't ;-( 20853 if (test != 'view%') 20854 current_hash = BX.util.urlencode(current_hash); 20855 20856 current_hash += (current_hash.indexOf('%3F') == -1 ? '%3F' : '%26') + param_name + '=' + param_value; 20857 20858 var url = '/bitrix/tools/ajax_redirector.php?hash=' + current_hash; 20859 20860 BX.ajax.insertToNode(url, obNode); 20861 } 20862 }); 20863 } 20864}; 20865 20866BX.ajax.component = function(node) 20867{ 20868 this.node = node; 20869}; 20870 20871BX.ajax.component.prototype.getState = function() 20872{ 20873 var state = { 20874 'node': this.node, 20875 'title': window.document.title, 20876 'data': BX(this.node).innerHTML 20877 }; 20878 20879 var obNavChain = BX('navigation'); 20880 if (null != obNavChain) 20881 state.nav_chain = obNavChain.innerHTML; 20882 20883 BX.onCustomEvent(BX(state.node), "onComponentAjaxHistoryGetState", [state]); 20884 20885 return state; 20886}; 20887 20888BX.ajax.component.prototype.setState = function(state) 20889{ 20890 BX(state.node).innerHTML = state.data; 20891 BX.ajax.UpdatePageTitle(state.title); 20892 20893 if (state.nav_chain) 20894 { 20895 BX.ajax.UpdatePageNavChain(state.nav_chain); 20896 } 20897 20898 BX.onCustomEvent(BX(state.node), "onComponentAjaxHistorySetState", [state]); 20899}; 20900 20901var jsAjaxHistoryContainer = { 20902 arHistory: {}, 20903 20904 put: function(hash, state) 20905 { 20906 this.arHistory[hash] = state; 20907 }, 20908 20909 get: function(hash) 20910 { 20911 return this.arHistory[hash]; 20912 } 20913}; 20914 20915 20916BX.ajax.FormData = function() 20917{ 20918 this.elements = []; 20919 this.files = []; 20920 this.features = {}; 20921 this.isSupported(); 20922 this.log('BX FormData init'); 20923}; 20924 20925BX.ajax.FormData.isSupported = function() 20926{ 20927 var f = new BX.ajax.FormData(); 20928 var result = f.features.supported; 20929 f = null; 20930 return result; 20931}; 20932 20933BX.ajax.FormData.prototype.log = function(o) 20934{ 20935 if (false) { 20936 try { 20937 if (BX.browser.IsIE()) o = JSON.stringify(o); 20938 console.log(o); 20939 } catch(e) {} 20940 } 20941}; 20942 20943BX.ajax.FormData.prototype.isSupported = function() 20944{ 20945 var f = {}; 20946 f.fileReader = (window.FileReader && window.FileReader.prototype.readAsBinaryString); 20947 f.readFormData = f.sendFormData = !!(window.FormData); 20948 f.supported = !!(f.readFormData && f.sendFormData); 20949 this.features = f; 20950 this.log('features:'); 20951 this.log(f); 20952 20953 return f.supported; 20954}; 20955 20956BX.ajax.FormData.prototype.append = function(name, value) 20957{ 20958 if (typeof(value) === 'object') { // seems to be files element 20959 this.files.push({'name': name, 'value':value}); 20960 } else { 20961 this.elements.push({'name': name, 'value':value}); 20962 } 20963}; 20964 20965BX.ajax.FormData.prototype.send = function(url, callbackOk, callbackProgress, callbackError) 20966{ 20967 this.log('FD send'); 20968 this.xhr = BX.ajax({ 20969 'method': 'POST', 20970 'dataType': 'html', 20971 'url': url, 20972 'onsuccess': callbackOk, 20973 'onfailure': callbackError, 20974 'start': false, 20975 'preparePost':false 20976 }); 20977 20978 if (callbackProgress) 20979 { 20980 this.xhr.upload.addEventListener( 20981 'progress', 20982 function(e) { 20983 if (e.lengthComputable) 20984 callbackProgress(e.loaded / (e.total || e.totalSize)); 20985 }, 20986 false 20987 ); 20988 } 20989 20990 if (this.features.readFormData && this.features.sendFormData) 20991 { 20992 var fd = new FormData(); 20993 this.log('use browser formdata'); 20994 for (var i in this.elements) 20995 { 20996 if(this.elements.hasOwnProperty(i)) 20997 fd.append(this.elements[i].name,this.elements[i].value); 20998 } 20999 for (i in this.files) 21000 { 21001 if(this.files.hasOwnProperty(i)) 21002 fd.append(this.files[i].name, this.files[i].value); 21003 } 21004 this.xhr.send(fd); 21005 } 21006 21007 return this.xhr; 21008}; 21009 21010BX.addCustomEvent('onAjaxFailure', BX.debug); 21011})(window); 21012 21013 21014 21015(function (exports,main_core) { 21016 'use strict'; 21017 21018 var LazyLoad = { 21019 observer: null, 21020 images: {}, 21021 imageStatus: { 21022 hidden: -2, 21023 error: -1, 21024 "undefined": 0, 21025 inited: 1, 21026 loaded: 2 21027 }, 21028 imageTypes: { 21029 image: 1, 21030 background: 2 21031 },
21032 initObserver: function initObserver() { 21033 this.observer = new IntersectionObserver(this.onIntersection.bind(this), { 21034 rootMargin: '20% 0% 20% 0%', 21035 threshold: 0.10 21036 }); 21037 }, 21038 onIntersection: function onIntersection(entries) { 21039 entries.forEach(function (entry) { 21040 if (entry.isIntersecting) { 21041 this.showImage(entry.target); 21042 } 21043 }.bind(this)); 21044 }, 21045 registerImage: function registerImage(id, isImageVisibleCallback, options) { 21046 if (this.observer === null) { 21047 this.initObserver(); 21048 } 21049 21050 options = options || {}; 21051 21052 if (!main_core.Type.isStringFilled(id)) { 21053 return; 21054 } 21055 21056 if (main_core.Type.isObject(this.images[id])) { 21057 return; 21058 } 21059 21060 var element = document.getElementById(id); 21061 21062 if (!main_core.Type.isDomNode(element)) { 21063 return; 21064 } 21065 21066 this.observer.observe(element); 21067 this.images[id] = { 21068 id: id, 21069 node: null, 21070 src: null, 21071 dataSrcName: options.dataSrcName || 'src', 21072 type: null, 21073 func: main_core.Type.isFunction(isImageVisibleCallback) ? isImageVisibleCallback : null, 21074 status: this.imageStatus.undefined 21075 }; 21076 }, 21077 registerImages: function registerImages(ids, isImageVisibleCallback, options) { 21078 if (main_core.Type.isArray(ids)) { 21079 for (var i = 0, length = ids.length; i < length; i++) { 21080 this.registerImage(ids[i], isImageVisibleCallback, options); 21081 } 21082 } 21083 }, 21084 showImage: function showImage(imageNode) { 21085 var imageNodeId = imageNode.id; 21086 21087 if (!main_core.Type.isStringFilled(imageNodeId)) { 21088 return; 21089 } 21090 21091 var image = this.images[imageNodeId]; 21092 21093 if (!main_core.Type.isPlainObject(image)) { 21094 return; 21095 } 21096 21097 if (image.status == this.imageStatus.undefined) { 21098 this.initImage(image); 21099 } 21100 21101 if (image.status !== this.imageStatus.inited) { 21102 return; 21103 } 21104 21105 if (!image.node || !image.node.parentNode) { 21106 image.node = null; 21107 image.status = this.imageStatus.error; 21108 return; 21109 } 21110 21111 if (image.type == this.imageTypes.image) { 21112 image.node.src = image.src; 21113 } else { 21114 image.node.style.backgroundImage = "url('" + image.src + "')"; 21115 } 21116 21117 image.node.dataset[image.dataSrcName] = ""; 21118 image.status = this.imageStatus.loaded; 21119 }, 21120 showImages: function showImages(checkOwnVisibility) { 21121 checkOwnVisibility = checkOwnVisibility !== false; 21122 21123 for (var id in this.images) { 21124 if (!this.images.hasOwnProperty(id)) { 21125 continue; 21126 } 21127 21128 var image = this.images[id]; 21129 21130 if (image.status == this.imageStatus.undefined) { 21131 this.initImage(image); 21132 } 21133 21134 if (image.status !== this.imageStatus.inited) { 21135 continue; 21136 } 21137 21138 if (!image.node || !image.node.parentNode) { 21139 image.node = null; 21140 image.status = this.imageStatus.error; 21141 continue; 21142 } 21143 21144 var isImageVisible = true; 21145 21146 if (checkOwnVisibility && main_core.Type.isFunction(image.func)) { 21147 isImageVisible = image.func(image); 21148 } 21149 21150 if (isImageVisible === true && this.isElementVisibleOnScreen(image.node)) { 21151 if (image.type == this.imageTypes.image) { 21152 image.node.src = image.src; 21153 } else { 21154 image.node.style.backgroundImage = "url('" + image.src + "')"; 21155 } 21156 21157 image.node.dataset[image.dataSrcName] = ""; 21158 image.status = this.imageStatus.loaded; 21159 } 21160 } 21161 }, 21162 initImage: function initImage(image) { 21163 image.status = this.imageStatus.error; 21164 var node = document.getElementById(image.id); 21165 21166 if (!main_core.Type.isDomNode(node)) { 21167 return; 21168 } 21169 21170 var src = node.dataset[image.dataSrcName]; 21171 21172 if (main_core.Type.isStringFilled(src)) { 21173 image.node = node; 21174 image.src = src; 21175 image.status = this.imageStatus.inited; 21176 image.type = image.node.tagName.toLowerCase() == "img" ? this.imageTypes.image : this.imageTypes.background; 21177 } 21178 }, 21179 isElementVisibleOnScreen: function isElementVisibleOnScreen(element) { 21180 var coords = this.getElementCoords(element); 21181 var windowTop = window.pageYOffset || document.documentElement.scrollTop; 21182 var windowBottom = windowTop + document.documentElement.clientHeight; 21183 coords.bottom = coords.top + element.offsetHeight; 21184 return coords.top > windowTop && coords.top < windowBottom || // topVisible 21185 coords.bottom < windowBottom && coords.bottom > windowTop // bottomVisible 21186 ; 21187 }, 21188 isElementVisibleOn2Screens: function isElementVisibleOn2Screens(element) { 21189 var windowHeight = document.documentElement.clientHeight; 21190 var windowTop = window.pageYOffset || document.documentElement.scrollTop; 21191 var windowBottom = windowTop + windowHeight; 21192 var coords = this.getElementCoords(element); 21193 coords.bottom = coords.top + element.offsetHeight; 21194 windowTop -= windowHeight; 21195 windowBottom += windowHeight; 21196 return coords.top > windowTop && coords.top < windowBottom || // topVisible 21197 coords.bottom < windowBottom && coords.bottom > windowTop // bottomVisible 21198 ; 21199 }, 21200 getElementCoords: function getElementCoords(element) { 21201 var box = element.getBoundingClientRect(); 21202 return { 21203 originTop: box.top, 21204 originLeft: box.left, 21205 top: box.top + window.pageYOffset, 21206 left: box.left + window.pageXOffset 21207 }; 21208 }, 21209 onScroll: function onScroll() {}, 21210 clearImages: function clearImages() { 21211 this.images = []; 21212 } 21213 }; 21214 21215 exports.LazyLoad = LazyLoad; 21216 21217}((this.BX = this.BX || {}),BX)); 21218 21219 21220 21221(function (exports) { 21222 'use strict'; 21223 21224 var ParamBag = 21225 /*#__PURE__*/ 21226 function () { 21227 function ParamBag() { 21228 var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 21229 babelHelpers.classCallCheck(this, ParamBag); 21230 21231 if (!!params && babelHelpers.typeof(params) === 'object') { 21232 this.params = new Map(Object.entries(params)); 21233 } else { 21234 this.params = new Map(); 21235 } 21236 } 21237 21238 babelHelpers.createClass(ParamBag, [{ 21239 key: "getParam", 21240 value: function getParam(key) { 21241 var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 21242 21243 if (this.params.has(key)) { 21244 return this.params.get(key); 21245 } 21246 21247 return defaultValue; 21248 } 21249 }, { 21250 key: "setParam", 21251 value: function setParam(key, value) { 21252 this.params.set(key, value); 21253 } 21254 }, { 21255 key: "clear", 21256 value: function clear() { 21257 this.params.clear(); 21258 } 21259 }], [{ 21260 key: "create", 21261 value: function create() { 21262 var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 21263 return new ParamBag(params); 21264 } 21265 }]); 21266 return ParamBag; 21267 }(); 21268 21269 exports.ParamBag = ParamBag; 21270 21271}((this.BX = this.BX || {}))); 21272 21273 21274 21275(function() { 21276 BX.FixFontSize = function(params) 21277 { 21278 var widthNode, computedStyles, width; 21279 21280 this.node = null; 21281 this.prevWindowSize = 0; 21282 this.prevWrapperSize = 0; 21283 this.mainWrapper = null; 21284 this.textWrapper = null; 21285 this.objList = params.objList; 21286 this.minFontSizeList = []; 21287 this.minFontSize = 0; 21288 21289 if (params.onresize) 21290 { 21291 this.prevWindowSize = window.innerWidth || document.documentElement.clientWidth; 21292 BX.bind(window, 'resize', BX.throttle(this.onResize, 350, this)); 21293 } 21294 21295 if (params.onAdaptiveResize) 21296 { 21297 widthNode = this.objList[0].scaleBy || this.objList[0].node; 21298 computedStyles = getComputedStyle(widthNode); 21299 this.prevWrapperSize = parseInt(computedStyles["width"]) - parseInt(computedStyles["paddingLeft"]) - parseInt(computedStyles["paddingRight"]); 21300 BX.bind(window, 'resize', BX.throttle(this.onAdaptiveResize, 350, this)); 21301 } 21302 21303 this.createTestNodes(); 21304 this.decrease(); 21305 }; 21306 21307 BX.FixFontSize.prototype = 21308 { 21309 createTestNodes: function() 21310 { 21311 this.textWrapper = BX.create('div',{ 21312 style : { 21313 display : 'inline-block', 21314 whiteSpace : 'nowrap' 21315 } 21316 }); 21317 21318 this.mainWrapper = BX.create('div',{ 21319 style : { 21320 height : 0, 21321 overflow : 'hidden' 21322 }, 21323 children : [this.textWrapper] 21324 }); 21325 21326 }, 21327 insertTestNodes: function() 21328 { 21329 document.body.appendChild(this.mainWrapper); 21330 }, 21331 removeTestNodes: function() 21332 { 21333 document.body.removeChild(this.mainWrapper); 21334 }, 21335 decrease: function() 21336 { 21337 var width, 21338 fontSize, 21339 widthNode, 21340 computedStyles; 21341 21342 this.insertTestNodes(); 21343
21344 for(var i=this.objList.length-1; i>=0; i--) 21345 { 21346 widthNode = this.objList[i].scaleBy || this.objList[i].node; 21347 computedStyles = getComputedStyle(widthNode); 21348 width = parseInt(computedStyles["width"]) - parseInt(computedStyles["paddingLeft"]) - parseInt(computedStyles["paddingRight"]); 21349 fontSize = parseInt(getComputedStyle(this.objList[i].node)["font-size"]); 21350 21351 this.textWrapperSetStyle(this.objList[i].node); 21352 21353 if(this.textWrapperInsertText(this.objList[i].node)) 21354 { 21355 while(this.textWrapper.offsetWidth > width && fontSize > 0) 21356 { 21357 this.textWrapper.style.fontSize = --fontSize + 'px'; 21358 } 21359 21360 if(this.objList[i].smallestValue) 21361 { 21362 this.minFontSize = this.minFontSize ? Math.min(this.minFontSize, fontSize) : fontSize; 21363 21364 this.minFontSizeList.push(this.objList[i].node) 21365 } 21366 else 21367 { 21368 this.objList[i].node.style.fontSize = fontSize + 'px'; 21369 } 21370 } 21371 } 21372 21373 if(this.minFontSizeList.length > 0) 21374 this.setMinFont(); 21375 21376 this.removeTestNodes(); 21377 21378 }, 21379 increase: function() 21380 { 21381 this.insertTestNodes(); 21382 var width, 21383 fontSize, 21384 widthNode, 21385 computedStyles; 21386 21387 this.insertTestNodes(); 21388 21389 for(var i=this.objList.length-1; i>=0; i--) 21390 { 21391 widthNode = this.objList[i].scaleBy || this.objList[i].node; 21392 computedStyles = getComputedStyle(widthNode); 21393 width = parseInt(computedStyles["width"]) - parseInt(computedStyles["paddingLeft"]) - parseInt(computedStyles["paddingRight"]); 21394 fontSize = parseInt(getComputedStyle(this.objList[i].node)["font-size"]); 21395 21396 this.textWrapperSetStyle(this.objList[i].node); 21397 21398 if(this.textWrapperInsertText(this.objList[i].node)) 21399 { 21400 while(this.textWrapper.offsetWidth < width && fontSize < this.objList[i].maxFontSize) 21401 { 21402 this.textWrapper.style.fontSize = ++fontSize + 'px'; 21403 } 21404 21405 fontSize--; 21406 21407 if(this.objList[i].smallestValue) 21408 { 21409 this.minFontSize = this.minFontSize ? Math.min(this.minFontSize, fontSize) : fontSize; 21410 21411 this.minFontSizeList.push(this.objList[i].node) 21412 } 21413 else 21414 { 21415 this.objList[i].node.style.fontSize = fontSize + 'px'; 21416 } 21417 } 21418 } 21419 21420 if(this.minFontSizeList.length > 0) 21421 this.setMinFont(); 21422 21423 this.removeTestNodes(); 21424 }, 21425 setMinFont : function() 21426 { 21427 for(var i = this.minFontSizeList.length-1; i>=0; i--) 21428 { 21429 this.minFontSizeList[i].style.fontSize = this.minFontSize + 'px'; 21430 } 21431 21432 this.minFontSize = 0; 21433 }, 21434 onResize : function() 21435 { 21436 var width = window.innerWidth || document.documentElement.clientWidth; 21437 21438 if(this.prevWindowSize > width) 21439 this.decrease(); 21440 21441 else if (this.prevWindowSize < width) 21442 this.increase(); 21443 21444 this.prevWindowSize = width; 21445 }, 21446 onAdaptiveResize : function() 21447 { 21448 var widthNode = this.objList[0].scaleBy || this.objList[0].node, 21449 computedStyles = getComputedStyle(widthNode), 21450 width = parseInt(computedStyles["width"]) - parseInt(computedStyles["paddingLeft"]) - parseInt(computedStyles["paddingRight"]); 21451 21452 if (this.prevWrapperSize > width) 21453 this.decrease(); 21454 else if (this.prevWrapperSize < width) 21455 this.increase(); 21456 21457 this.prevWrapperSize = width; 21458 }, 21459 textWrapperInsertText : function(node) 21460 { 21461 if(node.textContent){ 21462 this.textWrapper.textContent = node.textContent; 21463 return true; 21464 } 21465 else if(node.innerText) 21466 { 21467 this.textWrapper.innerText = node.innerText; 21468 return true; 21469 } 21470 else { 21471 return false; 21472 } 21473 }, 21474 textWrapperSetStyle : function(node) 21475 { 21476 this.textWrapper.style.fontFamily = getComputedStyle(node)["font-family"]; 21477 this.textWrapper.style.fontSize = getComputedStyle(node)["font-size"]; 21478 this.textWrapper.style.fontStyle = getComputedStyle(node)["font-style"]; 21479 this.textWrapper.style.fontWeight = getComputedStyle(node)["font-weight"]; 21480 this.textWrapper.style.lineHeight = getComputedStyle(node)["line-height"]; 21481 } 21482 }; 21483 21484 BX.FixFontSize.init = function(params) 21485 { 21486 return new BX.FixFontSize(params); 21487 }; 21488})(); 21489 21490})(); 21491//# sourceMappingURL=core.js.map
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.