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 var Extension = 10020 /*#__PURE__*/ 10021 function () { 10022 function Extension(options) { 10023 babelHelpers.classCallCheck(this, Extension); 10024 this.config = options.config || {}; 10025 this.name = options.extension; 10026 this.state = 'scheduled'; // eslint-disable-next-line 10027 10028 var result = BX.processHTML(options.html || ''); 10029 this.inlineScripts = result.SCRIPT.reduce(inlineScripts, []); 10030 this.externalScripts = result.SCRIPT.reduce(externalScripts, []); 10031 this.externalStyles = result.STYLE.reduce(externalStyles, []); 10032 } 10033 10034 babelHelpers.createClass(Extension, [{ 10035 key: "load", 10036 value: function load() { 10037 var _this = this; 10038 10039 if (this.state === 'error') { 10040 this.loadPromise = this.loadPromise || Promise.resolve(this); 10041 console.warn('Extension', this.name, 'not found'); 10042 } 10043 10044 if (!this.loadPromise && this.state) { 10045 this.state = 'load'; // eslint-disable-next-line 10046
10047 this.inlineScripts.forEach(BX.evalGlobal); 10048 this.loadPromise = Promise.all([loadAll(this.externalScripts), loadAll(this.externalStyles)]).then(function () { 10049 _this.state = 'loaded'; 10050 10051 if (Type.isPlainObject(_this.config) && _this.config.namespace) { 10052 return Reflection.getClass(_this.config.namespace); 10053 } 10054 10055 return window; 10056 }); 10057 } 10058 10059 return this.loadPromise; 10060 } 10061 }]); 10062 return Extension; 10063 }(); 10064 10065 var initialized = {}; 10066 var ajaxController = 'main.bitrix.main.controller.loadext.getextensions'; 10067 10068 function makeIterable(value) { 10069 return Type.isArray(value) ? value : [value]; 10070 } 10071 function isInitialized(extension) { 10072 return extension in initialized; 10073 } 10074 function getInitialized(extension) { 10075 return initialized[extension]; 10076 } 10077 function isAllInitialized(extensions) { 10078 return extensions.every(isInitialized); 10079 } 10080 function loadExtensions(extensions) { 10081 return Promise.all(extensions.map(function (item) { 10082 return item.load(); 10083 })); 10084 } 10085 function mergeExports(exports) { 10086 return exports.reduce(function (acc, currentExports) { 10087 if (Type.isObject(currentExports)) { 10088 return babelHelpers.objectSpread({}, currentExports); 10089 } 10090 10091 return currentExports; 10092 }, {}); 10093 } 10094 function inlineScripts(acc, item) { 10095 if (item.isInternal) { 10096 acc.push(item.JS); 10097 } 10098 10099 return acc; 10100 } 10101 function externalScripts(acc, item) { 10102 if (!item.isInternal) { 10103 acc.push(item.JS); 10104 } 10105 10106 return acc; 10107 } 10108 function externalStyles(acc, item) { 10109 if (Type.isString(item) && item !== '') { 10110 acc.push(item); 10111 } 10112 10113 return acc; 10114 } 10115 function request(options) { 10116 return new Promise(function (resolve) { 10117 // eslint-disable-next-line 10118 BX.ajax.runAction(ajaxController, { 10119 data: options 10120 }).then(resolve); 10121 }); 10122 } 10123 function prepareExtensions(response) { 10124 if (response.status !== 'success') { 10125 response.errors.map(console.warn); 10126 return []; 10127 } 10128 10129 return response.data.map(function (item) { 10130 var initializedExtension = getInitialized(item.extension); 10131 10132 if (initializedExtension) { 10133 return initializedExtension; 10134 } 10135 10136 initialized[item.extension] = new Extension(item); 10137 return initialized[item.extension]; 10138 }); 10139 } 10140 function loadAll(items) { 10141 var itemsList = makeIterable(items); 10142 10143 if (!itemsList.length) { 10144 return Promise.resolve(); 10145 } 10146 10147 return new Promise(function (resolve) { 10148 // eslint-disable-next-line 10149 BX.load(itemsList, resolve); 10150 }); 10151 } 10152 10153 /** 10154 * Loads extensions asynchronously 10155 * @param {string|Array<string>} extension 10156 * @return {Promise<Array<Extension>>} 10157 */ 10158 function loadExtension(extension) { 10159 var extensions = makeIterable(extension); 10160 var isAllInitialized$$1 = isAllInitialized(extensions); 10161 10162 if (isAllInitialized$$1) { 10163 var initializedExtensions = extensions.map(getInitialized); 10164 return loadExtensions(initializedExtensions).then(mergeExports); 10165 } 10166 10167 return request({ 10168 extension: extensions 10169 }).then(prepareExtensions).then(loadExtensions).then(mergeExports); 10170 } 10171 10172 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]']; 10173 10174 function isCloneable(value) { 10175 var isCloneableValue = Type.isObjectLike(value) && cloneableTags.includes(getTag(value)); 10176 return isCloneableValue || Type.isDomNode(value); 10177 } 10178 10179 function internalClone(value, map) { 10180 if (map.has(value)) { 10181 return map.get(value); 10182 } 10183 10184 if (isCloneable(value)) { 10185 if (Type.isArray(value)) { 10186 var cloned = Array.from(value); 10187 map.set(value, cloned); 10188 value.forEach(function (item, index) { 10189 cloned[index] = internalClone(item, map); 10190 }); 10191 return map.get(value); 10192 } 10193 10194 if (Type.isDomNode(value)) { 10195 return value.cloneNode(true); 10196 } 10197 10198 if (Type.isMap(value)) { 10199 var _result = new Map(); 10200 10201 map.set(value, _result); 10202 value.forEach(function (item, key) { 10203 _result.set(internalClone(key, map), internalClone(item, map)); 10204 }); 10205 return _result; 10206 } 10207 10208 if (Type.isSet(value)) { 10209 var _result2 = new Set(); 10210 10211 map.set(value, _result2); 10212 value.forEach(function (item) { 10213 _result2.add(internalClone(item, map)); 10214 }); 10215 return _result2; 10216 } 10217 10218 if (Type.isDate(value)) { 10219 return new Date(value); 10220 } 10221 10222 if (Type.isRegExp(value)) { 10223 var regExpFlags = /\w*$/; 10224 var flags = regExpFlags.exec(value); 10225 10226 var _result3 = new RegExp(value.source); 10227 10228 if (flags && Type.isArray(flags)) { 10229 _result3 = new RegExp(value.source, flags[0]); 10230 } 10231 10232 _result3.lastIndex = value.lastIndex; 10233 return _result3; 10234 } 10235 10236 var proto = Object.getPrototypeOf(value); 10237 var result = Object.assign(Object.create(proto), value); 10238 map.set(value, result); 10239 Object.keys(value).forEach(function (key) { 10240 result[key] = internalClone(value[key], map); 10241 }); 10242 return result; 10243 } 10244 10245 return value; 10246 }
10247 /** 10248 * Clones any cloneable object 10249 * @param value 10250 * @return {*} 10251 */ 10252 10253 function clone(value) { 10254 return internalClone(value, new WeakMap()); 10255 } 10256 10257 function merge(current, target) { 10258 return Object.entries(target).reduce(function (acc, _ref) { 10259 var _ref2 = babelHelpers.slicedToArray(_ref, 2), 10260 key = _ref2[0], 10261 value = _ref2[1]; 10262 10263 if (!Type.isDomNode(acc[key]) && Type.isObjectLike(acc[key]) && Type.isObjectLike(value)) { 10264 acc[key] = merge(acc[key], value); 10265 return acc; 10266 } 10267 10268 acc[key] = value; 10269 return acc; 10270 }, current); 10271 } 10272 10273 function createComparator(fields) { 10274 var orders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 10275 return function (a, b) { 10276 var field = fields[0]; 10277 var order = orders[0] || 'asc'; 10278 10279 if (Type.isUndefined(field)) { 10280 return 0; 10281 } 10282 10283 var valueA = a[field]; 10284 var valueB = b[field]; 10285 10286 if (Type.isString(valueA) && Type.isString(valueB)) { 10287 valueA = valueA.toLowerCase(); 10288 valueB = valueB.toLowerCase(); 10289 } 10290 10291 if (valueA < valueB) { 10292 return order === 'asc' ? -1 : 1; 10293 } 10294 10295 if (valueA > valueB) { 10296 return order === 'asc' ? 1 : -1; 10297 } 10298 10299 return createComparator(fields.slice(1), orders.slice(1))(a, b); 10300 }; 10301 } 10302 10303 /** 10304 * @memberOf BX 10305 */ 10306 10307 var Runtime = 10308 /*#__PURE__*/ 10309 function () { 10310 function Runtime() { 10311 babelHelpers.classCallCheck(this, Runtime); 10312 } 10313 10314 babelHelpers.createClass(Runtime, null, [{ 10315 key: "debounce", 10316 value: function debounce(func) { 10317 var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 10318 var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; 10319 var timeoutId; 10320 return function debounced() { 10321 var _this = this; 10322 10323 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 10324 args[_key] = arguments[_key]; 10325 } 10326 10327 if (Type.isNumber(timeoutId)) { 10328 clearTimeout(timeoutId); 10329 } 10330 10331 timeoutId = setTimeout(function () { 10332 func.apply(context || _this, args); 10333 }, wait); 10334 }; 10335 } 10336 }, { 10337 key: "throttle", 10338 value: function throttle(func) { 10339 var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 10340 var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; 10341 var timer = 0; 10342 var invoke; 10343 return function wrapper() { 10344 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 10345 args[_key2] = arguments[_key2]; 10346 } 10347 10348 invoke = true; 10349 10350 if (!timer) { 10351 var q = function q() { 10352 if (invoke) { 10353 func.apply(context || this, args); 10354 invoke = false; 10355 timer = setTimeout(q, wait); 10356 } else { 10357 timer = null; 10358 } 10359 }; 10360 10361 q(); 10362 } 10363 }; 10364 } 10365 }, { 10366 key: "html", 10367 value: function html(node, _html) { 10368 var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 10369 10370 if (Type.isNil(_html) && Type.isDomNode(node)) { 10371 return node.innerHTML; 10372 } // eslint-disable-next-line 10373 10374 10375 var parsedHtml = BX.processHTML(_html); 10376 var externalCss = parsedHtml.STYLE.reduce(externalStyles, []); 10377 var externalJs = parsedHtml.SCRIPT.reduce(externalScripts, []); 10378 var inlineJs = parsedHtml.SCRIPT.reduce(inlineScripts, []); 10379 10380 if (Type.isDomNode(node)) { 10381 if (params.htmlFirst || !externalJs.length && !externalCss.length) { 10382 node.innerHTML = parsedHtml.HTML; 10383 } 10384 } 10385 10386 return Promise.all([loadAll(externalJs), loadAll(externalCss)]).then(function () { 10387 if (Type.isDomNode(node) && (externalJs.length > 0 || externalCss.length > 0)) { 10388 node.innerHTML = parsedHtml.HTML; 10389 } // eslint-disable-next-line 10390 10391 10392 inlineJs.forEach(function (script) { 10393 return BX.evalGlobal(script); 10394 }); 10395 10396 if (Type.isFunction(params.callback)) { 10397 params.callback(); 10398 } 10399 }); 10400 } 10401 /** 10402 * Merges objects or arrays 10403 * @param targets 10404 * @return {any} 10405 */ 10406 10407 }, { 10408 key: "merge", 10409 value: function merge$$1() { 10410 for (var _len3 = arguments.length, targets = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { 10411 targets[_key3] = arguments[_key3]; 10412 } 10413 10414 if (Type.isArray(targets[0])) { 10415 targets.unshift([]); 10416 } else if (Type.isObject(targets[0])) { 10417 targets.unshift({}); 10418 } 10419 10420 return targets.reduce(function (acc, item) { 10421 return merge(acc, item); 10422 }, targets[0]); 10423 } 10424 }, { 10425 key: "orderBy", 10426 value: function orderBy(collection) { 10427 var fields = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 10428 var orders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; 10429 var comparator = createComparator(fields, orders); 10430 return Object.values(collection).sort(comparator); 10431 } 10432 }]); 10433 return Runtime; 10434 }(); 10435 10436 babelHelpers.defineProperty(Runtime, "debug", debug); 10437 babelHelpers.defineProperty(Runtime, "loadExtension", loadExtension); 10438 babelHelpers.defineProperty(Runtime, "clone", clone); 10439 10440 var _isError = Symbol.for('BX.BaseError.isError'); 10441 /** 10442 * @memberOf BX 10443 */ 10444 10445 10446 var BaseError = 10447 /*#__PURE__*/ 10448 function () { 10449 function BaseError(message, code, customData) { 10450 babelHelpers.classCallCheck(this, BaseError); 10451 this[_isError] = true; 10452 this.message = ''; 10453 this.code = null; 10454 this.customData = null; 10455 this.setMessage(message); 10456 this.setCode(code); 10457 this.setCustomData(customData); 10458 } 10459 /** 10460 * Returns a brief description of the error 10461 * @returns {string} 10462 */ 10463 10464 10465 babelHelpers.createClass(BaseError, [{ 10466 key: "getMessage",
10467 value: function getMessage() { 10468 return this.message; 10469 } 10470 /** 10471 * Sets a message of the error 10472 * @param {string} message 10473 * @returns {this} 10474 */ 10475 10476 }, { 10477 key: "setMessage", 10478 value: function setMessage(message) { 10479 if (Type.isString(message)) { 10480 this.message = message; 10481 } 10482 10483 return this; 10484 } 10485 /** 10486 * Returns a code of the error 10487 * @returns {?string} 10488 */ 10489 10490 }, { 10491 key: "getCode", 10492 value: function getCode() { 10493 return this.code; 10494 } 10495 /** 10496 * Sets a code of the error 10497 * @param {string} code 10498 * @returns {this} 10499 */ 10500 10501 }, { 10502 key: "setCode", 10503 value: function setCode(code) { 10504 if (Type.isStringFilled(code) || code === null) { 10505 this.code = code; 10506 } 10507 10508 return this; 10509 } 10510 /** 10511 * Returns custom data of the error 10512 * @returns {null|*} 10513 */ 10514 10515 }, { 10516 key: "getCustomData", 10517 value: function getCustomData() { 10518 return this.customData; 10519 } 10520 /** 10521 * Sets custom data of the error 10522 * @returns {this} 10523 */ 10524 10525 }, { 10526 key: "setCustomData", 10527 value: function setCustomData(customData) { 10528 if (!Type.isUndefined(customData)) { 10529 this.customData = customData; 10530 } 10531 10532 return this; 10533 } 10534 }, { 10535 key: "toString", 10536 value: function toString() { 10537 var code = this.getCode(); 10538 var message = this.getMessage(); 10539 10540 if (!Type.isStringFilled(code) && !Type.isStringFilled(message)) { 10541 return ''; 10542 } else if (!Type.isStringFilled(code)) { 10543 return "Error: ".concat(message); 10544 } else if (!Type.isStringFilled(message)) { 10545 return code; 10546 } else { 10547 return "".concat(code, ": ").concat(message); 10548 } 10549 } 10550 /** 10551 * Returns true if the object is an instance of BaseError 10552 * @param error 10553 * @returns {boolean} 10554 */ 10555 10556 }], [{ 10557 key: "isError", 10558 value: function isError(error) { 10559 return Type.isObject(error) && error[_isError] === true; 10560 } 10561 }]); 10562 return BaseError; 10563 }(); 10564 10565 /** 10566 * Implements base event object interface 10567 */ 10568 10569 var BaseEvent = 10570 /*#__PURE__*/ 10571 function () { 10572 function BaseEvent() { 10573 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { 10574 data: {} 10575 }; 10576 babelHelpers.classCallCheck(this, BaseEvent); 10577 this.type = ''; 10578 this.data = null; 10579 this.target = null; 10580 this.compatData = null; 10581 this.defaultPrevented = false; 10582 this.immediatePropagationStopped = false; 10583 this.errors = []; 10584 this.setData(options.data); 10585 this.setCompatData(options.compatData); 10586 } 10587 10588 babelHelpers.createClass(BaseEvent, [{ 10589 key: "getType", 10590 10591 /** 10592 * Returns the name of the event 10593 * @returns {string} 10594 */ 10595 value: function getType() { 10596 return this.type; 10597 } 10598 /** 10599 * 10600 * @param {string} type 10601 */ 10602 10603 }, { 10604 key: "setType", 10605 value: function setType(type) { 10606 if (Type.isStringFilled(type)) { 10607 this.type = type; 10608 } 10609 10610 return this; 10611 } 10612 /** 10613 * Returns an event data 10614 */ 10615 10616 }, { 10617 key: "getData", 10618 value: function getData() { 10619 return this.data; 10620 } 10621 /** 10622 * Sets an event data 10623 * @param data 10624 */ 10625 10626 }, { 10627 key: "setData", 10628 value: function setData(data) { 10629 if (!Type.isUndefined(data)) { 10630 this.data = data; 10631 } 10632 10633 return this; 10634 } 10635 /** 10636 * Returns arguments for BX.addCustomEvent handlers (deprecated). 10637 * @returns {array | null} 10638 */ 10639 10640 }, { 10641 key: "getCompatData", 10642 value: function getCompatData() { 10643 return this.compatData; 10644 } 10645 /** 10646 * Sets arguments for BX.addCustomEvent handlers (deprecated) 10647 * @param data 10648 */ 10649 10650 }, { 10651 key: "setCompatData", 10652 value: function setCompatData(data) { 10653 if (Type.isArrayLike(data)) { 10654 this.compatData = data; 10655 } 10656 10657 return this; 10658 } 10659 /** 10660 * Sets a event target 10661 * @param target 10662 */ 10663 10664 }, { 10665 key: "setTarget", 10666 value: function setTarget(target) { 10667 this.target = target; 10668 return this; 10669 } 10670 /** 10671 * Returns a event target 10672 */ 10673 10674 }, { 10675 key: "getTarget", 10676 value: function getTarget() { 10677 return this.target; 10678 } 10679 /** 10680 * Returns an array of event errors 10681 * @returns {[]} 10682 */ 10683 10684 }, { 10685 key: "getErrors", 10686 value: function getErrors() { 10687 return this.errors; 10688 } 10689 /** 10690 * Adds an error of the event. 10691 * Event listeners can prevent emitter's default action and set the reason of this behavior. 10692 * @param error 10693 */ 10694 10695 }, { 10696 key: "setError", 10697 value: function setError(error) { 10698 if (BaseError.isError(error)) { 10699 this.errors.push(error); 10700 } 10701 } 10702 /** 10703 * Prevents default action 10704 */ 10705 10706 }, { 10707 key: "preventDefault", 10708 value: function preventDefault() { 10709 this.defaultPrevented = true; 10710 } 10711 /** 10712 * Checks that is default action prevented 10713 * @return {boolean} 10714 */ 10715 10716 }, { 10717 key: "isDefaultPrevented", 10718 value: function isDefaultPrevented() { 10719 return this.defaultPrevented; 10720 } 10721 /** 10722 * Stops event immediate propagation 10723 */ 10724 10725 }, { 10726 key: "stopImmediatePropagation", 10727 value: function stopImmediatePropagation() { 10728 this.immediatePropagationStopped = true; 10729 } 10730 /** 10731 * Checks that is immediate propagation stopped 10732 * @return {boolean} 10733 */ 10734 10735 }, { 10736 key: "isImmediatePropagationStopped", 10737 value: function isImmediatePropagationStopped() { 10738 return this.immediatePropagationStopped; 10739 } 10740 }], [{ 10741 key: "create", 10742 value: function create(options) { 10743 return new this(options); 10744 } 10745 }]); 10746 return BaseEvent; 10747 }(); 10748 10749 var EventStore = 10750 /*#__PURE__*/ 10751 function () { 10752 function EventStore() { 10753 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 10754 babelHelpers.classCallCheck(this, EventStore); 10755 this.defaultMaxListeners = Type.isNumber(options.defaultMaxListeners) ? options.defaultMaxListeners : 10; 10756 this.eventStore = new WeakMap(); 10757 } 10758 10759 babelHelpers.createClass(EventStore, [{ 10760 key: "add", 10761 value: function add(target) { 10762 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 10763 var record = this.getRecordScheme(); 10764 10765 if (Type.isNumber(options.maxListeners)) { 10766 record.maxListeners = options.maxListeners; 10767 } 10768 10769 this.eventStore.set(target, record); 10770 return record; 10771 } 10772 }, { 10773 key: "get", 10774 value: function get(target) { 10775 return this.eventStore.get(target); 10776 } 10777 }, { 10778 key: "getOrAdd", 10779 value: function getOrAdd(target) { 10780 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 10781 return this.get(target) || this.add(target, options); 10782 } 10783 }, { 10784 key: "delete", 10785 value: function _delete(context) { 10786 this.eventStore.delete(context); 10787 } 10788 }, { 10789 key: "getRecordScheme", 10790 value: function getRecordScheme() { 10791 return { 10792 eventsMap: new Map(), 10793 onceMap: new Map(), 10794 maxListeners: this.getDefaultMaxListeners(), 10795 eventsMaxListeners: new Map() 10796 }; 10797 } 10798 }, { 10799 key: "getDefaultMaxListeners", 10800 value: function getDefaultMaxListeners() { 10801 return this.defaultMaxListeners; 10802 } 10803 }]); 10804 return EventStore; 10805 }(); 10806 10807 var WarningStore = 10808 /*#__PURE__*/ 10809 function () {
10810 function WarningStore() { 10811 babelHelpers.classCallCheck(this, WarningStore); 10812 this.warnings = new Map(); 10813 this.printDelayed = Runtime.debounce(this.print.bind(this), 500); 10814 } 10815 10816 babelHelpers.createClass(WarningStore, [{ 10817 key: "add", 10818 value: function add(target, eventName, listeners) { 10819 var contextWarnings = this.warnings.get(target); 10820 10821 if (!contextWarnings) { 10822 contextWarnings = Object.create(null); 10823 this.warnings.set(target, contextWarnings); 10824 } 10825 10826 if (!contextWarnings[eventName]) { 10827 contextWarnings[eventName] = {}; 10828 } 10829 10830 contextWarnings[eventName].size = listeners.size; 10831 10832 if (!Type.isArray(contextWarnings[eventName].errors)) { 10833 contextWarnings[eventName].errors = []; 10834 } 10835 10836 contextWarnings[eventName].errors.push(new Error()); 10837 } 10838 }, { 10839 key: "print", 10840 value: function print() { 10841 var _iteratorNormalCompletion = true; 10842 var _didIteratorError = false; 10843 var _iteratorError = undefined; 10844 10845 try { 10846 for (var _iterator = this.warnings[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { 10847 var _step$value = babelHelpers.slicedToArray(_step.value, 2), 10848 target = _step$value[0], 10849 warnings = _step$value[1]; 10850
10851 for (var eventName in warnings) { 10852 console.groupCollapsed('Possible BX.Event.EventEmitter memory leak detected. ' + warnings[eventName].size + ' "' + eventName + '" listeners added. ' + 'Use emitter.setMaxListeners() to increase limit.'); 10853 console.dir(warnings[eventName].errors); 10854 console.groupEnd(); 10855 } 10856 } 10857 } catch (err) { 10858 _didIteratorError = true; 10859 _iteratorError = err; 10860 } finally { 10861 try { 10862 if (!_iteratorNormalCompletion && _iterator.return != null) { 10863 _iterator.return(); 10864 } 10865 } finally { 10866 if (_didIteratorError) { 10867 throw _iteratorError; 10868 } 10869 } 10870 } 10871 10872 this.clear(); 10873 } 10874 }, { 10875 key: "clear", 10876 value: function clear() { 10877 this.warnings.clear(); 10878 } 10879 }, { 10880 key: "printDelayed", 10881 value: function printDelayed() {} 10882 }]); 10883 return WarningStore; 10884 }(); 10885 10886 var eventStore = new EventStore({ 10887 defaultMaxListeners: 10 10888 }); 10889 var warningStore = new WarningStore(); 10890 var aliasStore = new Map(); 10891 var globalTarget = { 10892 GLOBAL_TARGET: 'GLOBAL_TARGET' // this key only for debugging purposes 10893 10894 }; 10895 eventStore.add(globalTarget, { 10896 maxListeners: 25 10897 }); 10898 var isEmitterProperty = Symbol.for('BX.Event.EventEmitter.isEmitter'); 10899 var namespaceProperty = Symbol('namespaceProperty'); 10900 var targetProperty = Symbol('targetProperty'); 10901 10902 var EventEmitter = 10903 /*#__PURE__*/ 10904 function () { 10905 /** @private */ 10906 function EventEmitter() { 10907 var _this = this; 10908 10909 babelHelpers.classCallCheck(this, EventEmitter); 10910 this[targetProperty] = null; 10911 this[namespaceProperty] = null; 10912 this[isEmitterProperty] = true; 10913 var target = this; 10914 10915 if (Object.getPrototypeOf(this) === EventEmitter.prototype && arguments.length > 0) //new EventEmitter(obj) case 10916 { 10917 if (!Type.isObject(arguments.length <= 0 ? undefined : arguments[0])) { 10918 throw new TypeError("The \"target\" argument must be an object."); 10919 } 10920 10921 target = arguments.length <= 0 ? undefined : arguments[0]; 10922 this.setEventNamespace(arguments.length <= 1 ? undefined : arguments[1]); 10923 } 10924 10925 this[targetProperty] = target; 10926 setTimeout(function () { 10927 if (_this.getEventNamespace() === null) { 10928 console.warn('The instance of BX.Event.EventEmitter is supposed to have an event namespace. ' + 'Use emitter.setEventNamespace() to make events more unique.'); 10929 } 10930 }, 500); 10931 } 10932 /** 10933 * Makes a target observable 10934 * @param {object} target 10935 * @param {string} namespace 10936 */ 10937 10938 10939 babelHelpers.createClass(EventEmitter, [{ 10940 key: "setEventNamespace", 10941 value: function setEventNamespace(namespace) { 10942 if (Type.isStringFilled(namespace)) { 10943 this[namespaceProperty] = namespace; 10944 } 10945 } 10946 }, { 10947 key: "getEventNamespace", 10948 value: function getEventNamespace() { 10949 return this[namespaceProperty]; 10950 } 10951 /** 10952 * Subscribes listener on specified global event 10953 * @param {object} target 10954 * @param {string} eventName 10955 * @param {Function<BaseEvent>} listener 10956 * @param {object} options 10957 */ 10958 10959 }, { 10960 key: "subscribe", 10961 10962 /** 10963 * Subscribes a listener on a specified event 10964 * @param {string} eventName 10965 * @param {Function<BaseEvent>} listener 10966 * @return {this} 10967 */ 10968 value: function subscribe(eventName, listener) { 10969 EventEmitter.subscribe(this, eventName, listener); 10970 return this; 10971 } 10972 /** 10973 * 10974 * @param {object} options 10975 * @param {object} [aliases] 10976 * @param {boolean} [compatMode=false] 10977 */ 10978 10979 }, { 10980 key: "subscribeFromOptions", 10981 value: function subscribeFromOptions(options, aliases, compatMode) { 10982 var _this2 = this; 10983 10984 if (!Type.isPlainObject(options)) { 10985 return; 10986 } 10987 10988 aliases = Type.isPlainObject(aliases) ? EventEmitter.normalizeAliases(aliases) : {}; 10989 Object.keys(options).forEach(function (eventName) { 10990 var listener = options[eventName]; 10991 10992 if (!Type.isFunction(listener)) { 10993 throw new TypeError("The \"listener\" argument must be of type Function. Received type ".concat(babelHelpers.typeof(listener), ".")); 10994 } 10995 10996 eventName = EventEmitter.normalizeEventName(eventName); 10997 10998 if (aliases[eventName]) { 10999 var actualName = aliases[eventName].eventName; 11000 EventEmitter.subscribe(_this2, actualName, listener, { 11001 compatMode: compatMode !== false 11002 }); 11003 } else { 11004 EventEmitter.subscribe(_this2, eventName, listener, { 11005 compatMode: compatMode === true 11006 }); 11007 } 11008 }); 11009 } 11010 /** 11011 * Subscribes a listener that is called at 11012 * most once for a specified event. 11013 * @param {object} target 11014 * @param {string} eventName 11015 * @param {Function<BaseEvent>} listener 11016 */ 11017 11018 }, { 11019 key: "subscribeOnce", 11020 11021 /** 11022 * Subscribes a listener that is called at most once for a specified event. 11023 * @param {string} eventName 11024 * @param {Function<BaseEvent>} listener 11025 * @return {this} 11026 */ 11027 value: function subscribeOnce(eventName, listener) { 11028 EventEmitter.subscribeOnce(this, eventName, listener); 11029 return this; 11030 } 11031 /** 11032 * Unsubscribes an event listener 11033 * @param {object} target 11034 * @param {string} eventName 11035 * @param {Function<BaseEvent>} listener 11036 * @param options 11037 */ 11038 11039 }, { 11040 key: "unsubscribe", 11041 11042 /** 11043 * Unsubscribes an event listener 11044 * @param {string} eventName 11045 * @param {Function<BaseEvent>} listener 11046 * @return {this} 11047 */ 11048 value: function unsubscribe(eventName, listener) { 11049 EventEmitter.unsubscribe(this, eventName, listener); 11050 return this; 11051 } 11052 /** 11053 * Unsubscribes all event listeners 11054 * @param {object} target 11055 * @param {string} eventName 11056 * @param options 11057 */ 11058 11059 }, { 11060 key: "unsubscribeAll", 11061 11062 /** 11063 * Unsubscribes all event listeners 11064 * @param {string} [eventName] 11065 */ 11066 value: function unsubscribeAll(eventName) { 11067 EventEmitter.unsubscribeAll(this, eventName); 11068 } 11069 /** 11070 * 11071 * @param {object} target 11072 * @param {string} eventName 11073 * @param {BaseEvent | any} event 11074 * @param {object} options 11075 * @returns {Array} 11076 */ 11077 11078 }, { 11079 key: "emit", 11080 11081 /** 11082 * Emits specified event with specified event object 11083 * @param {string} eventName 11084 * @param {BaseEvent | any} event 11085 * @return {this} 11086 */ 11087 value: function emit(eventName, event) { 11088 EventEmitter.emit(this, eventName, event); 11089 return this; 11090 } 11091 /** 11092 * Emits global event and returns a promise that is resolved when 11093 * all promise returned from event handlers are resolved, 11094 * or rejected when at least one of the returned promise is rejected. 11095 * Importantly. You can return any value from synchronous handlers, not just promise 11096 * @param {object} target 11097 * @param {string} eventName 11098 * @param {BaseEvent | any} event 11099 * @return {Promise<Array>} 11100 */ 11101 11102 }, { 11103 key: "emitAsync", 11104 11105 /** 11106 * Emits event and returns a promise that is resolved when 11107 * all promise returned from event handlers are resolved, 11108 * or rejected when at least one of the returned promise is rejected. 11109 * Importantly. You can return any value from synchronous handlers, not just promise 11110 * @param {string} eventName 11111 * @param {BaseEvent|any} event 11112 * @return {Promise<Array>} 11113 */ 11114 value: function emitAsync(eventName, event) { 11115 return EventEmitter.emitAsync(this, eventName, event); 11116 } 11117 /** 11118 * @private 11119 * @param {object} target 11120 * @param {string} eventName 11121 * @param {BaseEvent|any} event 11122 * @returns {BaseEvent} 11123 */ 11124 11125 }, { 11126 key: "setMaxListeners", 11127 11128 /** 11129 * Sets max events listeners count 11130 * this.setMaxListeners(10) - sets the default value for all events
11131 * this.setMaxListeners("onClose", 10) sets the value for onClose event 11132 * @return {this} 11133 * @param args 11134 */ 11135 value: function setMaxListeners() { 11136 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 11137 args[_key] = arguments[_key]; 11138 } 11139 11140 EventEmitter.setMaxListeners.apply(EventEmitter, [this].concat(args)); 11141 return this; 11142 } 11143 /** 11144 * Returns max event listeners count 11145 * @param {object} target 11146 * @param {string} [eventName] 11147 * @returns {number} 11148 */ 11149 11150 }, { 11151 key: "getMaxListeners", 11152 11153 /** 11154 * Returns max event listeners count 11155 * @param {string} [eventName] 11156 * @returns {number} 11157 */ 11158 value: function getMaxListeners(eventName) { 11159 return EventEmitter.getMaxListeners(this, eventName); 11160 } 11161 /** 11162 * Adds or subtracts max listeners count 11163 * Event.EventEmitter.addMaxListeners() - adds one max listener for all events of global target 11164 * Event.EventEmitter.addMaxListeners(3) - adds three max listeners for all events of global target 11165 * Event.EventEmitter.addMaxListeners(-1) - subtracts one max listener for all events of global target 11166 * Event.EventEmitter.addMaxListeners('onClose') - adds one max listener for onClose event of global target 11167 * Event.EventEmitter.addMaxListeners('onClose', 2) - adds two max listeners for onClose event of global target 11168 * Event.EventEmitter.addMaxListeners('onClose', -1) - subtracts one max listener for onClose event of global target 11169 * 11170 * Event.EventEmitter.addMaxListeners(obj) - adds one max listener for all events of 'obj' target 11171 * Event.EventEmitter.addMaxListeners(obj, 3) - adds three max listeners for all events of 'obj' target 11172 * Event.EventEmitter.addMaxListeners(obj, -1) - subtracts one max listener for all events of 'obj' target 11173 * Event.EventEmitter.addMaxListeners(obj, 'onClose') - adds one max listener for onClose event of 'obj' target 11174 * Event.EventEmitter.addMaxListeners(obj, 'onClose', 2) - adds two max listeners for onClose event of 'obj' target 11175 * Event.EventEmitter.addMaxListeners(obj, 'onClose', -1) - subtracts one max listener for onClose event of 'obj' target 11176 * @param args 11177 * @returns {number} 11178 */ 11179 11180 }, { 11181 key: "incrementMaxListeners", 11182 11183 /** 11184 * Increases max listeners count 11185 * this.incrementMaxListeners() - adds one max listener for all events 11186 * this.incrementMaxListeners(3) - adds three max listeners for all events 11187 * this.incrementMaxListeners('onClose') - adds one max listener for onClose event 11188 * this.incrementMaxListeners('onClose', 2) - adds two max listeners for onClose event 11189 */ 11190 value: function incrementMaxListeners() { 11191 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 11192 args[_key2] = arguments[_key2]; 11193 } 11194 11195 return EventEmitter.incrementMaxListeners.apply(EventEmitter, [this].concat(args)); 11196 } 11197 /** 11198 * Decreases max listeners count 11199 * 11200 * Event.EventEmitter.decrementMaxListeners() - subtracts one max listener for all events of global target 11201 * Event.EventEmitter.decrementMaxListeners(3) - subtracts three max listeners for all events of global target 11202 * Event.EventEmitter.decrementMaxListeners('onClose') - subtracts one max listener for onClose event of global target 11203 * Event.EventEmitter.decrementMaxListeners('onClose', 2) - subtracts two max listeners for onClose event of global target 11204 * 11205 * Event.EventEmitter.decrementMaxListeners(obj) - subtracts one max listener for all events of 'obj' target 11206 * Event.EventEmitter.decrementMaxListeners(obj, 3) - subtracts three max listeners for all events of 'obj' target 11207 * Event.EventEmitter.decrementMaxListeners(obj, 'onClose') - subtracts one max listener for onClose event of 'obj' target 11208 * Event.EventEmitter.decrementMaxListeners(obj, 'onClose', 2) - subtracts two max listeners for onClose event of 'obj' target 11209 */ 11210 11211 }, { 11212 key: "decrementMaxListeners", 11213 11214 /** 11215 * Increases max listeners count 11216 * this.decrementMaxListeners() - subtracts one max listener for all events 11217 * this.decrementMaxListeners(3) - subtracts three max listeners for all events 11218 * this.decrementMaxListeners('onClose') - subtracts one max listener for onClose event 11219 * this.decrementMaxListeners('onClose', 2) - subtracts two max listeners for onClose event 11220 */ 11221 value: function decrementMaxListeners() { 11222 for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { 11223 args[_key3] = arguments[_key3]; 11224 } 11225 11226 return EventEmitter.decrementMaxListeners.apply(EventEmitter, [this].concat(args)); 11227 } 11228 /** 11229 * @private 11230 * @param {Array} args 11231 * @returns Array 11232 */ 11233 11234 }, { 11235 key: "getListeners", 11236 11237 /** 11238 * Gets listeners list for specified event 11239 * @param {string} eventName 11240 */ 11241 value: function getListeners(eventName) { 11242 return EventEmitter.getListeners(this, eventName); 11243 } 11244 /** 11245 * Returns a full event name with namespace 11246 * @param {string} eventName 11247 * @returns {string} 11248 */ 11249 11250 }, { 11251 key: "getFullEventName", 11252 value: function getFullEventName(eventName) { 11253 if (!Type.isStringFilled(eventName)) { 11254 throw new TypeError("The \"eventName\" argument must be a string."); 11255 } 11256 11257 return EventEmitter.makeFullEventName(this.getEventNamespace(), eventName); 11258 } 11259 /** 11260 * Registers aliases (old event names for BX.onCustomEvent) 11261 * @param aliases 11262 */ 11263 11264 }], [{ 11265 key: "makeObservable", 11266 value: function makeObservable(target, namespace) { 11267 if (!Type.isObject(target)) { 11268 throw new TypeError('The "target" argument must be an object.'); 11269 } 11270 11271 if (!Type.isStringFilled(namespace)) { 11272 throw new TypeError('The "namespace" must be an non-empty string.'); 11273 } 11274 11275 if (EventEmitter.isEventEmitter(target)) { 11276 throw new TypeError('The "target" is an event emitter already.'); 11277 } 11278 11279 var targetProto = Object.getPrototypeOf(target); 11280 var emitter = new EventEmitter(); 11281 emitter.setEventNamespace(namespace); 11282 Object.setPrototypeOf(emitter, targetProto); 11283 Object.setPrototypeOf(target, emitter); 11284 Object.getOwnPropertyNames(EventEmitter.prototype).forEach(function (method) {
11285 if (['constructor'].includes(method)) { 11286 return; 11287 } 11288 11289 emitter[method] = function () { 11290 for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { 11291 args[_key4] = arguments[_key4]; 11292 } 11293 11294 return EventEmitter.prototype[method].apply(target, args); 11295 }; 11296 }); 11297 } 11298 }, { 11299 key: "subscribe", 11300 value: function subscribe(target, eventName, listener, options) { 11301 if (Type.isString(target)) { 11302 options = listener; 11303 listener = eventName; 11304 eventName = target; 11305 target = this.GLOBAL_TARGET; 11306 } 11307 11308 if (!Type.isObject(target)) { 11309 throw new TypeError("The \"target\" argument must be an object."); 11310 } 11311 11312 eventName = this.normalizeEventName(eventName); 11313 11314 if (!Type.isStringFilled(eventName)) { 11315 throw new TypeError("The \"eventName\" argument must be a string."); 11316 } 11317 11318 if (!Type.isFunction(listener)) { 11319 throw new TypeError("The \"listener\" argument must be of type Function. Received type ".concat(babelHelpers.typeof(listener), ".")); 11320 } 11321 11322 options = Type.isPlainObject(options) ? options : {}; 11323 var fullEventName = this.resolveEventName(eventName, target, options.useGlobalNaming === true); 11324 11325 var _eventStore$getOrAdd = eventStore.getOrAdd(target), 11326 eventsMap = _eventStore$getOrAdd.eventsMap, 11327 onceMap = _eventStore$getOrAdd.onceMap; 11328 11329 var onceListeners = onceMap.get(fullEventName); 11330 var listeners = eventsMap.get(fullEventName); 11331 11332 if (listeners && listeners.has(listener) || onceListeners && onceListeners.has(listener)) { 11333 console.error("You cannot subscribe the same \"".concat(fullEventName, "\" event listener twice.")); 11334 } else { 11335 if (listeners) { 11336 listeners.set(listener, { 11337 listener: listener, 11338 options: options, 11339 sort: this.getNextSequenceValue() 11340 }); 11341 } else { 11342 listeners = new Map([[listener, { 11343 listener: listener, 11344 options: options, 11345 sort: this.getNextSequenceValue() 11346 }]]); 11347 eventsMap.set(fullEventName, listeners); 11348 } 11349 } 11350 11351 var maxListeners = this.getMaxListeners(target, eventName); 11352 11353 if (listeners.size > maxListeners) { 11354 warningStore.add(target, fullEventName, listeners); 11355 warningStore.printDelayed(); 11356 } 11357 } 11358 }, { 11359 key: "subscribeOnce", 11360 value: function subscribeOnce(target, eventName, listener) { 11361 var _this3 = this; 11362 11363 if (Type.isString(target)) { 11364 listener = eventName; 11365 eventName = target; 11366 target = this.GLOBAL_TARGET;
11367 } 11368 11369 if (!Type.isObject(target)) { 11370 throw new TypeError("The \"target\" argument must be an object."); 11371 } 11372 11373 eventName = this.normalizeEventName(eventName); 11374 11375 if (!Type.isStringFilled(eventName)) { 11376 throw new TypeError("The \"eventName\" argument must be a string."); 11377 } 11378 11379 if (!Type.isFunction(listener)) { 11380 throw new TypeError("The \"listener\" argument must be of type Function. Received type ".concat(babelHelpers.typeof(listener), ".")); 11381 } 11382 11383 var fullEventName = this.resolveEventName(eventName, target); 11384 11385 var _eventStore$getOrAdd2 = eventStore.getOrAdd(target), 11386 eventsMap = _eventStore$getOrAdd2.eventsMap, 11387 onceMap = _eventStore$getOrAdd2.onceMap; 11388 11389 var listeners = eventsMap.get(fullEventName); 11390 var onceListeners = onceMap.get(fullEventName); 11391 11392 if (listeners && listeners.has(listener) || onceListeners && onceListeners.has(listener)) { 11393 console.error("You cannot subscribe the same \"".concat(fullEventName, "\" event listener twice.")); 11394 } else { 11395 var once = function once() { 11396 _this3.unsubscribe(target, eventName, once); 11397 11398 onceListeners.delete(listener); 11399 listener.apply(void 0, arguments); 11400 }; 11401 11402 if (onceListeners) { 11403 onceListeners.set(listener, once); 11404 } else { 11405 onceListeners = new Map([[listener, once]]); 11406 onceMap.set(fullEventName, onceListeners); 11407 } 11408 11409 this.subscribe(target, eventName, once); 11410 } 11411 } 11412 }, { 11413 key: "unsubscribe", 11414 value: function unsubscribe(target, eventName, listener, options) { 11415 if (Type.isString(target)) { 11416 listener = eventName; 11417 eventName = target; 11418 target = this.GLOBAL_TARGET;
11419 } 11420 11421 eventName = this.normalizeEventName(eventName); 11422 11423 if (!Type.isStringFilled(eventName)) { 11424 throw new TypeError("The \"eventName\" argument must be a string."); 11425 } 11426 11427 if (!Type.isFunction(listener)) { 11428 throw new TypeError("The \"listener\" argument must be of type Function. Received type ".concat(typeof event === "undefined" ? "undefined" : babelHelpers.typeof(event), ".")); 11429 } 11430 11431 options = Type.isPlainObject(options) ? options : {}; 11432 var fullEventName = this.resolveEventName(eventName, target, options.useGlobalNaming === true); 11433 var targetInfo = eventStore.get(target); 11434 var listeners = targetInfo && targetInfo.eventsMap.get(fullEventName); 11435 var onceListeners = targetInfo && targetInfo.onceMap.get(fullEventName); 11436 11437 if (listeners) { 11438 listeners.delete(listener); 11439 } 11440 11441 if (onceListeners) { 11442 var once = onceListeners.get(listener); 11443 11444 if (once) { 11445 onceListeners.delete(listener); 11446 listeners.delete(once); 11447 } 11448 } 11449 } 11450 }, { 11451 key: "unsubscribeAll", 11452 value: function unsubscribeAll(target, eventName, options) { 11453 if (Type.isString(target)) { 11454 eventName = target; 11455 target = this.GLOBAL_TARGET;
11456 } 11457 11458 if (Type.isStringFilled(eventName)) { 11459 var targetInfo = eventStore.get(target); 11460 11461 if (targetInfo) { 11462 options = Type.isPlainObject(options) ? options : {}; 11463 var fullEventName = this.resolveEventName(eventName, target, options.useGlobalNaming === true); 11464 targetInfo.eventsMap.delete(fullEventName); 11465 targetInfo.onceMap.delete(fullEventName); 11466 } 11467 } else if (Type.isNil(eventName)) { 11468 if (target === this.GLOBAL_TARGET) { 11469 console.error('You cannot unsubscribe all global listeners.'); 11470 } else { 11471 eventStore.delete(target); 11472 } 11473 } 11474 } 11475 }, { 11476 key: "emit", 11477 value: function emit(target, eventName, event, options) { 11478 if (Type.isString(target)) { 11479 options = event; 11480 event = eventName; 11481 eventName = target; 11482 target = this.GLOBAL_TARGET; 11483 } 11484 11485 if (!Type.isObject(target)) { 11486 throw new TypeError("The \"target\" argument must be an object."); 11487 } 11488 11489 eventName = this.normalizeEventName(eventName); 11490 11491 if (!Type.isStringFilled(eventName)) { 11492 throw new TypeError("The \"eventName\" argument must be a string."); 11493 } 11494 11495 options = Type.isPlainObject(options) ? options : {}; 11496 var fullEventName = this.resolveEventName(eventName, target, options.useGlobalNaming === true); 11497 var globalEvents = eventStore.get(this.GLOBAL_TARGET); 11498 var globalListeners = globalEvents && globalEvents.eventsMap.get(fullEventName) || new Map(); 11499 var targetListeners = new Set(); 11500 11501 if (target !== this.GLOBAL_TARGET) { 11502 var targetEvents = eventStore.get(target); 11503 targetListeners = targetEvents && targetEvents.eventsMap.get(fullEventName) || new Map(); 11504 } 11505 11506 var listeners = [].concat(babelHelpers.toConsumableArray(globalListeners.values()), babelHelpers.toConsumableArray(targetListeners.values())); 11507 listeners.sort(function (a, b) { 11508 return a.sort - b.sort; 11509 }); 11510 var preparedEvent = this.prepareEvent(target, fullEventName, event); 11511 var result = []; 11512 11513 for (var i = 0; i < listeners.length; i++) { 11514 if (preparedEvent.isImmediatePropagationStopped()) { 11515 break; 11516 } 11517 11518 var _listeners$i = listeners[i], 11519 listener = _listeners$i.listener, 11520 listenerOptions = _listeners$i.options; //A previous listener could remove a current listener. 11521 11522 if (globalListeners.has(listener) || targetListeners.has(listener)) { 11523 var listenerResult = void 0; 11524 11525 if (listenerOptions.compatMode) { 11526 var params = []; 11527 var compatData = preparedEvent.getCompatData(); 11528 11529 if (compatData !== null) { 11530 params = options.cloneData === true ? Runtime.clone(compatData) : compatData; 11531 } else { 11532 params = [preparedEvent]; 11533 } 11534 11535 var context = Type.isUndefined(options.thisArg) ? target : options.thisArg; 11536 listenerResult = listener.apply(context, params); 11537 } else { 11538 listenerResult = Type.isUndefined(options.thisArg) ? listener(preparedEvent) : listener.call(options.thisArg, preparedEvent); 11539 } 11540 11541 result.push(listenerResult); 11542 } 11543 } 11544 11545 return result; 11546 } 11547 }, { 11548 key: "emitAsync", 11549 value: function emitAsync(target, eventName, event) { 11550 if (Type.isString(target)) { 11551 event = eventName; 11552 eventName = target; 11553 target = this.GLOBAL_TARGET;
11554 } 11555 11556 return Promise.all(this.emit(target, eventName, event)); 11557 } 11558 }, { 11559 key: "prepareEvent", 11560 value: function prepareEvent(target, eventName, event) { 11561 var preparedEvent = event; 11562 11563 if (!(event instanceof BaseEvent)) { 11564 preparedEvent = new BaseEvent(); 11565 preparedEvent.setData(event); 11566 } 11567 11568 preparedEvent.setTarget(this.isEventEmitter(target) ? target[targetProperty] : target); 11569 preparedEvent.setType(eventName); 11570 return preparedEvent; 11571 } 11572 /** 11573 * @private 11574 * @returns {number} 11575 */ 11576 11577 }, { 11578 key: "getNextSequenceValue", 11579 value: function getNextSequenceValue() { 11580 return this.sequenceValue++; 11581 } 11582 /** 11583 * Sets max global events listeners count 11584 * Event.EventEmitter.setMaxListeners(10) - sets the default value for all events (global target) 11585 * Event.EventEmitter.setMaxListeners("onClose", 10) - sets the value for onClose event (global target) 11586 * Event.EventEmitter.setMaxListeners(obj, 10) - sets the default value for all events (obj target) 11587 * Event.EventEmitter.setMaxListeners(obj, "onClose", 10); - sets the value for onClose event (obj target) 11588 * @return {void} 11589 * @param args 11590 */ 11591 11592 }, { 11593 key: "setMaxListeners", 11594 value: function setMaxListeners() { 11595 var target = this.GLOBAL_TARGET;
11596 var eventName = null; 11597 var count = undefined; 11598 11599 for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { 11600 args[_key5] = arguments[_key5]; 11601 } 11602 11603 if (args.length === 1) { 11604 count = args[0]; 11605 } else if (args.length === 2) { 11606 if (Type.isString(args[0])) { 11607 eventName = args[0]; 11608 count = args[1]; 11609 } else { 11610 target = args[0]; 11611 count = args[1]; 11612 } 11613 } else if (args.length >= 3) { 11614 target = args[0]; 11615 eventName = args[1]; 11616 count = args[2]; 11617 } 11618 11619 if (!Type.isObject(target)) { 11620 throw new TypeError("The \"target\" argument must be an object."); 11621 } 11622 11623 if (eventName !== null && !Type.isStringFilled(eventName)) { 11624 throw new TypeError("The \"eventName\" argument must be a string."); 11625 } 11626 11627 if (!Type.isNumber(count) || count < 0) { 11628 throw new TypeError("The value of \"count\" is out of range. It must be a non-negative number. Received ".concat(count, ".")); 11629 } 11630 11631 var targetInfo = eventStore.getOrAdd(target); 11632 11633 if (Type.isStringFilled(eventName)) { 11634 var fullEventName = this.resolveEventName(eventName, target); 11635 targetInfo.eventsMaxListeners.set(fullEventName, count); 11636 } else { 11637 targetInfo.maxListeners = count; 11638 } 11639 } 11640 }, { 11641 key: "getMaxListeners", 11642 value: function getMaxListeners(target, eventName) { 11643 if (Type.isString(target)) { 11644 eventName = target; 11645 target = this.GLOBAL_TARGET;
11646 } else if (Type.isNil(target)) { 11647 target = this.GLOBAL_TARGET; 11648 } 11649 11650 if (!Type.isObject(target)) { 11651 throw new TypeError("The \"target\" argument must be an object."); 11652 } 11653 11654 var targetInfo = eventStore.get(target); 11655 11656 if (targetInfo) { 11657 var maxListeners = targetInfo.maxListeners; 11658 11659 if (Type.isStringFilled(eventName)) { 11660 var fullEventName = this.resolveEventName(eventName, target); 11661 maxListeners = targetInfo.eventsMaxListeners.get(fullEventName) || maxListeners; 11662 } 11663 11664 return maxListeners; 11665 } 11666 11667 return this.DEFAULT_MAX_LISTENERS; 11668 } 11669 }, { 11670 key: "addMaxListeners", 11671 value: function addMaxListeners() { 11672 var _this$destructMaxList = this.destructMaxListenersArgs.apply(this, arguments), 11673 _this$destructMaxList2 = babelHelpers.slicedToArray(_this$destructMaxList, 3), 11674 target = _this$destructMaxList2[0], 11675 eventName = _this$destructMaxList2[1], 11676 increment = _this$destructMaxList2[2]; 11677 11678 var maxListeners = Math.max(this.getMaxListeners(target, eventName) + increment, 0); 11679 11680 if (Type.isStringFilled(eventName)) { 11681 EventEmitter.setMaxListeners(target, eventName, maxListeners); 11682 } else { 11683 EventEmitter.setMaxListeners(target, maxListeners); 11684 } 11685 11686 return maxListeners; 11687 } 11688 /** 11689 * Increases max listeners count 11690 * 11691 * Event.EventEmitter.incrementMaxListeners() - adds one max listener for all events of global target 11692 * Event.EventEmitter.incrementMaxListeners(3) - adds three max listeners for all events of global target 11693 * Event.EventEmitter.incrementMaxListeners('onClose') - adds one max listener for onClose event of global target 11694 * Event.EventEmitter.incrementMaxListeners('onClose', 2) - adds two max listeners for onClose event of global target 11695 * 11696 * Event.EventEmitter.incrementMaxListeners(obj) - adds one max listener for all events of 'obj' target 11697 * Event.EventEmitter.incrementMaxListeners(obj, 3) - adds three max listeners for all events of 'obj' target 11698 * Event.EventEmitter.incrementMaxListeners(obj, 'onClose') - adds one max listener for onClose event of 'obj' target 11699 * Event.EventEmitter.incrementMaxListeners(obj, 'onClose', 2) - adds two max listeners for onClose event of 'obj' target 11700 */ 11701 11702 }, { 11703 key: "incrementMaxListeners", 11704 value: function incrementMaxListeners() { 11705 var _this$destructMaxList3 = this.destructMaxListenersArgs.apply(this, arguments), 11706 _this$destructMaxList4 = babelHelpers.slicedToArray(_this$destructMaxList3, 3), 11707 target = _this$destructMaxList4[0], 11708 eventName = _this$destructMaxList4[1], 11709 increment = _this$destructMaxList4[2]; 11710 11711 return this.addMaxListeners(target, eventName, Math.abs(increment)); 11712 } 11713 }, { 11714 key: "decrementMaxListeners", 11715 value: function decrementMaxListeners() { 11716 var _this$destructMaxList5 = this.destructMaxListenersArgs.apply(this, arguments), 11717 _this$destructMaxList6 = babelHelpers.slicedToArray(_this$destructMaxList5, 3), 11718 target = _this$destructMaxList6[0], 11719 eventName = _this$destructMaxList6[1], 11720 increment = _this$destructMaxList6[2]; 11721 11722 return this.addMaxListeners(target, eventName, -Math.abs(increment)); 11723 } 11724 }, { 11725 key: "destructMaxListenersArgs", 11726 value: function destructMaxListenersArgs() { 11727 var eventName = null; 11728 var increment = 1; 11729 var target = this.GLOBAL_TARGET;
11730 11731 for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) { 11732 args[_key6] = arguments[_key6]; 11733 } 11734 11735 if (args.length === 1) { 11736 if (Type.isNumber(args[0])) { 11737 increment = args[0]; 11738 } else if (Type.isString(args[0])) { 11739 eventName = args[0]; 11740 } else { 11741 target = args[0]; 11742 } 11743 } else if (args.length === 2) { 11744 if (Type.isString(args[0])) { 11745 eventName = args[0]; 11746 increment = args[1]; 11747 } else if (Type.isString(args[1])) { 11748 target = args[0]; 11749 eventName = args[1]; 11750 } else { 11751 target = args[0]; 11752 increment = args[1]; 11753 } 11754 } else if (args.length >= 3) { 11755 target = args[0]; 11756 eventName = args[1]; 11757 increment = args[2]; 11758 } 11759 11760 if (!Type.isObject(target)) { 11761 throw new TypeError("The \"target\" argument must be an object."); 11762 } 11763 11764 if (eventName !== null && !Type.isStringFilled(eventName)) { 11765 throw new TypeError("The \"eventName\" argument must be a string."); 11766 } 11767 11768 if (!Type.isNumber(increment)) { 11769 throw new TypeError("The value of \"increment\" must be a number."); 11770 } 11771 11772 return [target, eventName, increment]; 11773 } 11774 /** 11775 * Gets listeners list for a specified event 11776 * @param {object} target 11777 * @param {string} eventName 11778 */ 11779 11780 }, { 11781 key: "getListeners", 11782 value: function getListeners(target, eventName) { 11783 if (Type.isString(target)) { 11784 eventName = target; 11785 target = this.GLOBAL_TARGET;
11786 } 11787 11788 if (!Type.isObject(target)) { 11789 throw new TypeError("The \"target\" argument must be an object."); 11790 } 11791 11792 eventName = this.normalizeEventName(eventName); 11793 11794 if (!Type.isStringFilled(eventName)) { 11795 throw new TypeError("The \"eventName\" argument must be a string."); 11796 } 11797 11798 var targetInfo = eventStore.get(target); 11799 11800 if (!targetInfo) { 11801 return new Map(); 11802 } 11803 11804 var fullEventName = this.resolveEventName(eventName, target); 11805 return targetInfo.eventsMap.get(fullEventName) || new Map(); 11806 } 11807 }, { 11808 key: "registerAliases", 11809 value: function registerAliases(aliases) { 11810 aliases = this.normalizeAliases(aliases); 11811 Object.keys(aliases).forEach(function (alias) { 11812 aliasStore.set(alias, { 11813 eventName: aliases[alias].eventName, 11814 namespace: aliases[alias].namespace 11815 }); 11816 }); 11817 EventEmitter.mergeEventAliases(aliases); 11818 } 11819 /** 11820 * @private 11821 * @param aliases 11822 */ 11823 11824 }, { 11825 key: "normalizeAliases", 11826 value: function normalizeAliases(aliases) { 11827 if (!Type.isPlainObject(aliases)) { 11828 throw new TypeError("The \"aliases\" argument must be an object."); 11829 } 11830 11831 var result = Object.create(null); 11832 11833 for (var _alias in aliases) { 11834 if (!Type.isStringFilled(_alias)) { 11835 throw new TypeError("The alias must be an non-empty string."); 11836 } 11837 11838 var options = aliases[_alias]; 11839 11840 if (!options || !Type.isStringFilled(options.eventName) || !Type.isStringFilled(options.namespace)) { 11841 throw new TypeError("The alias options must set the \"eventName\" and the \"namespace\"."); 11842 } 11843 11844 _alias = this.normalizeEventName(_alias); 11845 result[_alias] = { 11846 eventName: options.eventName, 11847 namespace: options.namespace 11848 }; 11849 } 11850 11851 return result; 11852 } 11853 /** 11854 * @private 11855 */ 11856 11857 }, { 11858 key: "mergeEventAliases", 11859 value: function mergeEventAliases(aliases) { 11860 var _this4 = this; 11861 11862 var globalEvents = eventStore.get(this.GLOBAL_TARGET); 11863 11864 if (!globalEvents) { 11865 return; 11866 } 11867 11868 Object.keys(aliases).forEach(function (alias) { 11869 var options = aliases[alias]; 11870 alias = _this4.normalizeEventName(alias); 11871 11872 var fullEventName = _this4.makeFullEventName(options.namespace, options.eventName); 11873 11874 var aliasListeners = globalEvents.eventsMap.get(alias); 11875 11876 if (aliasListeners) { 11877 var listeners = globalEvents.eventsMap.get(fullEventName) || new Map(); 11878 globalEvents.eventsMap.set(fullEventName, new Map([].concat(babelHelpers.toConsumableArray(listeners), babelHelpers.toConsumableArray(aliasListeners)))); 11879 globalEvents.eventsMap.delete(alias); 11880 } 11881 11882 var aliasOnceListeners = globalEvents.onceMap.get(alias); 11883 11884 if (aliasOnceListeners) { 11885 var onceListeners = globalEvents.onceMap.get(fullEventName) || new Map(); 11886 globalEvents.onceMap.set(fullEventName, new Map([].concat(babelHelpers.toConsumableArray(onceListeners), babelHelpers.toConsumableArray(aliasOnceListeners)))); 11887 globalEvents.onceMap.delete(alias); 11888 } 11889 11890 var aliasMaxListeners = globalEvents.eventsMaxListeners.get(alias); 11891 11892 if (aliasMaxListeners) { 11893 var eventMaxListeners = globalEvents.eventsMaxListeners.get(fullEventName) || 0; 11894 globalEvents.eventsMaxListeners.set(fullEventName, Math.max(eventMaxListeners, aliasMaxListeners)); 11895 globalEvents.eventsMaxListeners.delete(alias); 11896 } 11897 }); 11898 } 11899 /** 11900 * Returns true if the target is an instance of Event.EventEmitter 11901 * @param {object} target 11902 * @returns {boolean} 11903 */ 11904 11905 }, { 11906 key: "isEventEmitter", 11907 value: function isEventEmitter(target) { 11908 return Type.isObject(target) && target[isEmitterProperty] === true; 11909 } 11910 /** 11911 * @private 11912 * @param {string} eventName 11913 * @returns {string} 11914 */ 11915 11916 }, { 11917 key: "normalizeEventName", 11918 value: function normalizeEventName(eventName) { 11919 if (!Type.isStringFilled(eventName)) { 11920 return ''; 11921 } 11922 11923 return eventName.toLowerCase(); 11924 } 11925 /** 11926 * @private 11927 * @param eventName 11928 * @param target 11929 * @param useGlobalNaming 11930 * @returns {string} 11931 */ 11932 11933 }, { 11934 key: "resolveEventName", 11935 value: function resolveEventName(eventName, target) { 11936 var useGlobalNaming = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
11937 eventName = this.normalizeEventName(eventName); 11938 11939 if (!Type.isStringFilled(eventName)) { 11940 return ''; 11941 } 11942 11943 if (this.isEventEmitter(target) && useGlobalNaming !== true) { 11944 if (target.getEventNamespace() !== null && eventName.includes('.')) { 11945 console.warn("Possible the wrong event name \"".concat(eventName, "\".")); 11946 } 11947 11948 eventName = target.getFullEventName(eventName); 11949 } else if (aliasStore.has(eventName)) { 11950 var _aliasStore$get = aliasStore.get(eventName), 11951 namespace = _aliasStore$get.namespace, 11952 actualEventName = _aliasStore$get.eventName; 11953 11954 eventName = this.makeFullEventName(namespace, actualEventName); 11955 } 11956 11957 return eventName; 11958 } 11959 /** 11960 * @private 11961 * @param {string} namespace 11962 * @param {string} eventName 11963 * @returns {string} 11964 */ 11965 11966 }, { 11967 key: "makeFullEventName", 11968 value: function makeFullEventName(namespace, eventName) { 11969 var fullName = Type.isStringFilled(namespace) ? "".concat(namespace, ":").concat(eventName) : eventName; 11970 return Type.isStringFilled(fullName) ? fullName.toLowerCase() : ''; 11971 } 11972 }]); 11973 return EventEmitter; 11974 }(); 11975 11976 babelHelpers.defineProperty(EventEmitter, "GLOBAL_TARGET", globalTarget); 11977 babelHelpers.defineProperty(EventEmitter, "DEFAULT_MAX_LISTENERS", eventStore.getDefaultMaxListeners()); 11978 babelHelpers.defineProperty(EventEmitter, "sequenceValue", 1); 11979 11980 var stack = []; 11981 /** 11982 * For compatibility only 11983 * @type {boolean} 11984 */ 11985 // eslint-disable-next-line 11986 11987 exports.isReady = false; 11988 function ready(handler) { 11989 switch (document.readyState) { 11990 case 'loading': 11991 stack.push(handler); 11992 break; 11993 11994 case 'interactive': 11995 case 'complete': 11996 if (Type.isFunction(handler)) { 11997 handler(); 11998 } 11999 12000 exports.isReady = true; 12001 break; 12002 12003 default: 12004 break; 12005 } 12006 } 12007 document.addEventListener('readystatechange', function () { 12008 if (!exports.isReady) { 12009 stack.forEach(ready); 12010 stack = []; 12011 } 12012 }); 12013 12014 /** 12015 * @memberOf BX 12016 */ 12017 12018 var Event = function Event() { 12019 babelHelpers.classCallCheck(this, Event); 12020 }; 12021 12022 babelHelpers.defineProperty(Event, "bind", bind); 12023 babelHelpers.defineProperty(Event, "bindOnce", bindOnce); 12024 babelHelpers.defineProperty(Event, "unbind", unbind); 12025 babelHelpers.defineProperty(Event, "unbindAll", unbindAll); 12026 babelHelpers.defineProperty(Event, "ready", ready); 12027 babelHelpers.defineProperty(Event, "EventEmitter", EventEmitter); 12028 babelHelpers.defineProperty(Event, "BaseEvent", BaseEvent); 12029 12030 function encodeAttributeValue(value) { 12031 if (Type.isPlainObject(value) || Type.isArray(value)) { 12032 return JSON.stringify(value); 12033 } 12034 12035 return Text.encode(Text.decode(value)); 12036 } 12037 12038 function decodeAttributeValue(value) { 12039 if (Type.isString(value)) { 12040 var decodedValue = Text.decode(value); 12041 var result; 12042 12043 try { 12044 result = JSON.parse(decodedValue); 12045 } catch (e) { 12046 result = decodedValue; 12047 } 12048 12049 if (result === decodedValue) { 12050 if (/^[\d.]+[.]?\d+$/.test(result)) { 12051 return Number(result); 12052 } 12053 } 12054 12055 if (result === 'true' || result === 'false') { 12056 return Boolean(result); 12057 } 12058 12059 return result; 12060 } 12061 12062 return value; 12063 } 12064 12065 function getPageScroll() { 12066 var _document = document, 12067 documentElement = _document.documentElement, 12068 body = _document.body; 12069 var scrollTop = Math.max(window.pageYOffset || 0, documentElement ? documentElement.scrollTop : 0, body ? body.scrollTop : 0); 12070 var scrollLeft = Math.max(window.pageXOffset || 0, documentElement ? documentElement.scrollLeft : 0, body ? body.scrollLeft : 0); 12071 return { 12072 scrollTop: scrollTop, 12073 scrollLeft: scrollLeft 12074 }; 12075 } 12076 12077 /** 12078 * @memberOf BX 12079 */ 12080 12081 var Dom = 12082 /*#__PURE__*/ 12083 function () { 12084 function Dom() { 12085 babelHelpers.classCallCheck(this, Dom); 12086 } 12087 12088 babelHelpers.createClass(Dom, null, [{ 12089 key: "replace", 12090 12091 /** 12092 * Replaces old html element to new html element 12093 * @param oldElement 12094 * @param newElement 12095 */ 12096 value: function replace(oldElement, newElement) { 12097 if (Type.isDomNode(oldElement) && Type.isDomNode(newElement)) { 12098 if (Type.isDomNode(oldElement.parentNode)) { 12099 oldElement.parentNode.replaceChild(newElement, oldElement); 12100 } 12101 } 12102 } 12103 /** 12104 * Removes element 12105 * @param element 12106 */ 12107 12108 }, { 12109 key: "remove", 12110 value: function remove(element) { 12111 if (Type.isDomNode(element) && Type.isDomNode(element.parentNode)) { 12112 element.parentNode.removeChild(element); 12113 } 12114 } 12115 /** 12116 * Cleans element 12117 * @param element 12118 */ 12119 12120 }, { 12121 key: "clean", 12122 value: function clean(element) { 12123 if (Type.isDomNode(element)) { 12124 while (element.childNodes.length > 0) { 12125 element.removeChild(element.firstChild); 12126 } 12127 12128 return; 12129 } 12130 12131 if (Type.isString(element)) { 12132 Dom.clean(document.getElementById(element)); 12133 } 12134 } 12135 /** 12136 * Inserts element before target element 12137 * @param current 12138 * @param target 12139 */ 12140 12141 }, { 12142 key: "insertBefore", 12143 value: function insertBefore(current, target) { 12144 if (Type.isDomNode(current) && Type.isDomNode(target)) { 12145 if (Type.isDomNode(target.parentNode)) { 12146 target.parentNode.insertBefore(current, target); 12147 } 12148 } 12149 } 12150 /** 12151 * Inserts element after target element 12152 * @param current 12153 * @param target 12154 */ 12155 12156 }, { 12157 key: "insertAfter", 12158 value: function insertAfter(current, target) { 12159 if (Type.isDomNode(current) && Type.isDomNode(target)) { 12160 if (Type.isDomNode(target.parentNode)) { 12161 var parent = target.parentNode; 12162 12163 if (Type.isDomNode(target.nextSibling)) { 12164 parent.insertBefore(current, target.nextSibling); 12165 return; 12166 } 12167 12168 parent.appendChild(current); 12169 } 12170 } 12171 } 12172 /** 12173 * Appends element to target element 12174 * @param current 12175 * @param target 12176 */ 12177 12178 }, { 12179 key: "append", 12180 value: function append(current, target) { 12181 if (Type.isDomNode(current) && Type.isDomNode(target)) { 12182 target.appendChild(current); 12183 } 12184 } 12185 /** 12186 * Prepends element to target element 12187 * @param current 12188 * @param target 12189 */ 12190 12191 }, {
12192 key: "prepend", 12193 value: function prepend(current, target) { 12194 if (Type.isDomNode(current) && Type.isDomNode(target)) { 12195 if (Type.isDomNode(target.firstChild)) { 12196 target.insertBefore(current, target.firstChild); 12197 return; 12198 } 12199 12200 Dom.append(current, target); 12201 } 12202 } 12203 /** 12204 * Checks that element contains class name or class names 12205 * @param element 12206 * @param className 12207 * @return {Boolean} 12208 */ 12209 12210 }, { 12211 key: "hasClass", 12212 value: function hasClass(element, className) { 12213 if (Type.isElementNode(element)) { 12214 if (Type.isString(className)) { 12215 var preparedClassName = className.trim(); 12216 12217 if (preparedClassName.length > 0) { 12218 if (preparedClassName.includes(' ')) { 12219 return preparedClassName.split(' ').every(function (name) { 12220 return Dom.hasClass(element, name); 12221 }); 12222 } 12223 12224 if ('classList' in element) { 12225 return element.classList.contains(preparedClassName); 12226 } 12227 12228 if (Type.isObject(element.className) && Type.isString(element.className.baseVal)) { 12229 return element.getAttribute('class').split(' ').some(function (name) { 12230 return name === preparedClassName; 12231 }); 12232 } 12233 } 12234 } 12235 12236 if (Type.isArray(className) && className.length > 0) { 12237 return className.every(function (name) { 12238 return Dom.hasClass(element, name); 12239 }); 12240 } 12241 } 12242 12243 return false; 12244 } 12245 /** 12246 * Adds class name 12247 * @param element 12248 * @param className 12249 */ 12250 12251 }, { 12252 key: "addClass", 12253 value: function addClass(element, className) { 12254 if (Type.isElementNode(element)) { 12255 if (Type.isString(className)) { 12256 var preparedClassName = className.trim(); 12257 12258 if (preparedClassName.length > 0) { 12259 if (preparedClassName.includes(' ')) { 12260 Dom.addClass(element, preparedClassName.split(' ')); 12261 return; 12262 } 12263 12264 if ('classList' in element) { 12265 element.classList.add(preparedClassName); 12266 return; 12267 } 12268 12269 if (Type.isObject(element.className) && Type.isString(element.className.baseVal)) { 12270 if (element.className.baseVal === '') { 12271 element.className.baseVal = preparedClassName; 12272 return; 12273 } 12274 12275 var names = element.className.baseVal.split(' '); 12276 12277 if (!names.includes(preparedClassName)) { 12278 names.push(preparedClassName); 12279 element.className.baseVal = names.join(' ').trim(); 12280 return; 12281 } 12282 } 12283 12284 return; 12285 } 12286 } 12287 12288 if (Type.isArray(className)) { 12289 className.forEach(function (name) { 12290 return Dom.addClass(element, name); 12291 }); 12292 } 12293 } 12294 } 12295 /** 12296 * Removes class name 12297 * @param element 12298 * @param className 12299 */ 12300 12301 }, { 12302 key: "removeClass", 12303 value: function removeClass(element, className) { 12304 if (Type.isElementNode(element)) { 12305 if (Type.isString(className)) { 12306 var preparedClassName = className.trim(); 12307 12308 if (preparedClassName.length > 0) { 12309 if (preparedClassName.includes(' ')) { 12310 Dom.removeClass(element, preparedClassName.split(' ')); 12311 return; 12312 } 12313 12314 if ('classList' in element) { 12315 element.classList.remove(preparedClassName); 12316 return; 12317 } 12318 12319 if (Type.isObject(element.className) && Type.isString(element.className.baseVal)) { 12320 var names = element.className.baseVal.split(' ').filter(function (name) { 12321 return name !== preparedClassName; 12322 }); 12323 element.className.baseVal = names.join(' '); 12324 return; 12325 } 12326 } 12327 } 12328 12329 if (Type.isArray(className)) { 12330 className.forEach(function (name) { 12331 return Dom.removeClass(element, name); 12332 }); 12333 } 12334 } 12335 } 12336 /**
12337 * Toggles class name 12338 * @param element 12339 * @param className 12340 */ 12341 12342 }, { 12343 key: "toggleClass", 12344 value: function toggleClass(element, className) { 12345 if (Type.isElementNode(element)) { 12346 if (Type.isString(className)) { 12347 var preparedClassName = className.trim(); 12348 12349 if (preparedClassName.length > 0) { 12350 if (preparedClassName.includes(' ')) { 12351 Dom.toggleClass(element, preparedClassName.split(' ')); 12352 return; 12353 } 12354 12355 element.classList.toggle(preparedClassName); 12356 return; 12357 } 12358 } 12359 12360 if (Type.isArray(className)) { 12361 className.forEach(function (name) { 12362 return Dom.toggleClass(element, name); 12363 }); 12364 } 12365 } 12366 } 12367 /** 12368 * Styles element 12369 */ 12370 12371 }, { 12372 key: "style", 12373 value: function style(element, prop, value) { 12374 if (Type.isElementNode(element)) { 12375 if (Type.isNull(prop)) { 12376 element.removeAttribute('style'); 12377 return element; 12378 } 12379 12380 if (Type.isPlainObject(prop)) { 12381 Object.entries(prop).forEach(function (item) { 12382 var _item = babelHelpers.slicedToArray(item, 2), 12383 currentKey = _item[0], 12384 currentValue = _item[1]; 12385 12386 Dom.style(element, currentKey, currentValue); 12387 }); 12388 return element; 12389 } 12390 12391 if (Type.isString(prop)) { 12392 if (Type.isUndefined(value) && element.nodeType !== Node.DOCUMENT_NODE) { 12393 var computedStyle = getComputedStyle(element); 12394 12395 if (prop in computedStyle) { 12396 return computedStyle[prop]; 12397 } 12398 12399 return computedStyle.getPropertyValue(prop); 12400 } 12401 12402 if (Type.isNull(value) || value === '' || value === 'null') { 12403 // eslint-disable-next-line 12404 element.style[prop] = ''; 12405 return element; 12406 } 12407 12408 if (Type.isString(value) || Type.isNumber(value)) { 12409 // eslint-disable-next-line 12410 element.style[prop] = value; 12411 return element; 12412 } 12413 } 12414 } 12415 12416 return null; 12417 } 12418 /** 12419 * Adjusts element 12420 * @param target 12421 * @param data 12422 * @return {*} 12423 */ 12424 12425 }, { 12426 key: "adjust", 12427 value: function adjust(target) { 12428 var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 12429 12430 if (!target.nodeType) { 12431 return null; 12432 } 12433 12434 var element = target; 12435 12436 if (target.nodeType === Node.DOCUMENT_NODE) { 12437 element = target.body; 12438 } 12439 12440 if (Type.isPlainObject(data)) { 12441 if (Type.isPlainObject(data.attrs)) { 12442 Object.keys(data.attrs).forEach(function (key) { 12443 if (key === 'class' || key.toLowerCase() === 'classname') { 12444 element.className = data.attrs[key]; 12445 return; 12446 } // eslint-disable-next-line 12447 12448 12449 if (data.attrs[key] == '') { 12450 element.removeAttribute(key); 12451 return; 12452 } 12453 12454 element.setAttribute(key, data.attrs[key]); 12455 }); 12456 } 12457 12458 if (Type.isPlainObject(data.style)) { 12459 Dom.style(element, data.style); 12460 } 12461 12462 if (Type.isPlainObject(data.props)) { 12463 Object.keys(data.props).forEach(function (key) { 12464 element[key] = data.props[key]; 12465 }); 12466 } 12467 12468 if (Type.isPlainObject(data.events)) { 12469 Object.keys(data.events).forEach(function (key) { 12470 Event.bind(element, key, data.events[key]); 12471 }); 12472 } 12473 12474 if (Type.isPlainObject(data.dataset)) { 12475 Object.keys(data.dataset).forEach(function (key) { 12476 element.dataset[key] = data.dataset[key]; 12477 }); 12478 } 12479 12480 if (Type.isString(data.children)) { 12481 data.children = [data.children]; 12482 } 12483 12484 if (Type.isArray(data.children) && data.children.length > 0) {
12485 data.children.forEach(function (item) { 12486 if (Type.isDomNode(item)) { 12487 Dom.append(item, element); 12488 } 12489 12490 if (Type.isString(item)) { 12491 element.innerHTML += item; 12492 } 12493 }); 12494 return element; 12495 } 12496 12497 if ('text' in data && !Type.isNil(data.text)) { 12498 element.innerText = data.text; 12499 return element; 12500 } 12501 12502 if ('html' in data && !Type.isNil(data.html)) { 12503 element.innerHTML = data.html; 12504 } 12505 } 12506 12507 return element; 12508 } 12509 /** 12510 * Creates element 12511 * @param tag 12512 * @param data 12513 * @param context 12514 * @return {HTMLElement|HTMLBodyElement} 12515 */ 12516 12517 }, { 12518 key: "create", 12519 value: function create(tag) { 12520 var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 12521 var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : document; 12522 var tagName = tag; 12523 var options = data; 12524 12525 if (Type.isObjectLike(tag)) { 12526 options = tag; 12527 tagName = tag.tag; 12528 } 12529 12530 return Dom.adjust(context.createElement(tagName), options); 12531 } 12532 /** 12533 * Shows element 12534 * @param element 12535 */ 12536 12537 }, { 12538 key: "show", 12539 value: function show(element) { 12540 if (Type.isDomNode(element)) { 12541 // eslint-disable-next-line 12542 element.hidden = false; 12543 } 12544 } 12545 /** 12546 * Hides element 12547 * @param element 12548 */ 12549 12550 }, { 12551 key: "hide", 12552 value: function hide(element) { 12553 if (Type.isDomNode(element)) { 12554 // eslint-disable-next-line 12555 element.hidden = true; 12556 } 12557 } 12558 /** 12559 * Checks that element is shown 12560 * @param element 12561 * @return {*|boolean} 12562 */ 12563 12564 }, { 12565 key: "isShown", 12566 value: function isShown(element) { 12567 return Type.isDomNode(element) && !element.hidden && element.style.getPropertyValue('display') !== 'none'; 12568 } 12569 /** 12570 * Toggles element visibility 12571 * @param element 12572 */ 12573 12574 }, { 12575 key: "toggle", 12576 value: function toggle(element) { 12577 if (Type.isDomNode(element)) { 12578 if (Dom.isShown(element)) { 12579 Dom.hide(element); 12580 } else { 12581 Dom.show(element); 12582 } 12583 } 12584 } 12585 /** 12586 * Gets element position relative page 12587 * @param {HTMLElement} element 12588 * @return {DOMRect} 12589 */ 12590 12591 }, { 12592 key: "getPosition", 12593 value: function getPosition(element) { 12594 if (Type.isDomNode(element)) { 12595 var elementRect = element.getBoundingClientRect(); 12596 12597 var _getPageScroll = getPageScroll(), 12598 scrollLeft = _getPageScroll.scrollLeft, 12599 scrollTop = _getPageScroll.scrollTop; 12600 12601 return new DOMRect(elementRect.left + scrollLeft, elementRect.top + scrollTop, elementRect.width, elementRect.height); 12602 } 12603 12604 return new DOMRect(); 12605 } 12606 /** 12607 * Gets element position relative specified element position 12608 * @param {HTMLElement} element 12609 * @param {HTMLElement} relationElement 12610 * @return {DOMRect} 12611 */ 12612 12613 }, { 12614 key: "getRelativePosition", 12615 value: function getRelativePosition(element, relationElement) { 12616 if (Type.isDomNode(element) && Type.isDomNode(relationElement)) { 12617 var elementPosition = Dom.getPosition(element); 12618 var relationElementPosition = Dom.getPosition(relationElement); 12619 return new DOMRect(elementPosition.left - relationElementPosition.left, elementPosition.top - relationElementPosition.top, elementPosition.width, elementPosition.height); 12620 } 12621 12622 return new DOMRect(); 12623 } 12624 }, { 12625 key: "attr", 12626 value: function attr(element, _attr, value) { 12627 if (Type.isElementNode(element)) { 12628 if (Type.isString(_attr)) { 12629 if (!Type.isNil(value)) { 12630 return element.setAttribute(_attr, encodeAttributeValue(value)); 12631 } 12632 12633 if (Type.isNull(value)) { 12634 return element.removeAttribute(_attr); 12635 } 12636 12637 return decodeAttributeValue(element.getAttribute(_attr)); 12638 } 12639 12640 if (Type.isPlainObject(_attr)) { 12641 return Object.entries(_attr).forEach(function (_ref) { 12642 var _ref2 = babelHelpers.slicedToArray(_ref, 2), 12643 attrKey = _ref2[0], 12644 attrValue = _ref2[1]; 12645 12646 Dom.attr(element, attrKey, attrValue); 12647 }); 12648 } 12649 } 12650 12651 return null; 12652 } 12653 }]); 12654 return Dom; 12655 }(); 12656 12657 var UA = navigator.userAgent.toLowerCase(); 12658 /** 12659 * @memberOf BX 12660 */ 12661 12662 var Browser = 12663 /*#__PURE__*/ 12664 function () { 12665 function Browser() { 12666 babelHelpers.classCallCheck(this, Browser); 12667 } 12668 12669 babelHelpers.createClass(Browser, null, [{ 12670 key: "isOpera", 12671 value: function isOpera() { 12672 return UA.includes('opera'); 12673 } 12674 }, { 12675 key: "isIE", 12676 value: function isIE() { 12677 return 'attachEvent' in document && !Browser.isOpera(); 12678 } 12679 }, { 12680 key: "isIE6", 12681 value: function isIE6() { 12682 return UA.includes('msie 6'); 12683 } 12684 }, { 12685 key: "isIE7", 12686 value: function isIE7() { 12687 return UA.includes('msie 7'); 12688 } 12689 }, { 12690 key: "isIE8", 12691 value: function isIE8() { 12692 return UA.includes('msie 8'); 12693 } 12694 }, { 12695 key: "isIE9", 12696 value: function isIE9() { 12697 return 'documentMode' in document && document.documentMode >= 9; 12698 } 12699 }, { 12700 key: "isIE10", 12701 value: function isIE10() { 12702 return 'documentMode' in document && document.documentMode >= 10; 12703 } 12704 }, { 12705 key: "isSafari", 12706 value: function isSafari() { 12707 return UA.includes('webkit'); 12708 } 12709 }, { 12710 key: "isFirefox", 12711 value: function isFirefox() { 12712 return UA.includes('firefox'); 12713 } 12714 }, { 12715 key: "isChrome", 12716 value: function isChrome() { 12717 return UA.includes('chrome'); 12718 } 12719 }, { 12720 key: "detectIEVersion", 12721 value: function detectIEVersion() { 12722 if (Browser.isOpera() || Browser.isSafari() || Browser.isFirefox() || Browser.isChrome()) { 12723 return -1; 12724 } 12725 12726 var rv = -1; 12727 12728 if (!!window.MSStream && !window.ActiveXObject && 'ActiveXObject' in window) { 12729 rv = 11; 12730 } else if (Browser.isIE10()) { 12731 rv = 10; 12732 } else if (Browser.isIE9()) { 12733 rv = 9; 12734 } else if (Browser.isIE()) { 12735 rv = 8; 12736 } 12737 12738 if (rv === -1 || rv === 8) { 12739 if (navigator.appName === 'Microsoft Internet Explorer') { 12740 var re = new RegExp('MSIE ([0-9]+[.0-9]*)'); 12741 var res = navigator.userAgent.match(re); 12742 12743 if (Type.isArrayLike(res) && res.length > 0) { 12744 rv = parseFloat(res[1]); 12745 } 12746 } 12747 12748 if (navigator.appName === 'Netscape') { 12749 // Alternative check for IE 11 12750 rv = 11; 12751 12752 var _re = new RegExp('Trident/.*rv:([0-9]+[.0-9]*)'); 12753 12754 if (_re.exec(navigator.userAgent) != null) { 12755 var _res = navigator.userAgent.match(_re); 12756 12757 if (Type.isArrayLike(_res) && _res.length > 0) { 12758 rv = parseFloat(_res[1]); 12759 } 12760 } 12761 } 12762 } 12763 12764 return rv; 12765 } 12766 }, { 12767 key: "isIE11", 12768 value: function isIE11() { 12769 return Browser.detectIEVersion() >= 11; 12770 } 12771 }, { 12772 key: "isMac", 12773 value: function isMac() { 12774 return UA.includes('macintosh'); 12775 } 12776 }, { 12777 key: "isAndroid", 12778 value: function isAndroid() { 12779 return UA.includes('android'); 12780 } 12781 }, { 12782 key: "isIPad", 12783 value: function isIPad() { 12784 return UA.includes('ipad;'); 12785 } 12786 }, { 12787 key: "isIPhone", 12788 value: function isIPhone() { 12789 return UA.includes('iphone;'); 12790 } 12791 }, { 12792 key: "isIOS", 12793 value: function isIOS() { 12794 return Browser.isIPad() || Browser.isIPhone(); 12795 } 12796 }, { 12797 key: "isMobile", 12798 value: function isMobile() { 12799 return Browser.isIPhone() || Browser.isIPad() || Browser.isAndroid() || UA.includes('mobile') || UA.includes('touch'); 12800 } 12801 }, { 12802 key: "isRetina", 12803 value: function isRetina() { 12804 return window.devicePixelRatio && window.devicePixelRatio >= 2; 12805 } 12806 }, { 12807 key: "isDoctype", 12808 value: function isDoctype(target) { 12809 var doc = target || document; 12810 12811 if (doc.compatMode) { 12812 return doc.compatMode === 'CSS1Compat'; 12813 } 12814 12815 return doc.documentElement && doc.documentElement.clientHeight; 12816 } 12817 }, { 12818 key: "isLocalStorageSupported", 12819 value: function isLocalStorageSupported() { 12820 try { 12821 localStorage.setItem('test', 'test'); 12822 localStorage.removeItem('test'); 12823 return true; 12824 } catch (e) { 12825 return false;
12826 } 12827 } 12828 }, { 12829 key: "addGlobalClass", 12830 value: function addGlobalClass() { 12831 var globalClass = 'bx-core'; 12832 12833 if (Dom.hasClass(document.documentElement, globalClass)) { 12834 return; 12835 } 12836 12837 if (Browser.isIOS()) { 12838 globalClass += ' bx-ios'; 12839 } else if (Browser.isMac()) { 12840 globalClass += ' bx-mac'; 12841 } else if (Browser.isAndroid()) { 12842 globalClass += ' bx-android'; 12843 } 12844 12845 globalClass += Browser.isMobile() ? ' bx-touch' : ' bx-no-touch'; 12846 globalClass += Browser.isRetina() ? ' bx-retina' : ' bx-no-retina'; 12847 var ieVersion = -1; 12848 12849 if (/AppleWebKit/.test(navigator.userAgent)) { 12850 globalClass += ' bx-chrome'; 12851 } else if (Browser.detectIEVersion() > 0) { 12852 ieVersion = Browser.detectIEVersion(); 12853 globalClass += " bx-ie bx-ie".concat(ieVersion); 12854 12855 if (ieVersion > 7 && ieVersion < 10 && !Browser.isDoctype()) { 12856 globalClass += ' bx-quirks'; 12857 } 12858 } else if (/Opera/.test(navigator.userAgent)) { 12859 globalClass += ' bx-opera'; 12860 } else if (/Gecko/.test(navigator.userAgent)) { 12861 globalClass += ' bx-firefox'; 12862 } 12863 12864 Dom.addClass(document.documentElement, globalClass); 12865 } 12866 }, { 12867 key: "detectAndroidVersion", 12868 value: function detectAndroidVersion() { 12869 var re = new RegExp('Android ([0-9]+[.0-9]*)'); 12870 12871 if (re.exec(navigator.userAgent) != null) { 12872 var res = navigator.userAgent.match(re); 12873 12874 if (Type.isArrayLike(res) && res.length > 0) { 12875 return parseFloat(res[1]); 12876 } 12877 } 12878 12879 return 0; 12880 } 12881 }, { 12882 key: "isPropertySupported", 12883 value: function isPropertySupported(jsProperty, returnCSSName) { 12884 if (jsProperty === '') { 12885 return false; 12886 } 12887 12888 function getCssName(propertyName) { 12889 return propertyName.replace(/([A-Z])/g, function () { 12890 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 12891 args[_key] = arguments[_key]; 12892 } 12893 12894 return "-".concat(args[1].toLowerCase()); 12895 }); 12896 } 12897 12898 function getJsName(cssName) { 12899 var reg = /(\\-([a-z]))/g; 12900 12901 if (reg.test(cssName)) { 12902 return cssName.replace(reg, function () { 12903 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 12904 args[_key2] = arguments[_key2]; 12905 } 12906 12907 return args[2].toUpperCase(); 12908 }); 12909 } 12910 12911 return cssName; 12912 } 12913 12914 var property = jsProperty.includes('-') ? getJsName(jsProperty) : jsProperty; 12915 var bReturnCSSName = !!returnCSSName; 12916 var ucProperty = property.charAt(0).toUpperCase() + property.slice(1); 12917 var props = ['Webkit', 'Moz', 'O', 'ms'].join("".concat(ucProperty, " ")); 12918 var properties = "".concat(property, " ").concat(props, " ").concat(ucProperty).split(' '); 12919 var obj = document.body || document.documentElement; 12920 12921 for (var i = 0; i < properties.length; i += 1) { 12922 var prop = properties[i]; 12923 12924 if (obj && 'style' in obj && prop in obj.style) { 12925 var lowerProp = prop.substr(0, prop.length - property.length).toLowerCase(); 12926 var prefix = prop === property ? '' : "-".concat(lowerProp, "-"); 12927 return bReturnCSSName ? prefix + getCssName(property) : prop; 12928 } 12929 } 12930 12931 return false; 12932 } 12933 }, { 12934 key: "addGlobalFeatures", 12935 value: function addGlobalFeatures(features) { 12936 if (!Type.isArray(features)) { 12937 return; 12938 } 12939 12940 var classNames = []; 12941 12942 for (var i = 0; i < features.length; i += 1) { 12943 var support = !!Browser.isPropertySupported(features[i]); 12944 classNames.push("bx-".concat(support ? '' : 'no-').concat(features[i].toLowerCase())); 12945 } 12946 12947 Dom.addClass(document.documentElement, classNames.join(' ')); 12948 } 12949 }]); 12950 return Browser; 12951 }(); 12952 12953 var Cookie = 12954 /*#__PURE__*/ 12955 function () { 12956 function Cookie() { 12957 babelHelpers.classCallCheck(this, Cookie); 12958 } 12959 12960 babelHelpers.createClass(Cookie, null, [{ 12961 key: "getList", 12962 12963 /** 12964 * Gets cookies list for current domain 12965 * @return {object} 12966 */ 12967 value: function getList() { 12968 return document.cookie.split(';').map(function (item) { 12969 return item.split('='); 12970 }).map(function (item) { 12971 return item.map(function (subItem) { 12972 return subItem.trim(); 12973 }); 12974 }).reduce(function (acc, item) { 12975 var _item = babelHelpers.slicedToArray(item, 2), 12976 key = _item[0], 12977 value = _item[1]; 12978 12979 acc[decodeURIComponent(key)] = decodeURIComponent(value); 12980 return acc; 12981 }, {}); 12982 } 12983 /** 12984 * Gets cookie value 12985 * @param {string} name 12986 * @return {*} 12987 */ 12988 12989 }, { 12990 key: "get", 12991 value: function get(name) { 12992 var cookiesList = Cookie.getList(); 12993 12994 if (name in cookiesList) { 12995 return cookiesList[name]; 12996 } 12997 12998 return undefined; 12999 } 13000 /** 13001 * Sets cookie 13002 * @param {string} name 13003 * @param {*} value 13004 * @param {object} [options] 13005 */ 13006 13007 }, { 13008 key: "set", 13009 value: function set(name, value) { 13010 var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 13011 var attributes = babelHelpers.objectSpread({ 13012 expires: '' 13013 }, options); 13014 13015 if (Type.isNumber(attributes.expires)) { 13016 var now = +new Date(); 13017 var days = attributes.expires; 13018 var dayInMs = 864e+5; 13019 attributes.expires = new Date(now + days * dayInMs); 13020 } 13021 13022 if (Type.isDate(attributes.expires)) { 13023 attributes.expires = attributes.expires.toUTCString(); 13024 } 13025 13026 var safeName = decodeURIComponent(String(name)).replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape); 13027 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); 13028 var stringifiedAttributes = Object.keys(attributes).reduce(function (acc, key) { 13029 var attributeValue = attributes[key]; 13030 13031 if (!attributeValue) { 13032 return acc; 13033 } 13034 13035 if (attributeValue === true) { 13036 return "".concat(acc, "; ").concat(key); 13037 } 13038 /** 13039 * Considers RFC 6265 section 5.2: 13040 * ... 13041 * 3. If the remaining unparsed-attributes contains a %x3B (';') 13042 * character: 13043 * Consume the characters of the unparsed-attributes up to, 13044 * not including, the first %x3B (';') character. 13045 */ 13046 13047 13048 return "".concat(acc, "; ").concat(key, "=").concat(attributeValue.split(';')[0]); 13049 }, ''); 13050 document.cookie = "".concat(safeName, "=").concat(safeValue).concat(stringifiedAttributes); 13051 } 13052 /** 13053 * Removes cookie 13054 * @param {string} name 13055 * @param {object} [options] 13056 */ 13057 13058 }, { 13059 key: "remove", 13060 value: function remove(name) { 13061 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 13062 Cookie.set(name, '', babelHelpers.objectSpread({}, options, { 13063 expires: -1 13064 })); 13065 } 13066 }]); 13067 return Cookie; 13068 }(); 13069 13070 function objectToFormData(source) { 13071 var formData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new FormData(); 13072 var pre = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; 13073 13074 if (Type.isUndefined(source)) { 13075 return formData; 13076 } 13077 13078 if (Type.isNull(source)) { 13079 formData.append(pre, ''); 13080 } else if (Type.isArray(source)) { 13081 if (!source.length) { 13082 var _key = "".concat(pre, "[]"); 13083 13084 formData.append(_key, ''); 13085 } else { 13086 source.forEach(function (value, index) { 13087 var key = "".concat(pre, "[").concat(index, "]"); 13088 objectToFormData(value, formData, key); 13089 }); 13090 } 13091 } else if (Type.isDate(source)) { 13092 formData.append(pre, source.toISOString()); 13093 } else if (Type.isObject(source) && !Type.isFile(source) && !Type.isBlob(source)) { 13094 Object.keys(source).forEach(function (property) { 13095 var value = source[property]; 13096 var preparedProperty = property; 13097 13098 if (Type.isArray(value)) { 13099 while (property.length > 2 && property.lastIndexOf('[]') === property.length - 2) { 13100 preparedProperty = property.substring(0, property.length - 2); 13101 } 13102 } 13103 13104 var key = pre ? "".concat(pre, "[").concat(preparedProperty, "]") : preparedProperty; 13105 objectToFormData(value, formData, key); 13106 }); 13107 } else { 13108 formData.append(pre, source); 13109 } 13110 13111 return formData; 13112 } 13113 13114 var Data = 13115 /*#__PURE__*/ 13116 function () { 13117 function Data() { 13118 babelHelpers.classCallCheck(this, Data); 13119 } 13120 13121 babelHelpers.createClass(Data, null, [{ 13122 key: "convertObjectToFormData", 13123 13124 /** 13125 * Converts object to FormData 13126 * @param source 13127 * @return {FormData} 13128 */ 13129 value: function convertObjectToFormData(source) { 13130 return objectToFormData(source); 13131 } 13132 }]); 13133 return Data; 13134 }(); 13135 13136 /** 13137 * @memberOf BX 13138 */ 13139 13140 var Http = function Http() { 13141 babelHelpers.classCallCheck(this, Http); 13142 }; 13143 13144 babelHelpers.defineProperty(Http, "Cookie", Cookie); 13145 babelHelpers.defineProperty(Http, "Data", Data); 13146 13147 function message(value) { 13148 if (Type.isString(value)) { 13149 if (Type.isNil(message[value])) { 13150 // eslint-disable-next-line 13151 EventEmitter.emit('onBXMessageNotFound', new BaseEvent({ 13152 compatData: [value] 13153 })); 13154 13155 if (Type.isNil(message[value])) { 13156 Runtime.debug("message undefined: ".concat(value)); 13157 message[value] = ''; 13158 } 13159 } 13160 } 13161 13162 if (Type.isPlainObject(value)) { 13163 Object.keys(value).forEach(function (key) { 13164 message[key] = value[key]; 13165 }); 13166 } 13167 13168 return message[value]; 13169 } 13170 13171 if (!Type.isNil(window.BX) && Type.isFunction(window.BX.message)) { 13172 Object.keys(window.BX.message).forEach(function (key) { 13173 message(babelHelpers.defineProperty({}, key, window.BX.message[key])); 13174 }); 13175 } 13176 13177 /** 13178 * Implements interface for works with language messages 13179 * @memberOf BX 13180 */ 13181 13182 var Loc = 13183 /*#__PURE__*/ 13184 function () { 13185 function Loc() { 13186 babelHelpers.classCallCheck(this, Loc); 13187 } 13188 13189 babelHelpers.createClass(Loc, null, [{ 13190 key: "getMessage", 13191 13192 /** 13193 * Gets message by id 13194 * @param {string} messageId 13195 * @return {?string} 13196 */
13197 value: function getMessage(messageId) { 13198 return message(messageId); 13199 } 13200 /** 13201 * Sets message or messages 13202 * @param {string | Object<string, string>} id 13203 * @param {string} [value] 13204 */ 13205 13206 }, { 13207 key: "setMessage", 13208 value: function setMessage(id, value) { 13209 if (Type.isString(id) && Type.isString(value)) { 13210 message(babelHelpers.defineProperty({}, id, value)); 13211 } 13212 13213 if (Type.isObject(id)) { 13214 message(id); 13215 } 13216 } 13217 }]); 13218 return Loc; 13219 }(); 13220 13221 var handlers = new Map(); 13222 var children = new Map(); 13223 13224 var getUid = function () { 13225 var incremental = 0; 13226 return function () { 13227 incremental += 1; 13228 return incremental; 13229 }; 13230 }(); 13231 13232 function bindAll(element, handlersMap) { 13233 handlersMap.forEach(function (handler, key) { 13234 var currentElement = element.querySelector("[".concat(key, "]")); 13235 13236 if (currentElement) { 13237 currentElement.removeAttribute(key); 13238 var event = key.replace(/-(.*)/, ''); 13239 Event.bind(currentElement, event, handler); 13240 handlers.delete(key); 13241 } 13242 }); 13243 } 13244 13245 function replaceChild(element, childrenMap) { 13246 childrenMap.forEach(function (item, id) { 13247 var currentElement = element.getElementById(id); 13248 13249 if (currentElement) { 13250 Dom.replace(currentElement, item); 13251 children.delete(id); 13252 } 13253 }); 13254 } 13255 13256 function render(sections) { 13257 var eventAttrRe = /[ |\t]on(\w+)="$/; 13258 var uselessSymbolsRe = /[\r\n\t]/g; 13259 13260 for (var _len = arguments.length, substitutions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 13261 substitutions[_key - 1] = arguments[_key]; 13262 } 13263 13264 var html = substitutions.reduce(function (acc, item, index) { 13265 var preparedAcc = acc; // Process event handlers 13266 13267 var matches = acc.match(eventAttrRe); 13268 13269 if (matches && Type.isFunction(item)) { 13270 var eventName = matches[1].replace(/=['|"]/, ''); 13271 var attrName = "".concat(eventName, "-").concat(getUid()); 13272 var attribute = "".concat(attrName, "=\""); 13273 preparedAcc = preparedAcc.replace(eventAttrRe, " ".concat(attribute)); 13274 handlers.set(attrName, item); 13275 preparedAcc += sections[index + 1].replace(uselessSymbolsRe, ' ').replace(/ +/g, ' '); 13276 return preparedAcc; 13277 } // Process element 13278 13279 13280 if (Type.isDomNode(item)) { 13281 var childKey = "tmp___".concat(getUid()); 13282 children.set(childKey, item); 13283 preparedAcc += "<span id=\"".concat(childKey, "\"> </span>"); 13284 preparedAcc += sections[index + 1]; 13285 return preparedAcc; 13286 } // Process array 13287 13288 13289 if (Type.isArray(item)) { 13290 babelHelpers.toConsumableArray(item).forEach(function (currentElement) { 13291 if (Type.isDomNode(currentElement)) { 13292 var _childKey = "tmp___".concat(getUid()); 13293 13294 children.set(_childKey, currentElement); 13295 preparedAcc += "<span id=\"".concat(_childKey, "\"> </span>"); 13296 } 13297 }); 13298 preparedAcc += sections[index + 1]; 13299 return preparedAcc; 13300 } 13301 13302 return preparedAcc + item + sections[index + 1]; 13303 }, sections[0]); 13304 var lowercaseHtml = html.trim().toLowerCase(); 13305 13306 if (lowercaseHtml.startsWith('<!doctype') || lowercaseHtml.startsWith('<html')) { 13307 var doc = document.implementation.createHTMLDocument(''); 13308 doc.documentElement.innerHTML = html; 13309 replaceChild(doc, children); 13310 bindAll(doc, handlers); 13311 handlers.clear(); 13312 return doc; 13313 } 13314 13315 var parser = new DOMParser(); 13316 var parsedDocument = parser.parseFromString(html, 'text/html'); 13317 replaceChild(parsedDocument, children); 13318 bindAll(parsedDocument, handlers); 13319 13320 if (parsedDocument.head.children.length && parsedDocument.body.children.length) { 13321 return parsedDocument; 13322 } 13323 13324 if (parsedDocument.body.children.length === 1) { 13325 var _parsedDocument$body$ = babelHelpers.slicedToArray(parsedDocument.body.children, 1), 13326 el = _parsedDocument$body$[0]; 13327 13328 Dom.remove(el); 13329 return el; 13330 } 13331 13332 if (parsedDocument.body.children.length > 1) { 13333 return babelHelpers.toConsumableArray(parsedDocument.body.children).map(function (item) { 13334 Dom.remove(item); 13335 return item; 13336 }); 13337 } 13338 13339 if (parsedDocument.body.children.length === 0) { 13340 if (parsedDocument.head.children.length === 1) { 13341 var _parsedDocument$head$ = babelHelpers.slicedToArray(parsedDocument.head.children, 1), 13342 _el = _parsedDocument$head$[0]; 13343 13344 Dom.remove(_el); 13345 return _el; 13346 } 13347 13348 if (parsedDocument.head.children.length > 1) { 13349 return babelHelpers.toConsumableArray(parsedDocument.head.children).map(function (item) { 13350 Dom.remove(item); 13351 return item; 13352 }); 13353 } 13354 } 13355 13356 return false;
13357 } 13358 13359 function parseProps(sections) { 13360 for (var _len = arguments.length, substitutions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 13361 substitutions[_key - 1] = arguments[_key]; 13362 } 13363 13364 return substitutions.reduce(function (acc, item, index) { 13365 var nextSectionIndex = index + 1; 13366 13367 if (!Type.isPlainObject(item) && !Type.isArray(item)) { 13368 return acc + item + sections[nextSectionIndex]; 13369 } 13370 13371 return "".concat(acc, "__s").concat(index).concat(sections[nextSectionIndex]); 13372 }, sections[0]).replace(/[\r\t]/gm, '').split(';\n').map(function (item) { 13373 return item.replace(/\n/, ''); 13374 }).reduce(function (acc, item) { 13375 if (item !== '') { 13376 var matches = item.match(/^[\w-. ]+:/); 13377 var splitted = item.split(/^[\w-. ]+:/); 13378 13379 var _key2 = matches[0].replace(':', '').trim(); 13380 13381 var value = splitted[1].trim(); 13382 var substitutionPlaceholderExp = /^__s\d+/; 13383 13384 if (substitutionPlaceholderExp.test(value)) { 13385 acc[_key2] = substitutions[value.replace('__s', '')]; 13386 return acc; 13387 } 13388 13389 acc[_key2] = value; 13390 } 13391 13392 return acc; 13393 }, {}); 13394 } 13395 /** 13396 * @memberOf BX 13397 */ 13398 13399 13400 var Tag = 13401 /*#__PURE__*/ 13402 function () { 13403 function Tag() { 13404 babelHelpers.classCallCheck(this, Tag); 13405 } 13406 13407 babelHelpers.createClass(Tag, null, [{ 13408 key: "safe", 13409 13410 /** 13411 * Encodes all substitutions 13412 * @param sections 13413 * @param substitutions 13414 * @return {string} 13415 */ 13416 value: function safe(sections) { 13417 for (var _len2 = arguments.length, substitutions = new Array(_len2 > 1 ? _len2 - 1 : 0), _key3 = 1; _key3 < _len2; _key3++) { 13418 substitutions[_key3 - 1] = arguments[_key3]; 13419 } 13420 13421 return substitutions.reduce(function (acc, item, index) { 13422 return acc + Text.encode(item) + sections[index + 1]; 13423 }, sections[0]); 13424 } 13425 /** 13426 * Decodes all substitutions 13427 * @param sections 13428 * @param substitutions 13429 * @return {string} 13430 */ 13431 13432 }, { 13433 key: "unsafe", 13434 value: function unsafe(sections) { 13435 for (var _len3 = arguments.length, substitutions = new Array(_len3 > 1 ? _len3 - 1 : 0), _key4 = 1; _key4 < _len3; _key4++) { 13436 substitutions[_key4 - 1] = arguments[_key4]; 13437 } 13438 13439 return substitutions.reduce(function (acc, item, index) { 13440 return acc + Text.decode(item) + sections[index + 1]; 13441 }, sections[0]); 13442 } 13443 /** 13444 * Adds styles to specified element 13445 * @param {HTMLElement} element 13446 * @return {Function} 13447 */ 13448 13449 }, { 13450 key: "style", 13451 value: function style(element) { 13452 if (!Type.isDomNode(element)) { 13453 throw new Error('element is not HTMLElement'); 13454 } 13455 13456 return function styleTagHandler() { 13457 Dom.style(element, parseProps.apply(void 0, arguments)); 13458 }; 13459 } 13460 /** 13461 * Replace all messages identifiers to real messages 13462 * @param sections 13463 * @param substitutions 13464 * @return {string} 13465 */ 13466 13467 }, { 13468 key: "message", 13469 value: function message(sections) { 13470 for (var _len4 = arguments.length, substitutions = new Array(_len4 > 1 ? _len4 - 1 : 0), _key5 = 1; _key5 < _len4; _key5++) { 13471 substitutions[_key5 - 1] = arguments[_key5]; 13472 } 13473 13474 return substitutions.reduce(function (acc, item, index) { 13475 return acc + Loc.getMessage(item) + sections[index + 1]; 13476 }, sections[0]); 13477 } 13478 }, { 13479 key: "attrs", 13480 13481 /** 13482 * Adds attributes to specified element 13483 * @param element 13484 * @return {Function} 13485 */ 13486 value: function attrs(element) { 13487 if (!Type.isDomNode(element)) { 13488 throw new Error('element is not HTMLElement'); 13489 } 13490 13491 return function attrsTagHandler() { 13492 Dom.attr(element, parseProps.apply(void 0, arguments)); 13493 }; 13494 } 13495 }]); 13496 return Tag; 13497 }(); 13498 13499 babelHelpers.defineProperty(Tag, "render", render); 13500 babelHelpers.defineProperty(Tag, "attr", Tag.attrs); 13501 13502 function getParser(format) { 13503 switch (format) { 13504 case 'index': 13505 return function (sourceKey, value, accumulator) { 13506 var result = /\[(\w*)\]$/.exec(sourceKey); 13507 var key = sourceKey.replace(/\[\w*\]$/, ''); 13508 13509 if (Type.isNil(result)) { 13510 accumulator[key] = value; 13511 return; 13512 } 13513 13514 if (Type.isUndefined(accumulator[key])) { 13515 accumulator[key] = {}; 13516 } 13517 13518 accumulator[key][result[1]] = value; 13519 }; 13520 13521 case 'bracket': 13522 return function (sourceKey, value, accumulator) { 13523 var result = /(\[\])$/.exec(sourceKey); 13524 var key = sourceKey.replace(/\[\]$/, ''); 13525 13526 if (Type.isNil(result)) { 13527 accumulator[key] = value; 13528 return; 13529 } 13530 13531 if (Type.isUndefined(accumulator[key])) { 13532 accumulator[key] = [value]; 13533 return; 13534 } 13535 13536 accumulator[key] = [].concat(accumulator[key], value); 13537 }; 13538 13539 default: 13540 return function (sourceKey, value, accumulator) { 13541 var key = sourceKey.replace(/\[\]$/, ''); 13542 accumulator[key] = value; 13543 }; 13544 } 13545 } 13546 13547 function getKeyFormat(key) { 13548 if (/^\w+\[([\w]+)\]$/.test(key)) { 13549 return 'index'; 13550 } 13551 13552 if (/^\w+\[\]$/.test(key)) { 13553 return 'bracket'; 13554 } 13555 13556 return 'default'; 13557 } 13558 13559 function parseQuery(input) { 13560 if (!Type.isString(input)) { 13561 return {}; 13562 } 13563 13564 var url = input.trim().replace(/^[?#&]/, ''); 13565 13566 if (!url) { 13567 return {}; 13568 } 13569 13570 return url.split('&').reduce(function (acc, param) { 13571 var _param$replace$split = param.replace(/\+/g, ' ').split('='), 13572 _param$replace$split2 = babelHelpers.slicedToArray(_param$replace$split, 2), 13573 key = _param$replace$split2[0], 13574 value = _param$replace$split2[1]; 13575 13576 var keyFormat = getKeyFormat(key); 13577 var formatter = getParser(keyFormat); 13578 formatter(key, value, acc); 13579 return acc; 13580 }, {}); 13581 } 13582 13583 var urlExp = /^((\w+):)?(\/\/((\w+)?(:(\w+))?@)?([^\/\?:]+)(:(\d+))?)?(\/?([^\/\?#][^\?#]*)?)?(\?([^#]+))?(#(\w*))?/; 13584 function parseUrl(url) { 13585 var result = url.match(urlExp); 13586 13587 if (Type.isArray(result)) { 13588 var queryParams = parseQuery(result[14]); 13589 return { 13590 useShort: /^\/\//.test(url), 13591 href: result[0] || '', 13592 schema: result[2] || '', 13593 host: result[8] || '', 13594 port: result[10] || '', 13595 path: result[11] || '', 13596 query: result[14] || '', 13597 queryParams: queryParams, 13598 hash: result[16] || '', 13599 username: result[5] || '', 13600 password: result[7] || '', 13601 origin: result[8] || '' 13602 }; 13603 } 13604 13605 return {}; 13606 } 13607 13608 function buildQueryString() { 13609 var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 13610 var queryString = Object.keys(params).reduce(function (acc, key) { 13611 if (Type.isArray(params[key])) {
13612 params[key].forEach(function (paramValue) { 13613 acc.push("".concat(key, "[]=").concat(paramValue)); 13614 }, ''); 13615 } 13616 13617 if (Type.isPlainObject(params[key])) { 13618 Object.keys(params[key]).forEach(function (paramIndex) { 13619 acc.push("".concat(key, "[").concat(paramIndex, "]=").concat(params[key][paramIndex])); 13620 }, ''); 13621 } 13622 13623 if (!Type.isObject(params[key]) && !Type.isArray(params[key])) { 13624 acc.push("".concat(key, "=").concat(params[key])); 13625 } 13626 13627 return acc; 13628 }, []).join('&'); 13629 13630 if (queryString.length > 0) { 13631 return "?".concat(queryString); 13632 } 13633 13634 return queryString; 13635 } 13636 13637 function prepareParamValue(value) { 13638 if (Type.isArray(value)) { 13639 return value.map(function (item) { 13640 return String(item); 13641 }); 13642 } 13643 13644 if (Type.isPlainObject(value)) { 13645 return babelHelpers.objectSpread({}, value); 13646 } 13647 13648 return String(value); 13649 } 13650 13651 var map = new WeakMap(); 13652 /** 13653 * Implements interface for works with URI 13654 * @memberOf BX 13655 */ 13656 13657 var Uri = 13658 /*#__PURE__*/ 13659 function () { 13660 babelHelpers.createClass(Uri, null, [{ 13661 key: "addParam", 13662 value: function addParam(url) { 13663 var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 13664 return new Uri(url).setQueryParams(params).toString(); 13665 } 13666 }, { 13667 key: "removeParam", 13668 value: function removeParam(url, params) { 13669 var _ref; 13670 13671 var removableParams = Type.isArray(params) ? params : [params]; 13672 return (_ref = new Uri(url)).removeQueryParam.apply(_ref, babelHelpers.toConsumableArray(removableParams)).toString(); 13673 } 13674 }]); 13675 13676 function Uri() { 13677 var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; 13678 babelHelpers.classCallCheck(this, Uri); 13679 map.set(this, parseUrl(url)); 13680 } 13681 /** 13682 * Gets schema 13683 * @return {?string} 13684 */ 13685 13686 13687 babelHelpers.createClass(Uri, [{ 13688 key: "getSchema", 13689 value: function getSchema() { 13690 return map.get(this).schema; 13691 } 13692 /** 13693 * Sets schema 13694 * @param {string} schema 13695 * @return {Uri} 13696 */ 13697 13698 }, { 13699 key: "setSchema", 13700 value: function setSchema(schema) { 13701 map.get(this).schema = String(schema); 13702 return this; 13703 } 13704 /** 13705 * Gets host 13706 * @return {?string} 13707 */ 13708 13709 }, { 13710 key: "getHost", 13711 value: function getHost() { 13712 return map.get(this).host; 13713 } 13714 /** 13715 * Sets host 13716 * @param {string} host 13717 * @return {Uri} 13718 */ 13719 13720 }, { 13721 key: "setHost", 13722 value: function setHost(host) { 13723 map.get(this).host = String(host); 13724 return this; 13725 } 13726 /** 13727 * Gets port 13728 * @return {?string} 13729 */ 13730 13731 }, { 13732 key: "getPort", 13733 value: function getPort() { 13734 return map.get(this).port; 13735 } 13736 /** 13737 * Sets port 13738 * @param {String | Number} port 13739 * @return {Uri} 13740 */ 13741 13742 }, { 13743 key: "setPort", 13744 value: function setPort(port) { 13745 map.get(this).port = String(port); 13746 return this; 13747 } 13748 /** 13749 * Gets path 13750 * @return {?string} 13751 */ 13752 13753 }, { 13754 key: "getPath", 13755 value: function getPath() { 13756 return map.get(this).path; 13757 } 13758 /** 13759 * Sets path 13760 * @param {string} path 13761 * @return {Uri} 13762 */ 13763 13764 }, { 13765 key: "setPath", 13766 value: function setPath(path) { 13767 if (!/^\//.test(path)) { 13768 map.get(this).path = "/".concat(String(path)); 13769 return this; 13770 } 13771 13772 map.get(this).path = String(path); 13773 return this; 13774 } 13775 /** 13776 * Gets query 13777 * @return {?string} 13778 */ 13779 13780 }, { 13781 key: "getQuery", 13782 value: function getQuery() { 13783 return buildQueryString(map.get(this).queryParams); 13784 } 13785 /** 13786 * Gets query param value by name 13787 * @param {string} key 13788 * @return {?string} 13789 */ 13790 13791 }, { 13792 key: "getQueryParam", 13793 value: function getQueryParam(key) { 13794 var params = this.getQueryParams(); 13795 13796 if (key in params) { 13797 return params[key]; 13798 } 13799 13800 return null; 13801 } 13802 /** 13803 * Sets query param 13804 * @param {string} key 13805 * @param [value] 13806 * @return {Uri} 13807 */ 13808 13809 }, { 13810 key: "setQueryParam", 13811 value: function setQueryParam(key) { 13812 var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; 13813 map.get(this).queryParams[key] = prepareParamValue(value); 13814 return this; 13815 } 13816 /** 13817 * Gets query params 13818 * @return {Object<string, any>} 13819 */ 13820 13821 }, { 13822 key: "getQueryParams", 13823 value: function getQueryParams() { 13824 return babelHelpers.objectSpread({}, map.get(this).queryParams); 13825 } 13826 /** 13827 * Sets query params 13828 * @param {Object<string, any>} params 13829 * @return {Uri} 13830 */ 13831 13832 }, { 13833 key: "setQueryParams", 13834 value: function setQueryParams() { 13835 var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
13836 var currentParams = this.getQueryParams(); 13837 var newParams = babelHelpers.objectSpread({}, currentParams, params); 13838 Object.keys(newParams).forEach(function (key) { 13839 newParams[key] = prepareParamValue(newParams[key]); 13840 }); 13841 map.get(this).queryParams = newParams; 13842 return this; 13843 } 13844 /** 13845 * Removes query params by name 13846 * @param keys 13847 * @return {Uri} 13848 */ 13849 13850 }, { 13851 key: "removeQueryParam", 13852 value: function removeQueryParam() { 13853 var currentParams = babelHelpers.objectSpread({}, map.get(this).queryParams); 13854 13855 for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) { 13856 keys[_key] = arguments[_key]; 13857 } 13858 13859 keys.forEach(function (key) { 13860 if (key in currentParams) { 13861 delete currentParams[key]; 13862 } 13863 }); 13864 map.get(this).queryParams = currentParams; 13865 return this; 13866 } 13867 /** 13868 * Gets fragment 13869 * @return {?string} 13870 */ 13871 13872 }, { 13873 key: "getFragment", 13874 value: function getFragment() { 13875 return map.get(this).hash; 13876 } 13877 /** 13878 * Sets fragment 13879 * @param {string} hash 13880 * @return {Uri} 13881 */ 13882 13883 }, { 13884 key: "setFragment", 13885 value: function setFragment(hash) { 13886 map.get(this).hash = String(hash); 13887 return this; 13888 } 13889 /** 13890 * Serializes URI 13891 * @return {Object} 13892 */ 13893 13894 }, { 13895 key: "serialize", 13896 value: function serialize() { 13897 var serialized = babelHelpers.objectSpread({}, map.get(this)); 13898 serialized.href = this.toString(); 13899 return serialized; 13900 } 13901 /** 13902 * Gets URI string 13903 * @return {string} 13904 */ 13905 13906 }, { 13907 key: "toString", 13908 value: function toString() { 13909 var data = babelHelpers.objectSpread({}, map.get(this)); 13910 var protocol = data.schema ? "".concat(data.schema, "://") : ''; 13911 13912 if (data.useShort) { 13913 protocol = '//'; 13914 } 13915 13916 var port = function () { 13917 if (Type.isString(data.port) && !['', '80'].includes(data.port)) { 13918 return ":".concat(data.port); 13919 } 13920 13921 return ''; 13922 }(); 13923 13924 var host = this.getHost(); 13925 var path = this.getPath(); 13926 var query = buildQueryString(data.queryParams); 13927 var hash = data.hash ? "#".concat(data.hash) : ''; 13928 return "".concat(host ? protocol : '').concat(host).concat(host ? port : '').concat(path).concat(query).concat(hash); 13929 } 13930 }]); 13931 return Uri; 13932 }(); 13933 13934 /** 13935 * @memberOf BX 13936 */ 13937 var Validation = 13938 /*#__PURE__*/ 13939 function () { 13940 function Validation() { 13941 babelHelpers.classCallCheck(this, Validation); 13942 } 13943 13944 babelHelpers.createClass(Validation, null, [{ 13945 key: "isEmail", 13946 13947 /** 13948 * Checks that value is valid email 13949 * @param value 13950 * @return {boolean} 13951 */ 13952 value: function isEmail(value) { 13953 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])?)*$/; 13954 return exp.test(String(value).toLowerCase()); 13955 } 13956 }]); 13957 return Validation; 13958 }(); 13959 13960 var BaseCache = 13961 /*#__PURE__*/ 13962 function () { 13963 function BaseCache() { 13964 babelHelpers.classCallCheck(this, BaseCache); 13965 babelHelpers.defineProperty(this, "storage", new Map()); 13966 } 13967 13968 babelHelpers.createClass(BaseCache, [{ 13969 key: "get", 13970 13971 /** 13972 * Gets cached value or default value 13973 */ 13974 value: function get(key, defaultValue) { 13975 if (!this.storage.has(key)) { 13976 if (Type.isFunction(defaultValue)) { 13977 return defaultValue(); 13978 } 13979 13980 if (!Type.isUndefined(defaultValue)) { 13981 return defaultValue; 13982 } 13983 } 13984 13985 return this.storage.get(key); 13986 } 13987 /** 13988 * Sets cache entry 13989 */ 13990 13991 }, { 13992 key: "set", 13993 value: function set(key, value) { 13994 this.storage.set(key, value); 13995 } 13996 /** 13997 * Deletes cache entry 13998 */ 13999 14000 }, { 14001 key: "delete", 14002 value: function _delete(key) { 14003 this.storage.delete(key); 14004 } 14005 /** 14006 * Checks that storage contains entry with specified key 14007 */ 14008 14009 }, { 14010 key: "has", 14011 value: function has(key) { 14012 return this.storage.has(key); 14013 } 14014 /** 14015 * Gets cached value if exists, 14016 */ 14017 14018 }, { 14019 key: "remember", 14020 value: function remember(key, defaultValue) { 14021 if (!this.storage.has(key)) { 14022 if (Type.isFunction(defaultValue)) { 14023 this.storage.set(key, defaultValue()); 14024 } else if (!Type.isUndefined(defaultValue)) { 14025 this.storage.set(key, defaultValue); 14026 } 14027 } 14028 14029 return this.storage.get(key); 14030 } 14031 /** 14032 * Gets storage size 14033 */ 14034 14035 }, { 14036 key: "size", 14037 value: function size() { 14038 return this.storage.size; 14039 } 14040 /** 14041 * Gets storage keys 14042 */ 14043 14044 }, { 14045 key: "keys", 14046 value: function keys() { 14047 return babelHelpers.toConsumableArray(this.storage.keys()); 14048 } 14049 /** 14050 * Gets storage values 14051 */ 14052 14053 }, { 14054 key: "values", 14055 value: function values() { 14056 return babelHelpers.toConsumableArray(this.storage.values()); 14057 } 14058 }]); 14059 return BaseCache; 14060 }(); 14061 14062 var MemoryCache = 14063 /*#__PURE__*/ 14064 function (_BaseCache) { 14065 babelHelpers.inherits(MemoryCache, _BaseCache); 14066 14067 function MemoryCache() { 14068 var _babelHelpers$getProt; 14069 14070 var _this; 14071 14072 babelHelpers.classCallCheck(this, MemoryCache); 14073 14074 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 14075 args[_key] = arguments[_key]; 14076 } 14077 14078 _this = babelHelpers.possibleConstructorReturn(this, (_babelHelpers$getProt = babelHelpers.getPrototypeOf(MemoryCache)).call.apply(_babelHelpers$getProt, [this].concat(args))); 14079 babelHelpers.defineProperty(babelHelpers.assertThisInitialized(_this), "storage", new Map()); 14080 return _this; 14081 } 14082 14083 return MemoryCache; 14084 }(BaseCache); 14085 14086 var LsStorage = 14087 /*#__PURE__*/ 14088 function () { 14089 function LsStorage() { 14090 babelHelpers.classCallCheck(this, LsStorage); 14091 babelHelpers.defineProperty(this, "stackKey", 'BX.Cache.Storage.LsStorage.stack'); 14092 babelHelpers.defineProperty(this, "stack", null); 14093 } 14094 14095 babelHelpers.createClass(LsStorage, [{ 14096 key: "getStack", 14097 14098 /** 14099 * @private 14100 */ 14101 value: function getStack() { 14102 if (Type.isPlainObject(this.stack)) { 14103 return this.stack; 14104 } 14105 14106 var stack = localStorage.getItem(this.stackKey); 14107 14108 if (Type.isString(stack) && stack !== '') { 14109 var parsedStack = JSON.parse(stack); 14110 14111 if (Type.isPlainObject(parsedStack)) { 14112 this.stack = parsedStack; 14113 return this.stack; 14114 } 14115 } 14116 14117 this.stack = {}; 14118 return this.stack; 14119 } 14120 /** 14121 * @private 14122 */ 14123 14124 }, { 14125 key: "saveStack", 14126 value: function saveStack() { 14127 if (Type.isPlainObject(this.stack)) { 14128 var preparedStack = JSON.stringify(this.stack); 14129 localStorage.setItem(this.stackKey, preparedStack); 14130 } 14131 } 14132 }, { 14133 key: "get", 14134 value: function get(key) {
14135 var stack = this.getStack(); 14136 return stack[key]; 14137 } 14138 }, { 14139 key: "set", 14140 value: function set(key, value) { 14141 var stack = this.getStack(); 14142 stack[key] = value; 14143 this.saveStack(); 14144 } 14145 }, { 14146 key: "delete", 14147 value: function _delete(key) { 14148 var stack = this.getStack(); 14149 14150 if (key in stack) { 14151 delete stack[key]; 14152 } 14153 } 14154 }, { 14155 key: "has", 14156 value: function has(key) { 14157 var stack = this.getStack(); 14158 return key in stack; 14159 } 14160 }, { 14161 key: "keys", 14162 value: function keys() { 14163 var stack = this.getStack(); 14164 return Object.keys(stack); 14165 } 14166 }, { 14167 key: "values", 14168 value: function values() { 14169 var stack = this.getStack(); 14170 return Object.values(stack); 14171 } 14172 }, { 14173 key: "size", 14174 get: function get() { 14175 var stack = this.getStack(); 14176 return Object.keys(stack).length; 14177 } 14178 }]); 14179 return LsStorage; 14180 }(); 14181 14182 var LocalStorageCache = 14183 /*#__PURE__*/ 14184 function (_BaseCache) { 14185 babelHelpers.inherits(LocalStorageCache, _BaseCache); 14186 14187 function LocalStorageCache() { 14188 var _babelHelpers$getProt; 14189 14190 var _this; 14191 14192 babelHelpers.classCallCheck(this, LocalStorageCache); 14193 14194 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 14195 args[_key] = arguments[_key]; 14196 } 14197 14198 _this = babelHelpers.possibleConstructorReturn(this, (_babelHelpers$getProt = babelHelpers.getPrototypeOf(LocalStorageCache)).call.apply(_babelHelpers$getProt, [this].concat(args))); 14199 babelHelpers.defineProperty(babelHelpers.assertThisInitialized(_this), "storage", new LsStorage()); 14200 return _this; 14201 } 14202 14203 return LocalStorageCache; 14204 }(BaseCache); 14205 14206 /** 14207 * @memberOf BX 14208 */ 14209 14210 var Cache = function Cache() { 14211 babelHelpers.classCallCheck(this, Cache); 14212 }; 14213 14214 babelHelpers.defineProperty(Cache, "MemoryCache", MemoryCache); 14215 babelHelpers.defineProperty(Cache, "LocalStorageCache", LocalStorageCache); 14216 14217 function getElement(element) { 14218 if (Type.isString(element)) { 14219 return document.getElementById(element); 14220 } 14221 14222 return element; 14223 } 14224 14225 function getWindow(element) { 14226 if (Type.isElementNode(element)) { 14227 return element.ownerDocument.parentWindow || element.ownerDocument.defaultView || window; 14228 } 14229 14230 if (Type.isDomNode(element)) { 14231 return element.parentWindow || element.defaultView || window; 14232 } 14233 14234 return window; 14235 } 14236 14237 /* eslint-disable prefer-rest-params */ 14238 14239 var getClass = Reflection.getClass, 14240 namespace = Reflection.namespace; 14241 var message$1 = message; 14242 /** 14243 * @memberOf BX 14244 */ 14245 14246 var replace = Dom.replace, 14247 remove = Dom.remove, 14248 clean = Dom.clean, 14249 insertBefore = Dom.insertBefore, 14250 insertAfter = Dom.insertAfter, 14251 append = Dom.append, 14252 prepend = Dom.prepend, 14253 style = Dom.style, 14254 adjust = Dom.adjust, 14255 create = Dom.create, 14256 isShown = Dom.isShown; 14257 var addClass = function addClass() { 14258 Dom.addClass.apply(Dom, babelHelpers.toConsumableArray(Runtime.merge([], Array.from(arguments), [getElement(arguments[0])]))); 14259 }; 14260 var removeClass = function removeClass() { 14261 Dom.removeClass.apply(Dom, babelHelpers.toConsumableArray(Runtime.merge(Array.from(arguments), [getElement(arguments[0])]))); 14262 }; 14263 var hasClass = function hasClass() { 14264 return Dom.hasClass.apply(Dom, babelHelpers.toConsumableArray(Runtime.merge(Array.from(arguments), [getElement(arguments[0])]))); 14265 }; 14266 var toggleClass = function toggleClass() { 14267 Dom.toggleClass.apply(Dom, babelHelpers.toConsumableArray(Runtime.merge(Array.from(arguments), [getElement(arguments[0])]))); 14268 }; 14269 var cleanNode = function cleanNode(element) { 14270 var removeElement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 14271 var currentElement = getElement(element); 14272 14273 if (Type.isDomNode(currentElement)) { 14274 Dom.clean(currentElement); 14275 14276 if (removeElement) { 14277 Dom.remove(currentElement); 14278 return currentElement; 14279 } 14280 } 14281 14282 return currentElement; 14283 }; 14284 var getCookie = Http.Cookie.get; 14285 var setCookie = function setCookie(name, value) { 14286 var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 14287 var attributes = babelHelpers.objectSpread({}, options); 14288 14289 if (Type.isNumber(attributes.expires)) { 14290 attributes.expires /= 3600 * 24; 14291 } 14292 14293 Http.Cookie.set(name, value, attributes); 14294 }; 14295 var bind$1 = Event.bind, 14296 unbind$1 = Event.unbind, 14297 unbindAll$1 = Event.unbindAll, 14298 bindOnce$1 = Event.bindOnce, 14299 ready$1 = Event.ready; 14300 var debugEnableFlag = debugState, 14301 debugStatus = isDebugEnabled, 14302 debug$1 = debug; 14303 var debugEnable = function debugEnable(value) { 14304 if (value) { 14305 enableDebug(); 14306 } else { 14307 disableDebug(); 14308 } 14309 }; 14310 var clone$1 = Runtime.clone, 14311 loadExt = Runtime.loadExtension, 14312 debounce = Runtime.debounce, 14313 throttle = Runtime.throttle, 14314 html = Runtime.html; // BX.type 14315 var type = babelHelpers.objectSpread({}, Object.getOwnPropertyNames(Type).filter(function (key) { 14316 return !['name', 'length', 'prototype', 'caller', 'arguments'].includes(key); 14317 }).reduce(function (acc, key) { 14318 acc[key] = Type[key]; 14319 return acc; 14320 }, {}), { 14321 isNotEmptyString: function isNotEmptyString(value) { 14322 return Type.isString(value) && value !== ''; 14323 }, 14324 isNotEmptyObject: function isNotEmptyObject(value) { 14325 return Type.isObjectLike(value) && Object.keys(value).length > 0; 14326 }, 14327 isMapKey: Type.isObject, 14328 stringToInt: function stringToInt(value) { 14329 var parsed = parseInt(value); 14330 return !Number.isNaN(parsed) ? parsed : 0; 14331 } 14332 }); // BX.browser 14333 14334 var browser = { 14335 IsOpera: Browser.isOpera, 14336 IsIE: Browser.isIE, 14337 IsIE6: Browser.isIE6, 14338 IsIE7: Browser.isIE7, 14339 IsIE8: Browser.isIE8, 14340 IsIE9: Browser.isIE9, 14341 IsIE10: Browser.isIE10, 14342 IsIE11: Browser.isIE11, 14343 IsSafari: Browser.isSafari, 14344 IsFirefox: Browser.isFirefox, 14345 IsChrome: Browser.isChrome, 14346 DetectIeVersion: Browser.detectIEVersion, 14347 IsMac: Browser.isMac, 14348 IsAndroid: Browser.isAndroid, 14349 isIPad: Browser.isIPad, 14350 isIPhone: Browser.isIPhone, 14351 IsIOS: Browser.isIOS, 14352 IsMobile: Browser.isMobile, 14353 isRetina: Browser.isRetina, 14354 IsDoctype: Browser.isDoctype, 14355 SupportLocalStorage: Browser.isLocalStorageSupported, 14356 addGlobalClass: Browser.addGlobalClass, 14357 DetectAndroidVersion: Browser.detectAndroidVersion, 14358 isPropertySupported: Browser.isPropertySupported, 14359 addGlobalFeatures: Browser.addGlobalFeatures 14360 }; // eslint-disable-next-line 14361 14362 var ajax = window.BX ? window.BX.ajax : function () {}; 14363 function GetWindowScrollSize() { 14364 var doc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; 14365 return { 14366 scrollWidth: doc.documentElement.scrollWidth, 14367 scrollHeight: doc.documentElement.scrollHeight 14368 }; 14369 } 14370 function GetWindowScrollPos() { 14371 var doc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; 14372 var win = getWindow(doc); 14373 return { 14374 scrollLeft: win.pageXOffset, 14375 scrollTop: win.pageYOffset 14376 }; 14377 } 14378 function GetWindowInnerSize() { 14379 var doc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; 14380 var win = getWindow(doc); 14381 return { 14382 innerWidth: win.innerWidth, 14383 innerHeight: win.innerHeight 14384 }; 14385 } 14386 function GetWindowSize() { 14387 var doc = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; 14388 return babelHelpers.objectSpread({}, GetWindowInnerSize(doc), GetWindowScrollPos(doc), GetWindowScrollSize(doc)); 14389 } 14390 function GetContext(node) { 14391 return getWindow(node); 14392 } 14393 function pos(element) { 14394 var relative = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
14395 14396 if (!element) { 14397 return new DOMRect().toJSON(); 14398 } 14399 14400 if (element.ownerDocument === document && !relative) { 14401 var clientRect = element.getBoundingClientRect(); 14402 var root = document.documentElement; 14403 var _document = document, 14404 body = _document.body; 14405 return { 14406 top: Math.round(clientRect.top + (root.scrollTop || body.scrollTop)), 14407 left: Math.round(clientRect.left + (root.scrollLeft || body.scrollLeft)), 14408 width: Math.round(clientRect.right - clientRect.left), 14409 height: Math.round(clientRect.bottom - clientRect.top), 14410 right: Math.round(clientRect.right + (root.scrollLeft || body.scrollLeft)), 14411 bottom: Math.round(clientRect.bottom + (root.scrollTop || body.scrollTop)) 14412 }; 14413 } 14414 14415 var x = 0; 14416 var y = 0; 14417 var w = element.offsetWidth; 14418 var h = element.offsetHeight; 14419 var first = true; // eslint-disable-next-line no-param-reassign 14420 14421 for (; element != null; element = element.offsetParent) { 14422 if (!first && relative && BX.is_relative(element)) { 14423 break; 14424 } 14425 14426 x += element.offsetLeft; 14427 y += element.offsetTop; 14428 14429 if (first) { 14430 first = false; // eslint-disable-next-line no-continue 14431 14432 continue; 14433 } 14434 14435 x += Text.toNumber(Dom.style(element, 'border-left-width')); 14436 y += Text.toNumber(Dom.style(element, 'border-top-width')); 14437 } 14438 14439 return new DOMRect(x, y, w, h).toJSON(); 14440 } 14441 function addCustomEvent(eventObject, eventName, eventHandler) { 14442 if (Type.isString(eventObject)) { 14443 eventHandler = eventName; 14444 eventName = eventObject; 14445 eventObject = EventEmitter.GLOBAL_TARGET;
14446 } 14447 14448 if (eventObject === window) { 14449 eventObject = EventEmitter.GLOBAL_TARGET; 14450 } 14451 14452 if (!Type.isObject(eventObject)) { 14453 console.error('The "eventObject" argument must be an object. Received type ' + babelHelpers.typeof(eventObject) + '.'); 14454 return; 14455 } 14456 14457 if (!Type.isStringFilled(eventName)) { 14458 console.error('The "eventName" argument must be a string.'); 14459 return; 14460 } 14461 14462 if (!Type.isFunction(eventHandler)) { 14463 console.error('The "eventHandler" argument must be a function. Received type ' + babelHelpers.typeof(eventHandler) + '.'); 14464 return; 14465 } 14466 14467 eventName = eventName.toLowerCase(); 14468 EventEmitter.subscribe(eventObject, eventName, eventHandler, { 14469 compatMode: true, 14470 useGlobalNaming: true 14471 }); 14472 } 14473 function onCustomEvent(eventObject, eventName, eventParams, secureParams) { 14474 if (Type.isString(eventObject)) { 14475 secureParams = eventParams; 14476 eventParams = eventName; 14477 eventName = eventObject; 14478 eventObject = EventEmitter.GLOBAL_TARGET; 14479 } 14480 14481 if (!Type.isObject(eventObject) || eventObject === window) { 14482 eventObject = EventEmitter.GLOBAL_TARGET;
14483 } 14484 14485 if (!eventParams) { 14486 eventParams = []; 14487 } 14488 14489 eventName = eventName.toLowerCase(); 14490 var event = new BaseEvent(); 14491 event.setData(eventParams); 14492 event.setCompatData(eventParams); 14493 EventEmitter.emit(eventObject, eventName, event, { 14494 cloneData: secureParams === true, 14495 useGlobalNaming: true 14496 }); 14497 } 14498 function removeCustomEvent(eventObject, eventName, eventHandler) { 14499 if (Type.isString(eventObject)) { 14500 eventHandler = eventName; 14501 eventName = eventObject; 14502 eventObject = EventEmitter.GLOBAL_TARGET; 14503 } 14504 14505 if (!Type.isFunction(eventHandler)) { 14506 console.error('The "eventHandler" argument must be a function. Received type ' + babelHelpers.typeof(eventHandler) + '.'); 14507 return; 14508 } 14509 14510 if (eventObject === window) { 14511 eventObject = EventEmitter.GLOBAL_TARGET; 14512 } 14513 14514 eventName = eventName.toLowerCase(); 14515 EventEmitter.unsubscribe(eventObject, eventName, eventHandler, { 14516 useGlobalNaming: true 14517 }); 14518 } 14519 function removeAllCustomEvents(eventObject, eventName) { 14520 if (Type.isString(eventObject)) { 14521 eventName = eventObject; 14522 eventObject = EventEmitter.GLOBAL_TARGET;
14523 } 14524 14525 if (eventObject === window) { 14526 eventObject = EventEmitter.GLOBAL_TARGET; 14527 } 14528 14529 eventName = eventName.toLowerCase(); 14530 EventEmitter.unsubscribeAll(eventObject, eventName, { 14531 useGlobalNaming: true 14532 }); 14533 } 14534 14535 if (global && global.window && global.window.BX) { 14536 Object.assign(global.window.BX, exports); 14537 } 14538 14539 exports.Type = Type; 14540 exports.Reflection = Reflection; 14541 exports.Text = Text; 14542 exports.Dom = Dom; 14543 exports.Browser = Browser; 14544 exports.Event = Event; 14545 exports.Http = Http; 14546 exports.Runtime = Runtime; 14547 exports.Loc = Loc; 14548 exports.Tag = Tag; 14549 exports.Uri = Uri; 14550 exports.Validation = Validation; 14551 exports.Cache = Cache; 14552 exports.BaseError = BaseError; 14553 exports.getClass = getClass; 14554 exports.namespace = namespace; 14555 exports.message = message$1; 14556 exports.replace = replace; 14557 exports.remove = remove; 14558 exports.clean = clean; 14559 exports.insertBefore = insertBefore; 14560 exports.insertAfter = insertAfter; 14561 exports.append = append; 14562 exports.prepend = prepend; 14563 exports.style = style; 14564 exports.adjust = adjust; 14565 exports.create = create; 14566 exports.isShown = isShown; 14567 exports.addClass = addClass; 14568 exports.removeClass = removeClass; 14569 exports.hasClass = hasClass; 14570 exports.toggleClass = toggleClass; 14571 exports.cleanNode = cleanNode; 14572 exports.getCookie = getCookie; 14573 exports.setCookie = setCookie; 14574 exports.bind = bind$1; 14575 exports.unbind = unbind$1; 14576 exports.unbindAll = unbindAll$1; 14577 exports.bindOnce = bindOnce$1; 14578 exports.ready = ready$1; 14579 exports.debugEnableFlag = debugEnableFlag; 14580 exports.debugStatus = debugStatus; 14581 exports.debug = debug$1; 14582 exports.debugEnable = debugEnable; 14583 exports.clone = clone$1; 14584 exports.loadExt = loadExt; 14585 exports.debounce = debounce; 14586 exports.throttle = throttle; 14587 exports.html = html; 14588 exports.type = type; 14589 exports.browser = browser; 14590 exports.ajax = ajax; 14591 exports.GetWindowScrollSize = GetWindowScrollSize; 14592 exports.GetWindowScrollPos = GetWindowScrollPos; 14593 exports.GetWindowInnerSize = GetWindowInnerSize; 14594 exports.GetWindowSize = GetWindowSize; 14595 exports.GetContext = GetContext; 14596 exports.pos = pos; 14597 exports.addCustomEvent = addCustomEvent; 14598 exports.onCustomEvent = onCustomEvent; 14599 exports.removeCustomEvent = removeCustomEvent; 14600 exports.removeAllCustomEvents = removeAllCustomEvents; 14601 14602}((this.BX = this.BX || {}))); 14603 14604 14605 14606(function(BX) { 14607 /* list of registered proxy functions */ 14608 var proxyList = new WeakMap(); 14609 var deferList = new WeakMap(); 14610 14611 /* List of denied event handlers */ 14612 var deniedEvents = []; 14613 14614 /* list of registered custom events */ 14615 var customEvents = new WeakMap(); 14616 var customEventsCnt = 0; 14617 14618 /* list of external garbage collectors */ 14619 var garbageCollectors = []; 14620 14621 /* list of loaded CSS files */ 14622 var cssList = []; 14623 var cssInit = false; 14624 14625 /* list of loaded JS files */ 14626 var jsList = []; 14627 var jsInit = false; 14628 14629 var eventTypes = { 14630 click: 'MouseEvent', 14631 dblclick: 'MouseEvent', 14632 mousedown: 'MouseEvent', 14633 mousemove: 'MouseEvent', 14634 mouseout: 'MouseEvent', 14635 mouseover: 'MouseEvent', 14636 mouseup: 'MouseEvent', 14637 focus: 'MouseEvent', 14638 blur: 'MouseEvent' 14639 }; 14640 14641 var lastWait = []; 14642 14643 var CHECK_FORM_ELEMENTS = {tagName: /^INPUT|SELECT|TEXTAREA|BUTTON$/i}; 14644 14645 var PRELOADING = 1; 14646 var PRELOADED = 2; 14647 var LOADING = 3; 14648 var LOADED = 4; 14649 var assets = {}; 14650 var isAsync = null; 14651 14652 BX.MSLEFT = 1; 14653 BX.MSMIDDLE = 2; 14654 BX.MSRIGHT = 4; 14655 14656 BX.AM_PM_UPPER = 1; 14657 BX.AM_PM_LOWER = 2; 14658 BX.AM_PM_NONE = false; 14659 14660 BX.ext = function(ob) 14661 { 14662 for (var i in ob) 14663 { 14664 if(ob.hasOwnProperty(i)) 14665 { 14666 this[i] = ob[i]; 14667 } 14668 } 14669 }; 14670 14671 var r = { 14672 script: /<script([^>]*)>/ig, 14673 script_end: /<\/script>/ig, 14674 script_src: /src=["\']([^"\']+)["\']/i, 14675 script_type: /type=["\']([^"\']+)["\']/i, 14676 space: /\s+/, 14677 ltrim: /^[\s\r\n]+/g, 14678 rtrim: /[\s\r\n]+$/g, 14679 style: /<link.*?(rel="stylesheet"|type="text\/css")[^>]*>/i, 14680 style_href: /href=["\']([^"\']+)["\']/i 14681 }; 14682 14683 BX.processHTML = function(data, scriptsRunFirst) 14684 { 14685 var matchScript, matchStyle, matchSrc, matchHref, matchType, scripts = [], styles = []; 14686 var textIndexes = []; 14687 var lastIndex = r.script.lastIndex = r.script_end.lastIndex = 0; 14688 14689 while ((matchScript = r.script.exec(data)) !== null) 14690 { 14691 r.script_end.lastIndex = r.script.lastIndex; 14692 var matchScriptEnd = r.script_end.exec(data); 14693 if (matchScriptEnd === null) 14694 { 14695 break; 14696 } 14697 14698 // skip script tags of special types 14699 var skipTag = false;
14700 if ((matchType = matchScript[1].match(r.script_type)) !== null) 14701 { 14702 if(matchType[1] == 'text/html' || matchType[1] == 'text/template') 14703 skipTag = true; 14704 } 14705 14706 if(skipTag) 14707 { 14708 textIndexes.push([lastIndex, r.script_end.lastIndex - lastIndex]); 14709 } 14710 else 14711 { 14712 textIndexes.push([lastIndex, matchScript.index - lastIndex]); 14713 14714 var bRunFirst = scriptsRunFirst || (matchScript[1].indexOf('bxrunfirst') != '-1'); 14715 14716 if ((matchSrc = matchScript[1].match(r.script_src)) !== null) 14717 { 14718 scripts.push({"bRunFirst": bRunFirst, "isInternal": false, "JS": matchSrc[1]}); 14719 } 14720 else 14721 { 14722 var start = matchScript.index + matchScript[0].length; 14723 var js = data.substr(start, matchScriptEnd.index-start); 14724 14725 scripts.push({"bRunFirst": bRunFirst, "isInternal": true, "JS": js}); 14726 } 14727 } 14728 14729 lastIndex = matchScriptEnd.index + 9; 14730 r.script.lastIndex = lastIndex; 14731 } 14732 14733 textIndexes.push([lastIndex, lastIndex === 0 ? data.length : data.length - lastIndex]); 14734 var pureData = ""; 14735 for (var i = 0, length = textIndexes.length; i < length; i++) 14736 { 14737 if (BX.type.isString(data) && BX.type.isFunction(data.substr)) 14738 { 14739 pureData += data.substr(textIndexes[i][0], textIndexes[i][1]); 14740 } 14741 } 14742 14743 while ((matchStyle = pureData.match(r.style)) !== null) 14744 { 14745 if ((matchHref = matchStyle[0].match(r.style_href)) !== null && matchStyle[0].indexOf('media="') < 0) 14746 { 14747 styles.push(matchHref[1]); 14748 } 14749 14750 pureData = pureData.replace(matchStyle[0], ''); 14751 } 14752 14753 return {'HTML': pureData, 'SCRIPT': scripts, 'STYLE': styles}; 14754 }; 14755 14756 /* OO emulation utility */ 14757 BX.extend = function(child, parent) 14758 { 14759 var f = function() {}; 14760 f.prototype = parent.prototype; 14761 14762 child.prototype = new f(); 14763 child.prototype.constructor = child; 14764 14765 child.superclass = parent.prototype; 14766 child.prototype.superclass = parent.prototype; 14767 if(parent.prototype.constructor == Object.prototype.constructor) 14768 { 14769 parent.prototype.constructor = parent; 14770 } 14771 }; 14772 14773 BX.is_subclass_of = function(ob, parent_class) 14774 { 14775 if (ob instanceof parent_class) 14776 return true; 14777 14778 if (parent_class.superclass) 14779 return BX.is_subclass_of(ob, parent_class.superclass); 14780 14781 return false; 14782 }; 14783 14784 BX.clearNodeCache = function() 14785 { 14786 return false; 14787 }; 14788 14789 BX.bitrix_sessid = function() {return BX.message("bitrix_sessid"); }; 14790 14791 /** 14792 * Creates document fragment with child nodes. 14793 * 14794 * @param {Node[]} nodes 14795 * @return {DocumentFragment} 14796 */ 14797 BX.createFragment = function(nodes) 14798 { 14799 var fragment = document.createDocumentFragment(); 14800 14801 if(!BX.type.isArray(nodes)) 14802 { 14803 return fragment; 14804 } 14805 for(var i = 0; i < nodes.length; i++) 14806 { 14807 fragment.appendChild(nodes[i]); 14808 } 14809 14810 return fragment; 14811 }; 14812 14813 /** 14814 * @deprecated 14815 * @use BX.style 14816 * @param element 14817 * @param opacity 14818 */ 14819 BX.setOpacity = function(element, opacity) 14820 { 14821 var opacityValue = parseFloat(opacity); 14822 14823 if (!isNaN(opacityValue) && BX.type.isDomNode(element)) 14824 { 14825 opacityValue = opacityValue < 1 ? opacityValue : opacityValue / 100; 14826 BX.style(element, 'opacity', opacityValue); 14827 } 14828 }; 14829 14830 /** 14831 * @deprecated 14832 * @param el 14833 * @return {*} 14834 */ 14835 BX.hoverEvents = function(el) 14836 { 14837 if (el) 14838 return BX.adjust(el, {events: BX.hoverEvents()}); 14839 else 14840 return {mouseover: BX.hoverEventsHover, mouseout: BX.hoverEventsHout}; 14841 }; 14842 14843 /** 14844 * @deprecated 14845 */ 14846 BX.hoverEventsHover = function(){BX.addClass(this,'bx-hover');this.BXHOVER=true;}; 14847 /** 14848 * @deprecated 14849 */ 14850 BX.hoverEventsHout = function(){BX.removeClass(this,'bx-hover');this.BXHOVER=false;}; 14851 14852 /** 14853 * @deprecated 14854 */ 14855 BX.focusEvents = function(el) 14856 { 14857 if (el) 14858 return BX.adjust(el, {events: BX.focusEvents()}); 14859 else 14860 return {mouseover: BX.focusEventsFocus, mouseout: BX.focusEventsBlur}; 14861 }; 14862 14863 /** 14864 * @deprecated 14865 */ 14866 BX.focusEventsFocus = function(){BX.addClass(this,'bx-focus');this.BXFOCUS=true;}; 14867 /** 14868 * @deprecated 14869 */ 14870 BX.focusEventsBlur = function(){BX.removeClass(this,'bx-focus');this.BXFOCUS=false;}; 14871 14872 BX.setUnselectable = function(node) 14873 { 14874 BX.style(node, { 14875 'userSelect': 'none', 14876 'MozUserSelect': 'none', 14877 'WebkitUserSelect': 'none', 14878 'KhtmlUserSelect': 'none', 14879 }); 14880 node.setAttribute('unSelectable', 'on'); 14881 }; 14882 14883 BX.setSelectable = function(node) 14884 { 14885 BX.style(node, { 14886 'userSelect': null, 14887 'MozUserSelect': null, 14888 'WebkitUserSelect': null, 14889 'KhtmlUserSelect': null, 14890 }); 14891 node.removeAttribute('unSelectable'); 14892 }; 14893 14894 BX.styleIEPropertyName = function(name) 14895 { 14896 if (name == 'float') 14897 name = BX.browser.IsIE() ? 'styleFloat' : 'cssFloat'; 14898 else 14899 { 14900 var res = BX.browser.isPropertySupported(name); 14901 if (res) 14902 { 14903 name = res; 14904 } 14905 else 14906 {
14907 var reg = /(\-([a-z]){1})/g; 14908 if (reg.test(name)) 14909 { 14910 name = name.replace(reg, function () {return arguments[2].toUpperCase();}); 14911 } 14912 } 14913 } 14914 return name; 14915 }; 14916 14917 BX.focus = function(el) 14918 { 14919 try 14920 { 14921 el.focus(); 14922 return true; 14923 } 14924 catch (e) 14925 { 14926 return false; 14927 } 14928 }; 14929 14930 BX.firstChild = function(el) 14931 { 14932 return BX.type.isDomNode(el) ? el.firstElementChild : null; 14933 }; 14934 14935 BX.lastChild = function(el) 14936 { 14937 return BX.type.isDomNode(el) ? el.lastElementChild : null; 14938 }; 14939 14940 BX.previousSibling = function(el) 14941 { 14942 return BX.type.isDomNode(el) ? el.previousElementSibling : null; 14943 }; 14944 14945 BX.nextSibling = function(el) 14946 { 14947 return BX.type.isDomNode(el) ? el.nextElementSibling : null; 14948 }; 14949 14950 /* 14951 params: { 14952 obj : html node 14953 className : className value 14954 recursive : used only for older browsers to optimize the tree traversal, in new browsers the search is always recursively, default - true 14955 } 14956 14957 Search all nodes with className 14958 */ 14959 /** 14960 * @deprecated 14961 * @use .querySelectorAll 14962 * @param obj 14963 * @param className 14964 * @param recursive 14965 * @return {*} 14966 */ 14967 BX.findChildrenByClassName = function(obj, className, recursive) 14968 { 14969 if(!obj || !obj.childNodes) return null; 14970 14971 var result = []; 14972 if (typeof(obj.getElementsByClassName) == 'undefined') 14973 { 14974 recursive = recursive !== false; 14975 result = BX.findChildren(obj, {className : className}, recursive); 14976 } 14977 else 14978 { 14979 var col = obj.getElementsByClassName(className); 14980 for (i=0,l=col.length;i<l;i++) 14981 { 14982 result[i] = col[i]; 14983 } 14984 } 14985 return result; 14986 }; 14987 14988 /* 14989 params: { 14990 obj : html node 14991 className : className value 14992 recursive : used only for older browsers to optimize the tree traversal, in new browsers the search is always recursively, default - true 14993 } 14994 14995 Search first node with className 14996 */ 14997 /** 14998 * @deprecated 14999 * @use .querySelector 15000 * @param obj 15001 * @param className 15002 * @param recursive 15003 * @return {*} 15004 */ 15005 BX.findChildByClassName = function(obj, className, recursive) 15006 { 15007 if(!obj || !obj.childNodes) return null; 15008 15009 var result = null; 15010 if (typeof(obj.getElementsByClassName) == 'undefined') 15011 { 15012 recursive = recursive !== false; 15013 result = BX.findChild(obj, {className : className}, recursive); 15014 } 15015 else 15016 { 15017 var col = obj.getElementsByClassName(className); 15018 if (col && typeof(col[0]) != 'undefined') 15019 { 15020 result = col[0]; 15021 } 15022 else 15023 { 15024 result = null; 15025 } 15026 } 15027 return result; 15028 }; 15029 15030 /* 15031 params: { 15032 tagName|tag : 'tagName', 15033 className|class : 'className', 15034 attribute : {attribute : value, attribute : value} | attribute | [attribute, attribute....], 15035 property : {prop: value, prop: value} | prop | [prop, prop] 15036 } 15037 15038 all values can be RegExps or strings 15039 */ 15040 /** 15041 * @deprecated 15042 * @use .querySelectorAll 15043 * @param obj 15044 * @param params 15045 * @param recursive 15046 * @return {*|Node} 15047 */ 15048 BX.findChildren = function(obj, params, recursive) 15049 { 15050 return BX.findChild(obj, params, recursive, true); 15051 }; 15052 15053 /** 15054 * @deprecated 15055 * @use .querySelectorAll 15056 * @param obj 15057 * @param params 15058 * @param recursive 15059 * @param get_all 15060 * @return {*} 15061 */ 15062 BX.findChild = function(obj, params, recursive, get_all) 15063 { 15064 if(!obj || !obj.childNodes) return null; 15065 15066 recursive = !!recursive; get_all = !!get_all; 15067 15068 var n = obj.childNodes.length, result = []; 15069 15070 for (var j=0; j<n; j++) 15071 { 15072 var child = obj.childNodes[j]; 15073 15074 if (_checkNode(child, params)) 15075 { 15076 if (get_all) 15077 result.push(child); 15078 else 15079 return child; 15080 } 15081 15082 if(recursive == true) 15083 { 15084 var res = BX.findChild(child, params, recursive, get_all); 15085 if (res) 15086 { 15087 if (get_all) 15088 result = BX.util.array_merge(result, res); 15089 else 15090 return res; 15091 } 15092 } 15093 } 15094 15095 if (get_all || result.length > 0) 15096 return result; 15097 else 15098 return null; 15099 }; 15100 15101 /** 15102 * @deprecated 15103 * @use .closest() 15104 * @param obj 15105 * @param params 15106 * @param maxParent 15107 * @return {*} 15108 */ 15109 BX.findParent = function(obj, params, maxParent) 15110 { 15111 if(!obj) 15112 return null; 15113 15114 var o = obj; 15115 while(o.parentNode) 15116 { 15117 var parent = o.parentNode; 15118 15119 if (_checkNode(parent, params)) 15120 return parent; 15121 15122 o = parent; 15123 15124 if (!!maxParent &&
15125 (BX.type.isFunction(maxParent) 15126 || typeof maxParent == 'object')) 15127 { 15128 if (BX.type.isElementNode(maxParent)) 15129 { 15130 if (o == maxParent) 15131 break; 15132 } 15133 else 15134 { 15135 if (_checkNode(o, maxParent)) 15136 break; 15137 } 15138 } 15139 } 15140 return null; 15141 }; 15142 15143 /** 15144 * @deprecated 15145 * @use .querySelector 15146 * @param obj 15147 * @param params 15148 * @return {*} 15149 */ 15150 BX.findNextSibling = function(obj, params) 15151 { 15152 if(!obj) 15153 return null; 15154 var o = obj; 15155 while(o.nextSibling) 15156 { 15157 var sibling = o.nextSibling; 15158 if (_checkNode(sibling, params)) 15159 return sibling; 15160 o = sibling; 15161 } 15162 return null; 15163 }; 15164 15165 /** 15166 * @deprecated 15167 * @use .querySelector 15168 * @param obj 15169 * @param params 15170 * @return {*} 15171 */ 15172 BX.findPreviousSibling = function(obj, params) 15173 { 15174 if(!obj) 15175 return null; 15176 15177 var o = obj; 15178 while(o.previousSibling) 15179 { 15180 var sibling = o.previousSibling; 15181 if(_checkNode(sibling, params)) 15182 return sibling; 15183 o = sibling; 15184 } 15185 return null; 15186 }; 15187 15188 BX.checkNode = function(obj, params) 15189 { 15190 return _checkNode(obj, params); 15191 }; 15192 15193 /** 15194 * @deprecated 15195 * @use .querySelectorAll 15196 * @param form 15197 * @return {Array} 15198 */ 15199 BX.findFormElements = function(form) 15200 { 15201 if (BX.type.isString(form)) 15202 form = document.forms[form]||BX(form); 15203 15204 var res = []; 15205 15206 if (BX.type.isElementNode(form)) 15207 { 15208 if (form.tagName.toUpperCase() == 'FORM') 15209 { 15210 res = form.elements; 15211 } 15212 else 15213 { 15214 res = BX.findChildren(form, CHECK_FORM_ELEMENTS, true); 15215 } 15216 } 15217 15218 return res; 15219 }; 15220 15221 /** 15222 * @deprecated 15223 * @use .contains() 15224 * @param whichNode 15225 * @param forNode 15226 * @return {boolean} 15227 */ 15228 BX.isParentForNode = function(whichNode, forNode) 15229 { 15230 if (BX.type.isDomNode(whichNode) && BX.type.isDomNode(forNode)) 15231 { 15232 return whichNode.contains(forNode); 15233 } 15234 15235 return false; 15236 }; 15237 15238 BX.getCaretPosition = function(node) 15239 { 15240 var pos = 0; 15241 15242 if(node.selectionStart || node.selectionStart == 0) 15243 { 15244 pos = node.selectionStart; 15245 } 15246 else if(document.selection) 15247 { 15248 node.focus(); 15249 var selection = document.selection.createRange(); 15250 selection.moveStart('character', -node.value.length); 15251 pos = selection.text.length; 15252 } 15253 15254 return (pos); 15255 }; 15256 15257 BX.setCaretPosition = function(node, pos) 15258 { 15259 if(!BX.isNodeInDom(node) || BX.isNodeHidden(node) || node.disabled) 15260 { 15261 return; 15262 } 15263 15264 if(node.setSelectionRange) 15265 { 15266 node.focus(); 15267 node.setSelectionRange(pos, pos); 15268 } 15269 else if(node.createTextRange) 15270 { 15271 var range = node.createTextRange(); 15272 range.collapse(true); 15273 range.moveEnd('character', pos); 15274 range.moveStart('character', pos); 15275 range.select(); 15276 } 15277 }; 15278 15279 // access private. use BX.mergeEx instead. 15280 // todo: refactor BX.merge, make it work through BX.mergeEx 15281 BX.merge = function(){ 15282 var arg = Array.prototype.slice.call(arguments); 15283 15284 if(arg.length < 2) 15285 return {}; 15286 15287 var result = arg.shift(); 15288 15289 for(var i = 0; i < arg.length; i++) 15290 { 15291 for(var k in arg[i]){ 15292 15293 if(typeof arg[i] == 'undefined' || arg[i] == null) 15294 continue; 15295 15296 if(arg[i].hasOwnProperty(k)){ 15297 15298 if(typeof arg[i][k] == 'undefined' || arg[i][k] == null) 15299 continue; 15300 15301 if(typeof arg[i][k] == 'object' && !BX.type.isDomNode(arg[i][k]) && (typeof arg[i][k]['isUIWidget'] == 'undefined')){ 15302 15303 // go deeper 15304 15305 var isArray = 'length' in arg[i][k]; 15306 15307 if(typeof result[k] != 'object') 15308 result[k] = isArray ? [] : {}; 15309 15310 if(isArray) 15311 BX.util.array_merge(result[k], arg[i][k]); 15312 else 15313 BX.merge(result[k], arg[i][k]); 15314 15315 }else 15316 result[k] = arg[i][k]; 15317 } 15318 } 15319 } 15320 15321 return result; 15322 }; 15323 15324 BX.mergeEx = function() 15325 { 15326 var arg = Array.prototype.slice.call(arguments); 15327 if(arg.length < 2) 15328 { 15329 return {}; 15330 } 15331 15332 var result = arg.shift(); 15333 for (var i = 0; i < arg.length; i++) 15334 { 15335 for (var k in arg[i]) 15336 { 15337 if (typeof arg[i] == "undefined" || arg[i] == null || !arg[i].hasOwnProperty(k)) 15338 { 15339 continue; 15340 } 15341 15342 if (BX.type.isPlainObject(arg[i][k]) && BX.type.isPlainObject(result[k])) 15343 { 15344 BX.mergeEx(result[k], arg[i][k]); 15345 } 15346 else 15347 { 15348 result[k] = BX.type.isPlainObject(arg[i][k]) ? BX.clone(arg[i][k]) : arg[i][k]; 15349 } 15350 } 15351 } 15352 15353 return result; 15354 }; 15355 15356 BX.getEventButton = function(e) 15357 { 15358 e = e || window.event; 15359 15360 var flags = 0; 15361 15362 if (typeof e.which != 'undefined') 15363 { 15364 switch (e.which) 15365 { 15366 case 1: flags = flags|BX.MSLEFT; break; 15367 case 2: flags = flags|BX.MSMIDDLE; break; 15368 case 3: flags = flags|BX.MSRIGHT; break; 15369 } 15370 } 15371 else if (typeof e.button != 'undefined') 15372 { 15373 flags = event.button; 15374 } 15375 15376 return flags || BX.MSLEFT; 15377 }; 15378 15379 var captured_events = null, _bind = null; 15380 BX.CaptureEvents = function(el_c, evname_c) 15381 { 15382 if (_bind) 15383 return; 15384 15385 _bind = BX.bind; 15386 captured_events = []; 15387 15388 BX.bind = function(el, evname, func) 15389 { 15390 if (el === el_c && evname === evname_c) 15391 captured_events.push(func); 15392 15393 _bind.apply(this, arguments); 15394 } 15395 }; 15396 15397 BX.CaptureEventsGet = function() 15398 { 15399 if (_bind) 15400 { 15401 BX.bind = _bind; 15402 15403 var captured = captured_events; 15404 15405 _bind = null; 15406 captured_events = null; 15407 return captured; 15408 } 15409 return null; 15410 }; 15411 15412 // Don't even try to use it for submit event! 15413 BX.fireEvent = function(ob,ev) 15414 { 15415 var result = false, e = null; 15416 if (BX.type.isDomNode(ob)) 15417 { 15418 result = true; 15419 if (document.createEventObject) 15420 { 15421 // IE 15422 if (eventTypes[ev] != 'MouseEvent') 15423 { 15424 e = document.createEventObject(); 15425 e.type = ev; 15426 result = ob.fireEvent('on' + ev, e); 15427 } 15428 15429 if (ob[ev]) 15430 { 15431 ob[ev](); 15432 } 15433 } 15434 else 15435 {
15436 // non-IE 15437 e = null; 15438 15439 switch (eventTypes[ev]) 15440 { 15441 case 'MouseEvent': 15442 e = document.createEvent('MouseEvent'); 15443 try 15444 { 15445 e.initMouseEvent(ev, true, true, top, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, null); 15446 } 15447 catch (initException) 15448 { 15449 e.initMouseEvent(ev, true, true, window, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, null); 15450 } 15451 15452 break; 15453 default: 15454 e = document.createEvent('Event'); 15455 e.initEvent(ev, true, true); 15456 } 15457 15458 result = ob.dispatchEvent(e); 15459 } 15460 } 15461 15462 return result; 15463 }; 15464 15465 BX.getWheelData = function(e) 15466 { 15467 e = e || window.event; 15468 e.wheelData = e.detail ? e.detail * -1 : e.wheelDelta / 40; 15469 return e.wheelData; 15470 }; 15471 15472 BX.proxy_context = null; 15473 15474 BX.delegate = function (func, thisObject) 15475 { 15476 if (!func || !thisObject) 15477 return func; 15478 15479 return function() { 15480 var cur = BX.proxy_context; 15481 BX.proxy_context = this; 15482 var res = func.apply(thisObject, arguments); 15483 BX.proxy_context = cur; 15484 return res; 15485 } 15486 }; 15487 15488 BX.delegateLater = function (func_name, thisObject, contextObject) 15489 { 15490 return function() 15491 { 15492 if (thisObject[func_name]) 15493 { 15494 var cur = BX.proxy_context; 15495 BX.proxy_context = this; 15496 var res = thisObject[func_name].apply(contextObject||thisObject, arguments); 15497 BX.proxy_context = cur; 15498 return res; 15499 } 15500 return null; 15501 } 15502 }; 15503 15504 BX.proxy = function(func, thisObject) 15505 { 15506 return getObjectDelegate(func, thisObject, proxyList); 15507 }; 15508 15509 BX.defer = function(func, thisObject) 15510 { 15511 if (!!thisObject) 15512 return BX.defer_proxy(func, thisObject); 15513 else 15514 return function() { 15515 var arg = arguments; 15516 setTimeout(function(){func.apply(this,arg)}, 10); 15517 }; 15518 }; 15519 15520 BX.defer_proxy = function(func, thisObject) 15521 { 15522 return getObjectDelegate(func, thisObject, deferList, BX.defer); 15523 }; 15524 15525 /** 15526 * 15527 * @private 15528 */ 15529 function getObjectDelegate(func, thisObject, collection, decorator) 15530 { 15531 if (!BX.type.isFunction(func) || !BX.type.isMapKey(thisObject)) 15532 { 15533 return func; 15534 } 15535 15536 var objectDelegates = collection.get(thisObject); 15537 if (!objectDelegates) 15538 { 15539 objectDelegates = new WeakMap(); 15540 collection.set(thisObject, objectDelegates); 15541 } 15542 15543 var delegate = objectDelegates.get(func); 15544 if (!delegate) 15545 { 15546 delegate = decorator ? decorator(BX.delegate(func, thisObject)) : BX.delegate(func, thisObject); 15547 objectDelegates.set(func, delegate); 15548 } 15549 15550 return delegate; 15551 } 15552 15553 BX.once = function(el, evname, func) 15554 { 15555 var fn = function() 15556 { 15557 BX.unbind(el, evname, fn); 15558 func.apply(this, arguments); 15559 }; 15560 15561 return fn; 15562 }; 15563 15564 BX.bindDelegate = function (elem, eventName, isTarget, handler) 15565 { 15566 var h = BX.delegateEvent(isTarget, handler); 15567 BX.bind(elem, eventName, h); 15568 return h; 15569 }; 15570 15571 BX.delegateEvent = function(isTarget, handler) 15572 { 15573 return function(e) 15574 { 15575 e = e || window.event; 15576 var target = e.target || e.srcElement; 15577 15578 while (target != this) 15579 { 15580 if (_checkNode(target, isTarget)) 15581 { 15582 return handler.call(target, e); 15583 } 15584 if (target && target.parentNode) 15585 target = target.parentNode; 15586 else 15587 break; 15588 } 15589 return null; 15590 } 15591 }; 15592 15593 BX.False = function() {return false;}; 15594 BX.DoNothing = function() {}; 15595 15596 // TODO: also check event handlers set via BX.bind() 15597 BX.denyEvent = function(el, ev) 15598 { 15599 deniedEvents.push([el, ev, el['on' + ev]]); 15600 el['on' + ev] = BX.DoNothing; 15601 }; 15602 15603 BX.allowEvent = function(el, ev) 15604 { 15605 for(var i=0, len=deniedEvents.length; i<len; i++) 15606 { 15607 if (deniedEvents[i][0] == el && deniedEvents[i][1] == ev) 15608 { 15609 el['on' + ev] = deniedEvents[i][2]; 15610 BX.util.deleteFromArray(deniedEvents, i); 15611 return; 15612 } 15613 } 15614 }; 15615 15616 BX.fixEventPageXY = function(event) 15617 { 15618 BX.fixEventPageX(event); 15619 BX.fixEventPageY(event); 15620 return event; 15621 }; 15622 15623 BX.fixEventPageX = function(event) 15624 { 15625 if (event.pageX == null && event.clientX != null) 15626 { 15627 event.pageX = 15628 event.clientX + 15629 (document.documentElement && document.documentElement.scrollLeft || document.body && document.body.scrollLeft || 0) - 15630 (document.documentElement.clientLeft || 0); 15631 } 15632 15633 return event; 15634 }; 15635 15636 BX.fixEventPageY = function(event) 15637 { 15638 if (event.pageY == null && event.clientY != null) 15639 { 15640 event.pageY = 15641 event.clientY + 15642 (document.documentElement && document.documentElement.scrollTop || document.body && document.body.scrollTop || 0) - 15643 (document.documentElement.clientTop || 0); 15644 } 15645 15646 return event; 15647 }; 15648 15649 /** 15650 * @deprecated 15651 * @see e.preventDefault() 15652 */ 15653 BX.PreventDefault = function(e) 15654 { 15655 if(!e) e = window.event; 15656 if(e.stopPropagation) 15657 { 15658 e.preventDefault(); 15659 e.stopPropagation(); 15660 } 15661 else 15662 { 15663 e.cancelBubble = true; 15664 e.returnValue = false;
15665 } 15666 return false; 15667 }; 15668 15669 /** 15670 * @deprecated 15671 * @see e.preventDefault(); 15672 * 15673 * @param e 15674 * @return {boolean} 15675 */ 15676 BX.eventReturnFalse = function(e) 15677 { 15678 e=e||window.event; 15679 if (e && e.preventDefault) e.preventDefault(); 15680 else e.returnValue = false; 15681 return false; 15682 }; 15683 15684 /** 15685 * @deprecated 15686 * @see e.stopPropagation() 15687 * @param e 15688 */ 15689 BX.eventCancelBubble = function(e) 15690 { 15691 e=e||window.event; 15692 if(e && e.stopPropagation) 15693 e.stopPropagation(); 15694 else 15695 e.cancelBubble = true; 15696 }; 15697 15698 BX.bindDebouncedChange = function(node, fn, fnInstant, timeout, ctx) 15699 { 15700 ctx = ctx || window; 15701 timeout = timeout || 300; 15702 15703 var dataTag = 'bx-dc-previous-value'; 15704 BX.data(node, dataTag, node.value); 15705 15706 var act = function(fn, val){ 15707 15708 var pVal = BX.data(node, dataTag); 15709 15710 if(typeof pVal == 'undefined' || pVal != val){ 15711 if(typeof ctx != 'object') 15712 fn(val); 15713 else 15714 fn.apply(ctx, [val]); 15715 } 15716 }; 15717 15718 var actD = BX.debounce(function(){ 15719 var val = node.value; 15720 act(fn, val); 15721 BX.data(node, dataTag, val); 15722 }, timeout); 15723 15724 BX.bind(node, 'keyup', actD); 15725 BX.bind(node, 'change', actD); 15726 BX.bind(node, 'input', actD); 15727 15728 if(BX.type.isFunction(fnInstant)){ 15729 15730 var actI = function(){ 15731 act(fnInstant, node.value); 15732 }; 15733 15734 BX.bind(node, 'keyup', actI); 15735 BX.bind(node, 'change', actI); 15736 BX.bind(node, 'input', actI); 15737 } 15738 }; 15739 15740 BX.parseJSON = function(data, context) 15741 { 15742 var result = null; 15743 if (BX.type.isNotEmptyString(data)) 15744 { 15745 try { 15746 if (data.indexOf("\n") >= 0) 15747 eval('result = ' + data); 15748 else 15749 result = (new Function("return " + data))(); 15750 } catch(e) { 15751 BX.onCustomEvent(context, 'onParseJSONFailure', [data, context]) 15752 } 15753 } 15754 else if(BX.type.isPlainObject(data)) 15755 { 15756 return data; 15757 } 15758 15759 return result; 15760 }; 15761 15762 BX.submit = function(obForm, action_name, action_value, onAfterSubmit) 15763 { 15764 action_name = action_name || 'save'; 15765 if (!obForm['BXFormSubmit_' + action_name]) 15766 { 15767 obForm['BXFormSubmit_' + action_name] = obForm.appendChild(BX.create('INPUT', { 15768 'props': { 15769 'type': 'submit', 15770 'name': action_name, 15771 'value': action_value || 'Y' 15772 }, 15773 'style': { 15774 'display': 'none' 15775 } 15776 })); 15777 } 15778 15779 if (obForm.sessid) 15780 obForm.sessid.value = BX.bitrix_sessid(); 15781 15782 setTimeout(BX.delegate(function() {BX.fireEvent(this, 'click'); if (onAfterSubmit) onAfterSubmit();}, obForm['BXFormSubmit_' + action_name]), 10); 15783 }; 15784 15785 BX.show = function(ob, displayType) 15786 { 15787 if (ob.BXDISPLAY || !_checkDisplay(ob, displayType)) 15788 { 15789 ob.style.display = ob.BXDISPLAY; 15790 } 15791 }; 15792 15793 BX.hide = function(ob, displayType) 15794 { 15795 if (!ob.BXDISPLAY) 15796 _checkDisplay(ob, displayType); 15797 15798 ob.style.display = 'none'; 15799 }; 15800 15801 BX.toggle = function(ob, values) 15802 { 15803 if (!values && BX.type.isElementNode(ob)) 15804 { 15805 var bShow = true; 15806 if (ob.BXDISPLAY) 15807 bShow = !_checkDisplay(ob); 15808 else 15809 bShow = ob.style.display == 'none'; 15810 15811 if (bShow) 15812 BX.show(ob); 15813 else 15814 BX.hide(ob); 15815 } 15816 else if (BX.type.isArray(values)) 15817 { 15818 for (var i=0,len=values.length; i<len; i++) 15819 { 15820 if (ob == values[i]) 15821 { 15822 ob = values[i==len-1 ? 0 : i+1]; 15823 break; 15824 } 15825 } 15826 if (i==len) 15827 ob = values[0]; 15828 } 15829 15830 return ob; 15831 }; 15832 15833 function _checkDisplay(ob, displayType) 15834 { 15835 if (typeof displayType != 'undefined') 15836 ob.BXDISPLAY = displayType; 15837 15838 var d = ob.style.display || BX.style(ob, 'display'); 15839 if (d != 'none') 15840 { 15841 ob.BXDISPLAY = ob.BXDISPLAY || d; 15842 return true; 15843 } 15844 else 15845 { 15846 ob.BXDISPLAY = ob.BXDISPLAY || 'block'; 15847 return false; 15848 } 15849 } 15850 15851 /* some useful util functions */ 15852 15853 BX.util = { 15854 /** 15855 * @deprecated 15856 * @use [].filter(value => !BX.Type.isNil(value)) 15857 * @param ar 15858 * @return {*} 15859 */ 15860 array_values: function(ar) 15861 { 15862 if (!BX.type.isArray(ar)) 15863 return BX.util._array_values_ob(ar); 15864 var arv = []; 15865 for(var i=0,l=ar.length;i<l;i++) 15866 if (ar[i] !== null && typeof ar[i] != 'undefined') 15867 arv.push(ar[i]); 15868 return arv; 15869 }, 15870 15871 /** 15872 * @deprecated 15873 * @use Object.values([]).filter(value => !BX.Type.isNil(value)) 15874 * @param ar 15875 * @return {Array} 15876 * @private 15877 */ 15878 _array_values_ob: function(ar) 15879 { 15880 var arv = []; 15881 for(var i in ar) 15882 if (ar[i] !== null && typeof ar[i] != 'undefined') 15883 arv.push(ar[i]); 15884 return arv; 15885 }, 15886 15887 /** 15888 * @deprecated 15889 * @use 15890 * @param ar 15891 * @return {*} 15892 */ 15893 array_keys: function(ar) 15894 { 15895 if (!BX.type.isArray(ar)) 15896 return BX.util._array_keys_ob(ar); 15897 var arv = []; 15898 for(var i=0,l=ar.length;i<l;i++) 15899 if (ar[i] !== null && typeof ar[i] != 'undefined') 15900 arv.push(i); 15901 return arv; 15902 }, 15903 15904 _array_keys_ob: function(ar) 15905 { 15906 var arv = []; 15907 for(var i in ar) 15908 if (ar[i] !== null && typeof ar[i] != 'undefined') 15909 arv.push(i); 15910 return arv; 15911 }, 15912 15913 object_keys: function(obj) 15914 { 15915 var arv = []; 15916 for(var k in obj) 15917 { 15918 if(obj.hasOwnProperty(k)) 15919 { 15920 arv.push(k); 15921 } 15922 } 15923 return arv; 15924 }, 15925 15926 /** 15927 * @deprecated 15928 * @use firstArr.concat(secondArr); 15929 * @param first 15930 * @param second 15931 * @return {*[]} 15932 */ 15933 array_merge: function(first, second) 15934 { 15935 if (!BX.type.isArray(first)) first = []; 15936 if (!BX.type.isArray(second)) second = []; 15937 15938 var i = first.length, j = 0; 15939 15940 if (typeof second.length === "number") 15941 { 15942 for (var l = second.length; j < l; j++) 15943 { 15944 first[i++] = second[j]; 15945 } 15946 } 15947 else 15948 {
15949 while (second[j] !== undefined) 15950 { 15951 first[i++] = second[j++]; 15952 } 15953 } 15954 15955 first.length = i; 15956 15957 return first; 15958 }, 15959 15960 array_flip: function (object) 15961 { 15962 var newObject = {}; 15963 15964 for (var key in object) 15965 { 15966 newObject[object[key]] = key; 15967 } 15968 15969 return newObject; 15970 }, 15971 15972 array_diff: function(ar1, ar2, hash) 15973 { 15974 hash = BX.type.isFunction(hash) ? hash : null; 15975 var i, length, v, h, map = {}, result = []; 15976 for(i = 0, length = ar2.length; i < length; i++) 15977 { 15978 v = ar2[i]; 15979 h = hash ? hash(v) : v; 15980 map[h] = true; 15981 } 15982 15983 for(i = 0, length = ar1.length; i < length; i++) 15984 { 15985 v = ar1[i]; 15986 h = hash ? hash(v) : v; 15987 if(typeof(map[h]) === "undefined") 15988 { 15989 result.push(v); 15990 } 15991 } 15992 return result; 15993 }, 15994 15995 /** 15996 * @deprecated 15997 * @use Set 15998 */ 15999 array_unique: function(ar) 16000 { 16001 var i=0,j,len=ar.length; 16002 if(len<2) return ar; 16003 16004 for (; i<len-1;i++) 16005 { 16006 for (j=i+1; j<len;j++) 16007 { 16008 if (ar[i]==ar[j]) 16009 { 16010 ar.splice(j--,1); len--; 16011 } 16012 } 16013 } 16014 16015 return ar; 16016 }, 16017 16018 /** 16019 * @deprecated 16020 * @use myArr.includes(needle) 16021 */ 16022 in_array: function(needle, haystack) 16023 { 16024 for(var i=0; i<haystack.length; i++) 16025 { 16026 if(haystack[i] == needle) 16027 return true; 16028 } 16029 return false; 16030 }, 16031 16032 /** 16033 * @deprecated 16034 * @use myArr.findIndex(item => item === needle); 16035 */ 16036 array_search: function(needle, haystack) 16037 { 16038 for(var i=0; i<haystack.length; i++) 16039 { 16040 if(haystack[i] == needle) 16041 return i; 16042 } 16043 return -1; 16044 }, 16045 16046 object_search_key: function(needle, haystack) 16047 { 16048 if (typeof haystack[needle] != 'undefined') 16049 return haystack[needle]; 16050 16051 for(var i in haystack) 16052 { 16053 if (typeof haystack[i] == "object") 16054 { 16055 var result = BX.util.object_search_key(needle, haystack[i]); 16056 if (result !== false) 16057 return result; 16058 } 16059 } 16060 return false; 16061 }, 16062 16063 trim: function(s) 16064 { 16065 if (BX.type.isString(s)) 16066 { 16067 return s.trim(); 16068 } 16069 16070 return s; 16071 }, 16072 16073 urlencode: function(s){return encodeURIComponent(s);}, 16074 16075 // it may also be useful. via sVD. 16076 deleteFromArray: function(ar, ind) {return ar.slice(0, ind).concat(ar.slice(ind + 1));}, 16077 insertIntoArray: function(ar, ind, el) {return ar.slice(0, ind).concat([el]).concat(ar.slice(ind));}, 16078 16079 htmlspecialchars: function(str) 16080 { 16081 return BX.Text.encode(str); 16082 }, 16083 16084 htmlspecialcharsback: function(str) 16085 { 16086 return BX.Text.decode(str); 16087 }, 16088 16089 // Quote regular expression characters plus an optional character 16090 preg_quote: function(str, delimiter) 16091 { 16092 if(!str.replace) 16093 return str; 16094 return str.replace(new RegExp('[.\\\\+*?\\[\\^\\]$(){}=!<>|:\\' + (delimiter || '') + '-]', 'g'), '\\$&'); 16095 }, 16096 16097 jsencode: function(str) 16098 { 16099 if (!str || !str.replace) 16100 return str; 16101 16102 var escapes = 16103 [ 16104 { c: "\\\\", r: "\\\\" }, // should be first 16105 { c: "\\t", r: "\\t" }, 16106 { c: "\\n", r: "\\n" }, 16107 { c: "\\r", r: "\\r" }, 16108 { c: "\"", r: "\\\"" }, 16109 { c: "'", r: "\\'" }, 16110 { c: "<", r: "\\x3C" }, 16111 { c: ">", r: "\\x3E" }, 16112 { c: "\\u2028", r: "\\u2028" }, 16113 { c: "\\u2029", r: "\\u2029" } 16114 ]; 16115 for (var i = 0; i < escapes.length; i++) 16116 str = str.replace(new RegExp(escapes[i].c, 'g'), escapes[i].r); 16117 return str; 16118 }, 16119 16120 getCssName: function(jsName) 16121 { 16122 if (!BX.type.isNotEmptyString(jsName)) 16123 { 16124 return ""; 16125 } 16126 16127 return jsName.replace(/[A-Z]/g, function(match) { 16128 return "-" + match.toLowerCase(); 16129 }); 16130 }, 16131 16132 getJsName: function(cssName) 16133 { 16134 var regex = /\-([a-z]){1}/g; 16135 if (regex.test(cssName)) 16136 { 16137 return cssName.replace(regex, function(match, letter) { 16138 return letter.toUpperCase(); 16139 }); 16140 } 16141 16142 return cssName; 16143 }, 16144 16145 nl2br: function(str) 16146 { 16147 if (!str || !str.replace) 16148 return str; 16149 16150 return str.replace(/([^>])\n/g, '$1<br/>'); 16151 }, 16152 16153 /** 16154 * @deprecated 16155 * @use .padStart() / .padEnd() 16156 * @param input 16157 * @param pad_length 16158 * @param pad_string 16159 * @param pad_type 16160 * @return {*} 16161 */ 16162 str_pad: function(input, pad_length, pad_string, pad_type) 16163 { 16164 pad_string = pad_string || ' '; 16165 pad_type = pad_type || 'right'; 16166 input = input.toString(); 16167 16168 if (pad_type === 'left') 16169 { 16170 return BX.util.str_pad_left(input, pad_length, pad_string); 16171 } 16172 16173 return BX.util.str_pad_right(input, pad_length, pad_string); 16174 }, 16175 16176 str_pad_left: function(input, pad_length, pad_string) 16177 { 16178 return input.toString().padStart(pad_length, pad_string); 16179 }, 16180 16181 str_pad_right: function(input, pad_length, pad_string) 16182 { 16183 return input.toString().padEnd(pad_length, pad_string); 16184 }, 16185 16186 strip_tags: function(str) 16187 { 16188 return str.split(/<[^>]+>/g).join(''); 16189 }, 16190 16191 strip_php_tags: function(str) 16192 { 16193 return str.replace(/<\?(.|[\r\n])*?\?>/g, ''); 16194 }, 16195 16196 popup: function(url, width, height) 16197 { 16198 var w, h; 16199 if(BX.browser.IsOpera()) 16200 { 16201 w = document.body.offsetWidth; 16202 h = document.body.offsetHeight; 16203 } 16204 else 16205 {
16206 w = screen.width; 16207 h = screen.height; 16208 } 16209 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)); 16210 }, 16211 16212 shuffle: function(array) 16213 { 16214 var temporaryValue, randomIndex; 16215 var currentIndex = array.length; 16216 16217 while (0 !== currentIndex) 16218 { 16219 randomIndex = Math.floor(Math.random() * currentIndex); 16220 currentIndex -= 1; 16221 16222 temporaryValue = array[currentIndex]; 16223 array[currentIndex] = array[randomIndex]; 16224 array[randomIndex] = temporaryValue; 16225 } 16226 16227 return array; 16228 }, 16229 16230 // BX.util.objectSort(object, sortBy, sortDir) - Sort object by property 16231 // function params: 1 - object for sort, 2 - sort by property, 3 - sort direction (asc/desc) 16232 // return: sort array [[objectElement], [objectElement]] in sortDir direction 16233 16234 // example: BX.util.objectSort({'L1': {'name': 'Last'}, 'F1': {'name': 'First'}}, 'name', 'asc'); 16235 // return: [{'name' : 'First'}, {'name' : 'Last'}] 16236 objectSort: function(object, sortBy, sortDir) 16237 { 16238 sortDir = sortDir == 'asc'? 'asc': 'desc'; 16239 16240 var arItems = [], i; 16241 for (i in object) 16242 { 16243 if (object.hasOwnProperty(i) && object[i][sortBy]) 16244 { 16245 arItems.push([i, object[i][sortBy]]); 16246 } 16247 } 16248 16249 if (sortDir == 'asc') 16250 { 16251 arItems.sort(function(i, ii) { 16252 var s1, s2; 16253 if (BX.type.isDate(i[1])) 16254 { 16255 s1 = i[1].getTime(); 16256 } 16257 else if (!isNaN(i[1])) 16258 { 16259 s1 = parseInt(i[1]); 16260 } 16261 else 16262 { 16263 s1 = i[1].toString().toLowerCase(); 16264 } 16265 16266 if (BX.type.isDate(ii[1])) 16267 { 16268 s2 = ii[1].getTime(); 16269 } 16270 else if (!isNaN(ii[1])) 16271 { 16272 s2 = parseInt(ii[1]); 16273 } 16274 else 16275 { 16276 s2 = ii[1].toString().toLowerCase(); 16277 } 16278 16279 if (s1 > s2) 16280 return 1; 16281 else if (s1 < s2) 16282 return -1; 16283 else 16284 return 0; 16285 }); 16286 } 16287 else 16288 { 16289 arItems.sort(function(i, ii) { 16290 var s1, s2; 16291 if (BX.type.isDate(i[1])) 16292 { 16293 s1 = i[1].getTime(); 16294 } 16295 else if (!isNaN(i[1])) 16296 { 16297 s1 = parseInt(i[1]); 16298 } 16299 else 16300 { 16301 s1 = i[1].toString().toLowerCase(); 16302 } 16303 16304 if (BX.type.isDate(ii[1])) 16305 { 16306 s2 = ii[1].getTime(); 16307 } 16308 else if (!isNaN(ii[1])) 16309 { 16310 s2 = parseInt(ii[1]); 16311 } 16312 else 16313 { 16314 s2 = ii[1].toString().toLowerCase(); 16315 } 16316 16317 if (s1 < s2) 16318 return 1; 16319 else if (s1 > s2) 16320 return -1; 16321 else 16322 return 0; 16323 }); 16324 } 16325 16326 var arReturnArray = Array(); 16327 for (i = 0; i < arItems.length; i++) 16328 { 16329 arReturnArray.push(object[arItems[i][0]]); 16330 } 16331 16332 return arReturnArray; 16333 }, 16334 16335 objectMerge: function() 16336 { 16337 return BX.mergeEx.apply(window, arguments); 16338 }, 16339 16340 objectClone : function(object) 16341 { 16342 return BX.clone(object, true); 16343 }, 16344 16345 // #fdf9e5 => {r=253, g=249, b=229} 16346 hex2rgb: function(color) 16347 { 16348 var rgb = color.replace(/[# ]/g,"").replace(/^(.)(.)(.)$/,'$1$1$2$2$3$3').match(/.{2}/g); 16349 for (var i=0; i<3; i++) 16350 { 16351 rgb[i] = parseInt(rgb[i], 16); 16352 } 16353 return {'r':rgb[0],'g':rgb[1],'b':rgb[2]}; 16354 }, 16355 16356 /** 16357 * @deprecated 16358 * @use BX.Uri 16359 * @param url 16360 * @param param 16361 * @return {string} 16362 */ 16363 remove_url_param: function(url, param) 16364 { 16365 return BX.Uri.removeParam(url, param); 16366 }, 16367 16368 /* 16369 {'param1': 'value1', 'param2': 'value2'} 16370 */ 16371 /** 16372 * @deprecated 16373 * @use BX.Uri 16374 * @param url 16375 * @param params 16376 * @return {string} 16377 */ 16378 add_url_param: function(url, params) 16379 { 16380 var preparedParams = Object.entries(params).reduce(function(acc, item) { 16381 acc[item[0]] = BX.type.isArray(item[1]) ? item[1].join() : item[1]; 16382 return acc; 16383 }, {}); 16384 16385 return BX.Uri.addParam(url, preparedParams); 16386 }, 16387 16388 /* 16389 {'param1': 'value1', 'param2': 'value2'} 16390 */ 16391 buildQueryString: function(params) 16392 { 16393 var result = ''; 16394 for (var key in params) 16395 { 16396 var value = params[key]; 16397 if(BX.type.isArray(value)) 16398 { 16399 value.forEach(function(valueElement, index) 16400 { 16401 result += encodeURIComponent(key + "[" + index + "]") + "=" + encodeURIComponent(valueElement) + "&"; 16402 }); 16403 } 16404 else 16405 { 16406 result += encodeURIComponent(key) + "=" + encodeURIComponent(value) + "&"; 16407 } 16408 } 16409 16410 if(result.length > 0) 16411 { 16412 result = result.substr(0, result.length - 1); 16413 } 16414 return result; 16415 }, 16416 16417 even: function(digit) 16418 { 16419 return (parseInt(digit) % 2 == 0); 16420 }, 16421 16422 hashCode: function(str) 16423 { 16424 if(!BX.type.isNotEmptyString(str)) 16425 { 16426 return 0; 16427 } 16428 16429 var hash = 0; 16430 for (var i = 0; i < str.length; i++) 16431 { 16432 var c = str.charCodeAt(i); 16433 hash = ((hash << 5) - hash) + c; 16434 hash = hash & hash; 16435 } 16436 return hash; 16437 }, 16438 16439 getRandomString: function (length) 16440 { 16441 return BX.Text.getRandom(length); 16442 }, 16443 16444 number_format: function(number, decimals, dec_point, thousands_sep) 16445 { 16446 var i, j, kw, kd, km, sign = ''; 16447 decimals = Math.abs(decimals); 16448 if (isNaN(decimals) || decimals < 0) 16449 { 16450 decimals = 2; 16451 } 16452 dec_point = dec_point || ','; 16453 if (typeof thousands_sep === 'undefined') 16454 thousands_sep = '.'; 16455 16456 number = (+number || 0).toFixed(decimals); 16457 if (number < 0) 16458 { 16459 sign = '-'; 16460 number = -number; 16461 } 16462 16463 i = parseInt(number, 10) + ''; 16464 j = (i.length > 3 ? i.length % 3 : 0); 16465 16466 km = (j ? i.substr(0, j) + thousands_sep : ''); 16467 kw = i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thousands_sep); 16468 kd = (decimals ? dec_point + Math.abs(number - i).toFixed(decimals).replace(/-/, '0').slice(2) : ''); 16469 16470 return sign + km + kw + kd; 16471 }, 16472 16473 getExtension: function (url) 16474 { 16475 url = url || ""; 16476 var items = url.split("?")[0].split("."); 16477 return items[items.length-1].toLowerCase(); 16478 }, 16479 addObjectToForm: function(object, form, prefix) 16480 { 16481 if(!BX.type.isString(prefix)) 16482 { 16483 prefix = ""; 16484 } 16485 16486 for(var key in object) 16487 { 16488 if(!object.hasOwnProperty(key)) 16489 { 16490 continue; 16491 } 16492 16493 var value = object[key]; 16494 var name = prefix !== "" ? (prefix + "[" + key + "]") : key; 16495 if(BX.type.isArray(value)) 16496 { 16497 var obj = {}; 16498 for(var i = 0; i < value.length; i++) 16499 { 16500 obj[i] = value[i]; 16501 } 16502 16503 BX.util.addObjectToForm(obj, form, name); 16504 } 16505 else if(BX.type.isPlainObject(value)) 16506 { 16507 BX.util.addObjectToForm(value, form, name); 16508 } 16509 else 16510 { 16511 value = BX.type.isFunction(value.toString) ? value.toString() : ""; 16512 if(value !== "") 16513 { 16514 form.appendChild(BX.create("INPUT", { attrs: { type: "hidden", name: name, value: value } })); 16515 } 16516 } 16517 } 16518 }, 16519 16520 observe: function(object, enable) 16521 {
16522 console.error('BX.util.observe: function is no longer supported by browser.'); 16523 return false; 16524 }, 16525 16526 escapeRegExp: function(str) 16527 { 16528 return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"); 16529 } 16530 }; 16531 16532 BX.validation = { 16533 checkIfEmail: function(s) 16534 { 16535 var atom = "[=a-z0-9_+~'!$&*^`|#%/?{}-]"; 16536 return (new RegExp('^\\s*'+atom+'+(\\.'+atom+'+)*@([a-z0-9-]+\\.)+[a-z0-9-]{2,20}\\s*$', 'i')).test(s); 16537 }, 16538 checkIfPhone: function(s) 16539 { 16540 var regexp = new RegExp( 16541 typeof(BX.PhoneNumber) === "undefined" 16542 ? BX.PhoneNumber.getValidNumberPattern() 16543 : '^\\s*\\+?\s*[0-9(-)\\s]+\\s*$', 16544 'i' 16545 ); 16546 return regexp.test(s); 16547 } 16548 }; 16549 16550 BX.prop = 16551 { 16552 get: function(object, key, defaultValue) 16553 { 16554 return object && object.hasOwnProperty(key) ? object[key] : defaultValue; 16555 }, 16556 getObject: function(object, key, defaultValue) 16557 { 16558 return object && BX.type.isPlainObject(object[key]) ? object[key] : defaultValue; 16559 }, 16560 getElementNode: function(object, key, defaultValue) 16561 { 16562 return object && BX.type.isElementNode(object[key]) ? object[key] : defaultValue; 16563 }, 16564 getArray: function(object, key, defaultValue) 16565 { 16566 return object && BX.type.isArray(object[key]) ? object[key] : defaultValue; 16567 }, 16568 getFunction: function(object, key, defaultValue) 16569 { 16570 return object && BX.type.isFunction(object[key]) ? object[key] : defaultValue; 16571 }, 16572 getNumber: function(object, key, defaultValue) 16573 { 16574 if(!(object && object.hasOwnProperty(key))) 16575 { 16576 return defaultValue; 16577 } 16578 16579 var value = object[key]; 16580 if(BX.type.isNumber(value)) 16581 { 16582 return value; 16583 } 16584 16585 value = parseFloat(value); 16586 return !isNaN(value) ? value : defaultValue; 16587 }, 16588 getInteger: function(object, key, defaultValue) 16589 { 16590 if(!(object && object.hasOwnProperty(key))) 16591 { 16592 return defaultValue; 16593 } 16594 16595 var value = object[key]; 16596 if(BX.type.isNumber(value)) 16597 { 16598 return value; 16599 } 16600 16601 value = parseInt(value); 16602 return !isNaN(value) ? value : defaultValue; 16603 }, 16604 getBoolean: function(object, key, defaultValue) 16605 { 16606 if(!(object && object.hasOwnProperty(key))) 16607 { 16608 return defaultValue; 16609 } 16610 16611 var value = object[key]; 16612 return (BX.type.isBoolean(value) 16613 ? value 16614 : (BX.type.isString(value) ? (value.toLowerCase() === "true") : !!value) 16615 ); 16616 }, 16617 getString: function(object, key, defaultValue) 16618 { 16619 if(!(object && object.hasOwnProperty(key))) 16620 { 16621 return defaultValue; 16622 } 16623 16624 var value = object[key]; 16625 return BX.type.isString(value) ? value : (value ? value.toString() : ''); 16626 }, 16627 extractDate: function(datetime) 16628 { 16629 if(!BX.type.isDate(datetime)) 16630 { 16631 datetime = new Date(); 16632 } 16633 16634 datetime.setHours(0); 16635 datetime.setMinutes(0); 16636 datetime.setSeconds(0); 16637 datetime.setMilliseconds(0); 16638 16639 return datetime; 16640 } 16641 }; 16642 16643 BX.isNodeInDom = function(node, doc) 16644 { 16645 return node === (doc || document) ? true : 16646 (node.parentNode ? BX.isNodeInDom(node.parentNode) : false); 16647 }; 16648 16649 BX.isNodeHidden = function(node) 16650 { 16651 if (node === document) 16652 return false; 16653 else if (BX.style(node, 'display') == 'none') 16654 return true; 16655 else 16656 return (node.parentNode ? BX.isNodeHidden(node.parentNode) : true); 16657 }; 16658 16659 BX.evalPack = function(code) 16660 { 16661 while (code.length > 0) 16662 { 16663 var c = code.shift(); 16664 16665 if (c.TYPE == 'SCRIPT_EXT' || c.TYPE == 'SCRIPT_SRC') 16666 { 16667 BX.loadScript(c.DATA, function() {BX.evalPack(code)}); 16668 return; 16669 } 16670 else if (c.TYPE == 'SCRIPT') 16671 { 16672 BX.evalGlobal(c.DATA); 16673 } 16674 } 16675 }; 16676 16677 BX.evalGlobal = function(data) 16678 { 16679 if (data) 16680 { 16681 var head = document.getElementsByTagName("head")[0] || document.documentElement, 16682 script = document.createElement("script"); 16683 16684 script.type = "text/javascript"; 16685 16686 if (!BX.browser.IsIE()) 16687 { 16688 script.appendChild(document.createTextNode(data)); 16689 } 16690 else 16691 { 16692 script.text = data; 16693 } 16694 16695 head.insertBefore(script, head.firstChild); 16696 head.removeChild(script); 16697 } 16698 }; 16699 16700 BX.garbage = function(call, thisObject) 16701 { 16702 garbageCollectors.push({callback: call, context: thisObject}); 16703 }; 16704 16705 BX.GetDocElement = function (pDoc) 16706 { 16707 pDoc = pDoc || document; 16708 return (BX.browser.IsDoctype(pDoc) ? pDoc.documentElement : pDoc.body); 16709 }; 16710 16711 BX.scrollTop = function(node, val){ 16712 if(typeof val != 'undefined'){ 16713 16714 if(node == window){ 16715 throw new Error('scrollTop() for window is not implemented'); 16716 }else 16717 node.scrollTop = parseInt(val); 16718 16719 }else{ 16720 16721 if(node == window) 16722 return BX.GetWindowScrollPos().scrollTop; 16723 16724 return node.scrollTop; 16725 } 16726 }; 16727 16728 BX.scrollLeft = function(node, val){ 16729 if(typeof val != 'undefined'){ 16730 16731 if(node == window){ 16732 throw new Error('scrollLeft() for window is not implemented'); 16733 }else 16734 node.scrollLeft = parseInt(val); 16735 16736 }else{ 16737 16738 if(node == window) 16739 return BX.GetWindowScrollPos().scrollLeft; 16740 16741 return node.scrollLeft; 16742 } 16743 }; 16744 16745 BX.hide_object = function(ob) 16746 { 16747 ob = BX(ob); 16748 ob.style.position = 'absolute'; 16749 ob.style.top = '-1000px'; 16750 ob.style.left = '-1000px'; 16751 ob.style.height = '10px'; 16752 ob.style.width = '10px'; 16753 }; 16754 16755 BX.is_relative = function(el) 16756 { 16757 var p = BX.style(el, 'position'); 16758 return p == 'relative' || p == 'absolute'; 16759 }; 16760 16761 BX.is_float = function(el) 16762 { 16763 var p = BX.style(el, 'float'); 16764 return p == 'right' || p == 'left'; 16765 }; 16766 16767 BX.is_fixed = function(el) 16768 { 16769 var p = BX.style(el, 'position'); 16770 return p == 'fixed'; 16771 }; 16772 16773 BX.width = function(node, val){ 16774 if(typeof val != 'undefined') 16775 BX.style(node, 'width', parseInt(val)+'px'); 16776 else{ 16777 16778 if(node == window) 16779 return window.innerWidth; 16780 16781 //return parseInt(BX.style(node, 'width')); 16782 return BX.pos(node).width; 16783 } 16784 }; 16785 16786 BX.height = function(node, val){ 16787 if(typeof val != 'undefined') 16788 BX.style(node, 'height', parseInt(val)+'px'); 16789 else{ 16790 16791 if(node == window) 16792 return window.innerHeight; 16793 16794 //return parseInt(BX.style(node, 'height')); 16795 return BX.pos(node).height; 16796 } 16797 }; 16798 16799 BX.align = function(pos, w, h, type) 16800 { 16801 if (type) 16802 type = type.toLowerCase(); 16803 else 16804 type = ''; 16805 16806 var pDoc = document; 16807 if (BX.type.isElementNode(pos)) 16808 { 16809 pDoc = pos.ownerDocument; 16810 pos = BX.pos(pos); 16811 } 16812 16813 var x = pos["left"], y = pos["bottom"]; 16814 16815 var scroll = BX.GetWindowScrollPos(pDoc); 16816 var size = BX.GetWindowInnerSize(pDoc); 16817 16818 if((size.innerWidth + scroll.scrollLeft) - (pos["left"] + w) < 0) 16819 { 16820 if(pos["right"] - w >= 0 ) 16821 x = pos["right"] - w; 16822 else 16823 x = scroll.scrollLeft; 16824 } 16825
16826 if(((size.innerHeight + scroll.scrollTop) - (pos["bottom"] + h) < 0) || ~type.indexOf('top')) 16827 { 16828 if(pos["top"] - h >= 0 || ~type.indexOf('top')) 16829 y = pos["top"] - h; 16830 else 16831 y = scroll.scrollTop; 16832 } 16833 16834 return {'left':x, 'top':y}; 16835 }; 16836 16837 BX.scrollToNode = function(node) 16838 { 16839 var obNode = BX(node); 16840 16841 if (obNode.scrollIntoView) 16842 obNode.scrollIntoView(true); 16843 else 16844 { 16845 var arNodePos = BX.pos(obNode); 16846 window.scrollTo(arNodePos.left, arNodePos.top); 16847 } 16848 }; 16849 16850 /* non-xhr loadings */ 16851 BX.showWait = function(node, msg) 16852 { 16853 node = BX(node) || document.body || document.documentElement; 16854 msg = msg || BX.message('JS_CORE_LOADING'); 16855 16856 var container_id = node.id || Math.random(); 16857 16858 var obMsg = node.bxmsg = document.body.appendChild(BX.create('DIV', { 16859 props: { 16860 id: 'wait_' + container_id 16861 }, 16862 style: { 16863 background: 'url("/bitrix/js/main/core/images/wait.gif") no-repeat scroll 10px center #fcf7d1', 16864 border: '1px solid #E1B52D', 16865 color: 'black', 16866 fontFamily: 'Verdana,Arial,sans-serif', 16867 fontSize: '11px', 16868 padding: '10px 30px 10px 37px', 16869 position: 'absolute', 16870 zIndex:'10000', 16871 textAlign:'center' 16872 }, 16873 text: msg 16874 })); 16875 16876 setTimeout(BX.delegate(_adjustWait, node), 10); 16877 16878 lastWait[lastWait.length] = obMsg; 16879 return obMsg; 16880 }; 16881 16882 BX.closeWait = function(node, obMsg) 16883 { 16884 if(node && !obMsg) 16885 obMsg = node.bxmsg; 16886 if(node && !obMsg && BX.hasClass(node, 'bx-core-waitwindow')) 16887 obMsg = node; 16888 if(node && !obMsg) 16889 obMsg = BX('wait_' + node.id); 16890 if(!obMsg) 16891 obMsg = lastWait.pop(); 16892 16893 if (obMsg && obMsg.parentNode) 16894 { 16895 for (var i=0,len=lastWait.length;i<len;i++) 16896 { 16897 if (obMsg == lastWait[i]) 16898 { 16899 lastWait = BX.util.deleteFromArray(lastWait, i); 16900 break; 16901 } 16902 } 16903 16904 obMsg.parentNode.removeChild(obMsg); 16905 if (node) node.bxmsg = null; 16906 BX.cleanNode(obMsg, true); 16907 } 16908 }; 16909 16910 BX.setJSList = function(scripts) 16911 { 16912 if (BX.type.isArray(scripts)) 16913 { 16914 scripts = scripts.map(function(script) { 16915 return normalizeUrl(script) 16916 }); 16917 16918 jsList = jsList.concat(scripts); 16919 } 16920 }; 16921 16922 BX.getJSList = function() 16923 { 16924 initJsList(); 16925 return jsList; 16926 }; 16927 16928 BX.setCSSList = function(cssFiles) 16929 { 16930 if (BX.type.isArray(cssFiles)) 16931 { 16932 cssFiles = cssFiles.map(function(cssFile) { 16933 return normalizeUrl(cssFile); 16934 }); 16935 16936 cssList = cssList.concat(cssFiles); 16937 } 16938 }; 16939 16940 BX.getCSSList = function() 16941 { 16942 initCssList(); 16943 return cssList; 16944 }; 16945 16946 BX.getJSPath = function(js) 16947 { 16948 return js.replace(/^(http[s]*:)*\/\/[^\/]+/i, ''); 16949 }; 16950 16951 BX.getCSSPath = function(css) 16952 { 16953 return css.replace(/^(http[s]*:)*\/\/[^\/]+/i, ''); 16954 }; 16955 16956 BX.getCDNPath = function(path) 16957 { 16958 return path; 16959 }; 16960 16961 BX.loadScript = function(script, callback, doc) 16962 { 16963 if (BX.type.isString(script)) 16964 { 16965 script = [script]; 16966 } 16967 16968 return BX.load(script, callback, doc); 16969 }; 16970 16971 BX.loadCSS = function(css, doc, win) 16972 { 16973 if (BX.type.isString(css)) 16974 { 16975 css = [css]; 16976 } 16977 16978 if (BX.type.isArray(css)) 16979 { 16980 css = css.map(function(url) { 16981 return { url: url, ext: "css" } 16982 }); 16983 16984 BX.load(css, null, doc); 16985 } 16986 }; 16987 16988 BX.load = function(items, callback, doc) 16989 { 16990 if (!BX.isReady) 16991 { 16992 var _args = arguments; 16993 BX.ready(function() { 16994 BX.load.apply(this, _args); 16995 }); 16996 return null; 16997 } 16998 16999 doc = doc || document; 17000 if (isAsync === null) 17001 { 17002 isAsync = "async" in doc.createElement("script") || "MozAppearance" in doc.documentElement.style || window.opera; 17003 } 17004 17005 return isAsync ? loadAsync(items, callback, doc) : loadAsyncEmulation(items, callback, doc); 17006 }; 17007 17008 BX.convert = 17009 { 17010 toNumber: function(value) 17011 { 17012 if(BX.type.isNumber(value)) 17013 { 17014 return value; 17015 } 17016 17017 value = Number(value); 17018 return !isNaN(value) ? value : 0; 17019 }, 17020 nodeListToArray: function(nodes) 17021 { 17022 try 17023 { 17024 return (Array.prototype.slice.call(nodes, 0)); 17025 } 17026 catch (ex) 17027 { 17028 var ary = []; 17029 for(var i = 0, l = nodes.length; i < l; i++) 17030 { 17031 ary.push(nodes[i]); 17032 } 17033 return ary; 17034 } 17035 } 17036 }; 17037 17038 function loadAsync(items, callback, doc) 17039 { 17040 if (!BX.type.isArray(items)) 17041 { 17042 return; 17043 } 17044 17045 function allLoaded(items) 17046 { 17047 items = items || assets; 17048 for (var name in items) 17049 { 17050 if (items.hasOwnProperty(name) && items[name].state !== LOADED) 17051 { 17052 return false;
17053 } 17054 } 17055 17056 return true; 17057 } 17058 17059 if (!BX.type.isFunction(callback)) 17060 { 17061 callback = null; 17062 } 17063 17064 var itemSet = {}, item, i; 17065 for (i = 0; i < items.length; i++) 17066 { 17067 item = items[i]; 17068 item = getAsset(item); 17069 itemSet[item.name] = item; 17070 } 17071 17072 var callbackWasCalled = false; 17073 if (items.length > 0) 17074 { 17075 for (i = 0; i < items.length; i++) 17076 { 17077 item = items[i]; 17078 item = getAsset(item); 17079 load(item, function () { 17080 if (allLoaded(itemSet)) 17081 { 17082 if (!callbackWasCalled) 17083 { 17084 callback && callback(); 17085 callbackWasCalled = true; 17086 } 17087 17088 } 17089 }, doc); 17090 } 17091 } 17092 else 17093 { 17094 if (typeof callback === 'function') 17095 { 17096 callback(); 17097 callbackWasCalled = true; 17098 } 17099 } 17100 } 17101 17102 function loadAsyncEmulation(items, callback, doc) 17103 { 17104 function onPreload(asset) 17105 { 17106 asset.state = PRELOADED; 17107 if (BX.type.isArray(asset.onpreload) && asset.onpreload) 17108 { 17109 for (var i = 0; i < asset.onpreload.length; i++) 17110 { 17111 asset.onpreload[i].call(); 17112 } 17113 } 17114 } 17115 17116 function preLoad(asset) 17117 { 17118 if (asset.state === undefined) 17119 { 17120 asset.state = PRELOADING; 17121 asset.onpreload = []; 17122 17123 loadAsset( 17124 { url: asset.url, type: "cache", ext: asset.ext}, 17125 function () { onPreload(asset); }, 17126 doc 17127 ); 17128 } 17129 } 17130 17131 if (!BX.type.isArray(items)) 17132 { 17133 return; 17134 } 17135 17136 if (!BX.type.isFunction(callback)) 17137 { 17138 callback = null; 17139 } 17140 17141 var rest = [].slice.call(items, 1); 17142 for (var i = 0; i < rest.length; i++) 17143 { 17144 preLoad(getAsset(rest[i])); 17145 } 17146 17147 load(getAsset(items[0]), items.length === 1 ? callback : function () { 17148 loadAsyncEmulation.apply(null, [rest, callback, doc]); 17149 }, doc); 17150 } 17151 17152 function load(asset, callback, doc) 17153 { 17154 callback = callback || BX.DoNothing; 17155 17156 if (asset.state === LOADED) 17157 { 17158 callback(); 17159 return; 17160 } 17161 17162 if (asset.state === PRELOADING) 17163 { 17164 asset.onpreload.push(function () { 17165 load(asset, callback, doc); 17166 }); 17167 return; 17168 } 17169 17170 asset.state = LOADING; 17171 17172 loadAsset( 17173 asset, 17174 function () { 17175 asset.state = LOADED; 17176 callback(); 17177 }, 17178 doc 17179 ); 17180 } 17181 17182 function loadAsset(asset, callback, doc) 17183 { 17184 callback = callback || BX.DoNothing; 17185 17186 function error(event) 17187 { 17188 ele.onload = ele.onreadystatechange = ele.onerror = null; 17189 callback(); 17190 } 17191 17192 function process(event) 17193 { 17194 event = event || window.event; 17195 if (event.type === "load" || (/loaded|complete/.test(ele.readyState) && (!doc.documentMode || doc.documentMode < 9))) 17196 { 17197 window.clearTimeout(asset.errorTimeout); 17198 window.clearTimeout(asset.cssTimeout); 17199 ele.onload = ele.onreadystatechange = ele.onerror = null; 17200 callback(); 17201 } 17202 } 17203 17204 function isCssLoaded() 17205 { 17206 if (asset.state !== LOADED && asset.cssRetries <= 20) 17207 { 17208 for (var i = 0, l = doc.styleSheets.length; i < l; i++) 17209 { 17210 if (doc.styleSheets[i].href === ele.href) 17211 { 17212 process({"type": "load"}); 17213 return; 17214 } 17215 } 17216 17217 asset.cssRetries++; 17218 asset.cssTimeout = window.setTimeout(isCssLoaded, 250); 17219 } 17220 } 17221 17222 var ele; 17223 var ext = BX.type.isNotEmptyString(asset.ext) ? asset.ext : BX.util.getExtension(asset.url); 17224 17225 if (ext === "css") 17226 { 17227 ele = doc.createElement("link"); 17228 ele.type = "text/" + (asset.type || "css"); 17229 ele.rel = "stylesheet"; 17230 ele.href = asset.url; 17231 17232 asset.cssRetries = 0; 17233 asset.cssTimeout = window.setTimeout(isCssLoaded, 500); 17234 } 17235 else 17236 { 17237 ele = doc.createElement("script"); 17238 ele.type = "text/" + (asset.type || "javascript"); 17239 ele.src = asset.url; 17240 } 17241 17242 ele.onload = ele.onreadystatechange = process; 17243 ele.onerror = error; 17244 17245 ele.async = false; 17246 ele.defer = false; 17247 17248 asset.errorTimeout = window.setTimeout(function () { 17249 error({type: "timeout"}); 17250 }, 7000); 17251 17252 if (ext === "css") 17253 { 17254 cssList.push(normalizeMinUrl(normalizeUrl(asset.url))); 17255 } 17256 else 17257 { 17258 jsList.push(normalizeMinUrl(normalizeUrl(asset.url))); 17259 } 17260 17261 var templateLink = null; 17262 var head = doc.head || doc.getElementsByTagName("head")[0]; 17263 if (ext === "css" && (templateLink = getTemplateLink(head)) !== null) 17264 { 17265 templateLink.parentNode.insertBefore(ele, templateLink); 17266 } 17267 else 17268 { 17269 head.insertBefore(ele, head.lastChild); 17270 } 17271 } 17272 17273 function getAsset(item) 17274 { 17275 var asset = {}; 17276 if (typeof item === "object") 17277 { 17278 asset = item; 17279 asset.name = asset.name ? asset.name : BX.util.hashCode(item.url); 17280 } 17281 else 17282 { 17283 asset = { name: BX.util.hashCode(item), url : item }; 17284 } 17285 17286 var ext = BX.type.isNotEmptyString(asset.ext) ? asset.ext : BX.util.getExtension(asset.url); 17287 if ((ext === "css" && isCssLoaded(asset.url)) || isScriptLoaded(asset.url)) 17288 { 17289 asset.state = LOADED; 17290 } 17291 17292 var existing = assets[asset.name]; 17293 if (existing && existing.url === asset.url) 17294 { 17295 return existing; 17296 } 17297 17298 assets[asset.name] = asset; 17299 return asset; 17300 } 17301 17302 function normalizeUrl(url) 17303 { 17304 if (!BX.type.isNotEmptyString(url)) 17305 { 17306 return ""; 17307 } 17308 17309 url = BX.getJSPath(url); 17310 url = url.replace(/\?[0-9]*$/, ""); 17311 17312 return url; 17313 } 17314 17315 function normalizeMinUrl(url) 17316 { 17317 if (!BX.type.isNotEmptyString(url)) 17318 { 17319 return ""; 17320 } 17321 17322 var minPos = url.indexOf(".min"); 17323 return minPos >= 0 ? url.substr(0, minPos) + url.substr(minPos + 4) : url; 17324 } 17325 17326 function isCssLoaded(fileSrc) 17327 { 17328 initCssList(); 17329 17330 fileSrc = normalizeUrl(fileSrc); 17331 var fileSrcMin = normalizeMinUrl(fileSrc); 17332 17333 return (fileSrc !== fileSrcMin && BX.util.in_array(fileSrcMin, cssList)) || BX.util.in_array(fileSrc, cssList); 17334 } 17335 17336 function initCssList() 17337 { 17338 if(!cssInit) 17339 { 17340 var linksCol = document.getElementsByTagName('link'); 17341 17342 if(!!linksCol && linksCol.length > 0) 17343 { 17344 for(var i = 0; i < linksCol.length; i++) 17345 { 17346 var href = linksCol[i].getAttribute('href'); 17347 if (BX.type.isNotEmptyString(href)) 17348 { 17349 href = normalizeMinUrl(normalizeUrl(href)); 17350 cssList.push(href); 17351 } 17352 } 17353 } 17354 cssInit = true; 17355 } 17356 } 17357 17358 function getTemplateLink(head) 17359 { 17360 var findLink = function(tag) 17361 { 17362 var links = head.getElementsByTagName(tag); 17363 for (var i = 0, length = links.length; i < length; i++) 17364 { 17365 var templateStyle = links[i].getAttribute("data-template-style"); 17366 if (BX.type.isNotEmptyString(templateStyle) && templateStyle == "true") 17367 { 17368 return links[i]; 17369 } 17370 } 17371 17372 return null; 17373 }; 17374 17375 var link = findLink("link"); 17376 if (link === null) 17377 { 17378 link = findLink("style"); 17379 } 17380 17381 return link; 17382 } 17383 17384 function isScriptLoaded(fileSrc) 17385 { 17386 initJsList(); 17387 17388 fileSrc = normalizeUrl(fileSrc); 17389 var fileSrcMin = normalizeMinUrl(fileSrc); 17390 17391 return (fileSrc !== fileSrcMin && BX.util.in_array(fileSrcMin, jsList)) || BX.util.in_array(fileSrc, jsList); 17392 } 17393 17394 function initJsList() 17395 { 17396 if(!jsInit) 17397 { 17398 var scriptCol = document.getElementsByTagName('script'); 17399 17400 if(!!scriptCol && scriptCol.length > 0) 17401 { 17402 for(var i=0; i<scriptCol.length; i++) 17403 { 17404 var src = scriptCol[i].getAttribute('src'); 17405 17406 if (BX.type.isNotEmptyString(src)) 17407 { 17408 src = normalizeMinUrl(normalizeUrl(src)); 17409 jsList.push(src); 17410 } 17411 } 17412 } 17413 jsInit = true; 17414 } 17415 } 17416 17417 function reloadInternal(back_url, bAddClearCache) 17418 { 17419 if (back_url === true) 17420 { 17421 bAddClearCache = true; 17422 back_url = null; 17423 } 17424 17425 var topWindow = BX.PageObject.getRootWindow(); 17426 var new_href = back_url || topWindow.location.href; 17427 17428 var hashpos = new_href.indexOf('#'), hash = ''; 17429 17430 if (hashpos != -1) 17431 { 17432 hash = new_href.substr(hashpos); 17433 new_href = new_href.substr(0, hashpos); 17434 } 17435 17436 if (bAddClearCache && new_href.indexOf('clear_cache=Y') < 0) 17437 new_href += (new_href.indexOf('?') == -1 ? '?' : '&') + 'clear_cache=Y'; 17438 17439 if (hash) 17440 { 17441 // hack for clearing cache in ajax mode components with history emulation 17442 if (bAddClearCache && (hash.substr(0, 5) == 'view/' || hash.substr(0, 6) == '#view/') && hash.indexOf('clear_cache%3DY') < 0) 17443 hash += (hash.indexOf('%3F') == -1 ? '%3F' : '%26') + 'clear_cache%3DY'; 17444 17445 new_href = new_href.replace(/(\?|\&)_r=[\d]*/, ''); 17446 new_href += (new_href.indexOf('?') == -1 ? '?' : '&') + '_r='+Math.round(Math.random()*10000) + hash; 17447 } 17448 17449 topWindow.location.href = new_href; 17450 } 17451 17452 BX.reload = function(back_url, bAddClearCache) 17453 { 17454 if (window !== window.top) 17455 { 17456 BX.Runtime 17457 .loadExtension('main.pageobject') 17458 .then(function() { 17459 reloadInternal(back_url, bAddClearCache); 17460 }); 17461 } 17462 else 17463 { 17464 reloadInternal(back_url, bAddClearCache); 17465 } 17466 }; 17467 17468 BX.clearCache = function() 17469 { 17470 BX.showWait(); 17471 BX.reload(true); 17472 }; 17473 17474 BX.template = function(tpl, callback, bKillTpl) 17475 { 17476 BX.ready(function() { 17477 _processTpl(BX(tpl), callback, bKillTpl); 17478 }); 17479 }; 17480 17481 BX.isAmPmMode = function(returnConst) 17482 { 17483 if (returnConst === true) 17484 { 17485 return BX.message.AMPM_MODE; 17486 } 17487 return BX.message.AMPM_MODE !== false; 17488 }; 17489 17490 BX.formatDate = function(date, format) 17491 { 17492 date = date || new Date(); 17493 17494 var bTime = date.getHours() || date.getMinutes() || date.getSeconds(), 17495 str = !!format 17496 ? format : 17497 (bTime ? BX.message('FORMAT_DATETIME') : BX.message('FORMAT_DATE') 17498 ); 17499 17500 return str.replace(/YYYY/ig, date.getFullYear()) 17501 .replace(/MMMM/ig, BX.util.str_pad_left((date.getMonth()+1).toString(), 2, '0')) 17502 .replace(/MM/ig, BX.util.str_pad_left((date.getMonth()+1).toString(), 2, '0')) 17503 .replace(/DD/ig, BX.util.str_pad_left(date.getDate().toString(), 2, '0')) 17504 .replace(/HH/ig, BX.util.str_pad_left(date.getHours().toString(), 2, '0')) 17505 .replace(/MI/ig, BX.util.str_pad_left(date.getMinutes().toString(), 2, '0')) 17506 .replace(/SS/ig, BX.util.str_pad_left(date.getSeconds().toString(), 2, '0')); 17507 }; 17508 BX.formatName = function(user, template, login) 17509 { 17510 user = user || {}; 17511 template = (template || ''); 17512 var replacement = { 17513 TITLE : (user["TITLE"] || ''), 17514 NAME : (user["NAME"] || ''),
17515 LAST_NAME : (user["LAST_NAME"] || ''), 17516 SECOND_NAME : (user["SECOND_NAME"] || ''), 17517 LOGIN : (user["LOGIN"] || ''), 17518 NAME_SHORT : user["NAME"] ? user["NAME"].substr(0, 1) + '.' : '', 17519 LAST_NAME_SHORT : user["LAST_NAME"] ? user["LAST_NAME"].substr(0, 1) + '.' : '', 17520 SECOND_NAME_SHORT : user["SECOND_NAME"] ? user["SECOND_NAME"].substr(0, 1) + '.' : '', 17521 EMAIL : (user["EMAIL"] || ''), 17522 ID : (user["ID"] || ''), 17523 NOBR : "", 17524 '/NOBR' : "" 17525 }, result = template; 17526 for (var ii in replacement) 17527 { 17528 if (replacement.hasOwnProperty(ii)) 17529 { 17530 result = result.replace("#" + ii+ "#", replacement[ii]) 17531 } 17532 } 17533 result = result.replace(/([\s]+)/gi, " ").trim(); 17534 if (result == "") 17535 { 17536 result = (login == "Y" ? replacement["LOGIN"] : ""); 17537 result = (result == "" ? "Noname" : result); 17538 } 17539 return result; 17540 }; 17541 17542 BX.getNumMonth = function(month) 17543 { 17544 var wordMonthCut = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec']; 17545 var wordMonth = ['january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december']; 17546 17547 var q = month.toUpperCase(); 17548 for (i = 1; i <= 12; i++) 17549 { 17550 if (q == BX.message('MON_'+i).toUpperCase() || q == BX.message('MONTH_'+i).toUpperCase() || q == wordMonthCut[i-1].toUpperCase() || q == wordMonth[i-1].toUpperCase()) 17551 { 17552 return i; 17553 } 17554 } 17555 return month; 17556 }; 17557 17558 BX.parseDate = function(str, bUTC, formatDate, formatDatetime) 17559 { 17560 if (BX.type.isNotEmptyString(str)) 17561 { 17562 if (!formatDate) 17563 formatDate = BX.message('FORMAT_DATE'); 17564 if (!formatDatetime) 17565 formatDatetime = BX.message('FORMAT_DATETIME'); 17566 17567 var regMonths = ''; 17568 for (i = 1; i <= 12; i++) 17569 { 17570 regMonths = regMonths + '|' + BX.message('MON_'+i); 17571 } 17572
17573 var expr = new RegExp('([0-9]+|[a-z]+' + regMonths + ')', 'ig'); 17574 var aDate = str.match(expr), 17575 aFormat = formatDate.match(/(DD|MI|MMMM|MM|M|YYYY)/ig), 17576 i, cnt, 17577 aDateArgs=[], aFormatArgs=[], 17578 aResult={}; 17579 17580 if (!aDate) 17581 return null; 17582 17583 if(aDate.length > aFormat.length) 17584 { 17585 aFormat = formatDatetime.match(/(DD|MI|MMMM|MM|M|YYYY|HH|H|SS|TT|T|GG|G)/ig); 17586 } 17587 17588 for(i = 0, cnt = aDate.length; i < cnt; i++) 17589 { 17590 if(BX.util.trim(aDate[i]) != '') 17591 { 17592 aDateArgs[aDateArgs.length] = aDate[i]; 17593 } 17594 } 17595 17596 for(i = 0, cnt = aFormat.length; i < cnt; i++) 17597 { 17598 if(BX.util.trim(aFormat[i]) != '') 17599 { 17600 aFormatArgs[aFormatArgs.length] = aFormat[i]; 17601 } 17602 } 17603 17604 17605 var m = BX.util.array_search('MMMM', aFormatArgs); 17606 if (m > 0) 17607 { 17608 aDateArgs[m] = BX.getNumMonth(aDateArgs[m]); 17609 aFormatArgs[m] = "MM"; 17610 } 17611 else 17612 { 17613 m = BX.util.array_search('M', aFormatArgs); 17614 if (m > 0) 17615 { 17616 aDateArgs[m] = BX.getNumMonth(aDateArgs[m]); 17617 aFormatArgs[m] = "MM"; 17618 } 17619 } 17620 17621 for(i = 0, cnt = aFormatArgs.length; i < cnt; i++) 17622 { 17623 var k = aFormatArgs[i].toUpperCase(); 17624 aResult[k] = k == 'T' || k == 'TT' ? aDateArgs[i] : parseInt(aDateArgs[i], 10); 17625 } 17626 17627 if(aResult['DD'] > 0 && aResult['MM'] > 0 && aResult['YYYY'] > 0) 17628 { 17629 var d = new Date(); 17630 17631 if(bUTC) 17632 { 17633 d.setUTCDate(1); 17634 d.setUTCFullYear(aResult['YYYY']); 17635 d.setUTCMonth(aResult['MM'] - 1); 17636 d.setUTCDate(aResult['DD']); 17637 d.setUTCHours(0, 0, 0, 0); 17638 } 17639 else 17640 { 17641 d.setDate(1); 17642 d.setFullYear(aResult['YYYY']); 17643 d.setMonth(aResult['MM'] - 1); 17644 d.setDate(aResult['DD']); 17645 d.setHours(0, 0, 0, 0); 17646 } 17647 17648 if( 17649 (!isNaN(aResult['HH']) || !isNaN(aResult['GG']) || !isNaN(aResult['H']) || !isNaN(aResult['G'])) 17650 && !isNaN(aResult['MI']) 17651 ) 17652 { 17653 if (!isNaN(aResult['H']) || !isNaN(aResult['G'])) 17654 { 17655 var bPM = (aResult['T']||aResult['TT']||'am').toUpperCase()=='PM'; 17656 var h = parseInt(aResult['H']||aResult['G']||0, 10); 17657 if(bPM) 17658 { 17659 aResult['HH'] = h + (h == 12 ? 0 : 12); 17660 } 17661 else 17662 { 17663 aResult['HH'] = h < 12 ? h : 0; 17664 } 17665 } 17666 else 17667 { 17668 aResult['HH'] = parseInt(aResult['HH']||aResult['GG']||0, 10); 17669 } 17670 17671 if (isNaN(aResult['SS'])) 17672 aResult['SS'] = 0; 17673 17674 if(bUTC) 17675 { 17676 d.setUTCHours(aResult['HH'], aResult['MI'], aResult['SS']); 17677 } 17678 else 17679 { 17680 d.setHours(aResult['HH'], aResult['MI'], aResult['SS']); 17681 } 17682 } 17683 17684 return d; 17685 } 17686 } 17687 17688 return null; 17689 }; 17690 17691 BX.selectUtils = 17692 { 17693 addNewOption: function(oSelect, opt_value, opt_name, do_sort, check_unique) 17694 { 17695 oSelect = BX(oSelect); 17696 if(oSelect) 17697 { 17698 var n = oSelect.length; 17699 if(check_unique !== false) 17700 { 17701 for(var i=0;i<n;i++) 17702 { 17703 if(oSelect[i].value==opt_value) 17704 { 17705 return; 17706 } 17707 } 17708 } 17709 17710 oSelect.options[n] = new Option(opt_name, opt_value, false, false); 17711 } 17712 17713 if(do_sort === true) 17714 { 17715 this.sortSelect(oSelect); 17716 } 17717 }, 17718 17719 deleteOption: function(oSelect, opt_value) 17720 { 17721 oSelect = BX(oSelect); 17722 if(oSelect) 17723 { 17724 for(var i=0;i<oSelect.length;i++) 17725 { 17726 if(oSelect[i].value==opt_value) 17727 { 17728 oSelect.remove(i); 17729 break; 17730 } 17731 } 17732 } 17733 }, 17734 17735 deleteSelectedOptions: function(oSelect) 17736 { 17737 oSelect = BX(oSelect); 17738 if(oSelect) 17739 { 17740 var i=0; 17741 while(i<oSelect.length) 17742 { 17743 if(oSelect[i].selected) 17744 { 17745 oSelect[i].selected=false; 17746 oSelect.remove(i); 17747 } 17748 else 17749 { 17750 i++; 17751 } 17752 } 17753 } 17754 }, 17755 17756 deleteAllOptions: function(oSelect) 17757 { 17758 oSelect = BX(oSelect); 17759 if(oSelect) 17760 { 17761 for(var i=oSelect.length-1; i>=0; i--) 17762 { 17763 oSelect.remove(i); 17764 } 17765 } 17766 }, 17767 17768 optionCompare: function(record1, record2) 17769 { 17770 var value1 = record1.optText.toLowerCase(); 17771 var value2 = record2.optText.toLowerCase(); 17772 if (value1 > value2) return(1); 17773 if (value1 < value2) return(-1); 17774 return(0); 17775 }, 17776 17777 sortSelect: function(oSelect) 17778 { 17779 oSelect = BX(oSelect); 17780 if(oSelect) 17781 { 17782 var myOptions = []; 17783 var n = oSelect.options.length; 17784 var i; 17785 for (i=0;i<n;i++) 17786 { 17787 myOptions[i] = { 17788 optText:oSelect[i].text, 17789 optValue:oSelect[i].value 17790 }; 17791 } 17792 myOptions.sort(this.optionCompare); 17793 oSelect.length=0; 17794 n = myOptions.length; 17795 for(i=0;i<n;i++) 17796 { 17797 oSelect[i] = new Option(myOptions[i].optText, myOptions[i].optValue, false, false); 17798 } 17799 } 17800 }, 17801 17802 selectAllOptions: function(oSelect) 17803 { 17804 oSelect = BX(oSelect); 17805 if(oSelect) 17806 { 17807 var n = oSelect.length; 17808 for(var i=0;i<n;i++) 17809 { 17810 oSelect[i].selected=true; 17811 } 17812 } 17813 }, 17814 17815 selectOption: function(oSelect, opt_value) 17816 { 17817 oSelect = BX(oSelect); 17818 if(oSelect) 17819 { 17820 var n = oSelect.length; 17821 for(var i=0;i<n;i++) 17822 { 17823 oSelect[i].selected = (oSelect[i].value == opt_value); 17824 } 17825 } 17826 }, 17827 17828 addSelectedOptions: function(oSelect, to_select_id, check_unique, do_sort) 17829 { 17830 oSelect = BX(oSelect); 17831 if(!oSelect) 17832 return; 17833 var n = oSelect.length; 17834 for(var i=0; i<n; i++) 17835 if(oSelect[i].selected) 17836 this.addNewOption(to_select_id, oSelect[i].value, oSelect[i].text, do_sort, check_unique); 17837 }, 17838 17839 moveOptionsUp: function(oSelect) 17840 { 17841 oSelect = BX(oSelect); 17842 if(!oSelect) 17843 return; 17844 var n = oSelect.length; 17845 for(var i=0; i<n; i++) 17846 { 17847 if(oSelect[i].selected && i>0 && oSelect[i-1].selected == false) 17848 { 17849 var option = new Option(oSelect[i].text, oSelect[i].value); 17850 oSelect[i] = new Option(oSelect[i-1].text, oSelect[i-1].value); 17851 oSelect[i].selected = false;
17852 oSelect[i-1] = option; 17853 oSelect[i-1].selected = true; 17854 } 17855 } 17856 }, 17857 17858 moveOptionsDown: function(oSelect) 17859 { 17860 oSelect = BX(oSelect); 17861 if(!oSelect) 17862 return; 17863 var n = oSelect.length; 17864 for(var i=n-1; i>=0; i--) 17865 { 17866 if(oSelect[i].selected && i<n-1 && oSelect[i+1].selected == false) 17867 { 17868 var option = new Option(oSelect[i].text, oSelect[i].value); 17869 oSelect[i] = new Option(oSelect[i+1].text, oSelect[i+1].value); 17870 oSelect[i].selected = false; 17871 oSelect[i+1] = option; 17872 oSelect[i+1].selected = true; 17873 } 17874 } 17875 } 17876 }; 17877 17878 BX.getEventTarget = function(e) 17879 { 17880 if(e.target) 17881 { 17882 return e.target; 17883 } 17884 else if(e.srcElement) 17885 { 17886 return e.srcElement; 17887 } 17888 return null; 17889 }; 17890 17891 /******* HINT ***************/ 17892// if function has 2 params - the 2nd one is hint html. otherwise hint_html is third and hint_title - 2nd; 17893// '<div onmouseover="BX.hint(this, 'This is <b>Hint</b>')"'>; 17894// BX.hint(el, 'This is <b>Hint</b>') - this won't work, use constructor 17895 BX.hint = function(el, hint_title, hint_html, hint_id) 17896 { 17897 if (null == hint_html) 17898 { 17899 hint_html = hint_title; 17900 hint_title = ''; 17901 } 17902 17903 if (null == el.BXHINT) 17904 { 17905 el.BXHINT = new BX.CHint({ 17906 parent: el, hint: hint_html, title: hint_title, id: hint_id 17907 }); 17908 el.BXHINT.Show(); 17909 } 17910 }; 17911 17912 BX.hint_replace = function(el, hint_title, hint_html) 17913 { 17914 if (null == hint_html) 17915 { 17916 hint_html = hint_title; 17917 hint_title = ''; 17918 } 17919 17920 if (!el || !el.parentNode || !hint_html) 17921 return null; 17922 17923 var obHint = new BX.CHint({ 17924 hint: hint_html, 17925 title: hint_title 17926 }); 17927 17928 obHint.CreateParent(); 17929 17930 el.parentNode.insertBefore(obHint.PARENT, el); 17931 el.parentNode.removeChild(el); 17932 17933 obHint.PARENT.style.marginLeft = '5px'; 17934 17935 return el; 17936 }; 17937 17938 BX.CHint = function(params) 17939 { 17940 this.PARENT = BX(params.parent); 17941 17942 this.HINT = params.hint; 17943 this.HINT_TITLE = params.title; 17944 17945 this.PARAMS = {}; 17946 for (var i in this.defaultSettings) 17947 { 17948 if (null == params[i]) 17949 this.PARAMS[i] = this.defaultSettings[i]; 17950 else 17951 this.PARAMS[i] = params[i]; 17952 } 17953 17954 if (null != params.id) 17955 this.ID = params.id; 17956 17957 this.timer = null; 17958 this.bInited = false; 17959 this.msover = true; 17960 17961 if (this.PARAMS.showOnce) 17962 { 17963 this.__show(); 17964 this.msover = false; 17965 this.timer = setTimeout(BX.proxy(this.__hide, this), this.PARAMS.hide_timeout); 17966 } 17967 else if (this.PARENT) 17968 { 17969 BX.bind(this.PARENT, 'mouseover', BX.proxy(this.Show, this)); 17970 BX.bind(this.PARENT, 'mouseout', BX.proxy(this.Hide, this)); 17971 } 17972 }; 17973 17974 BX.CHint.openHints = new Set(); 17975 17976 BX.CHint.globalDisabled = false; 17977 17978 BX.CHint.handleMenuOpen = function() { 17979 BX.CHint.globalDisabled = true; 17980 17981 BX.CHint.openHints.forEach(function(hint) { 17982 hint.__hide_immediately(); 17983 }); 17984 }; 17985 17986 BX.CHint.handleMenuClose = function() { 17987 BX.CHint.globalDisabled = false; 17988 }; 17989 17990 BX.addCustomEvent('onMenuOpen', BX.CHint.handleMenuOpen); 17991 BX.addCustomEvent('onMenuClose', BX.CHint.handleMenuClose); 17992 17993 BX.CHint.prototype.defaultSettings = { 17994 show_timeout: 1000, 17995 hide_timeout: 500, 17996 dx: 2, 17997 showOnce: false, 17998 preventHide: true, 17999 min_width: 250 18000 }; 18001 18002 BX.CHint.prototype.CreateParent = function(element, params) 18003 { 18004 if (this.PARENT) 18005 { 18006 BX.unbind(this.PARENT, 'mouseover', BX.proxy(this.Show, this)); 18007 BX.unbind(this.PARENT, 'mouseout', BX.proxy(this.Hide, this)); 18008 } 18009 18010 if (!params) params = {}; 18011 var type = 'icon'; 18012 18013 if (params.type && (params.type == "link" || params.type == "icon")) 18014 type = params.type; 18015 18016 if (element) 18017 type = "element"; 18018 18019 if (type == "icon") 18020 { 18021 element = BX.create('IMG', { 18022 props: { 18023 src: params.iconSrc 18024 ? params.iconSrc 18025 : "/bitrix/js/main/core/images/hint.gif" 18026 } 18027 }); 18028 } 18029 else if (type == "link") 18030 { 18031 element = BX.create("A", { 18032 props: {href: 'javascript:void(0)'}, 18033 html: '[?]' 18034 }); 18035 } 18036 18037 this.PARENT = element; 18038 18039 BX.bind(this.PARENT, 'mouseover', BX.proxy(this.Show, this)); 18040 BX.bind(this.PARENT, 'mouseout', BX.proxy(this.Hide, this)); 18041 18042 return this.PARENT; 18043 }; 18044 18045 BX.CHint.prototype.Show = function() 18046 { 18047 this.msover = true; 18048 18049 if (null != this.timer) 18050 clearTimeout(this.timer); 18051 18052 this.timer = setTimeout(BX.proxy(this.__show, this), this.PARAMS.show_timeout); 18053 }; 18054 18055 BX.CHint.prototype.Hide = function() 18056 { 18057 this.msover = false;
18058 18059 if (null != this.timer) 18060 clearTimeout(this.timer); 18061 18062 this.timer = setTimeout(BX.proxy(this.__hide, this), this.PARAMS.hide_timeout); 18063 }; 18064 18065 BX.CHint.prototype.__show = function() 18066 { 18067 if (!this.msover || this.disabled || BX.CHint.globalDisabled) return; 18068 if (!this.bInited) this.Init(); 18069 18070 if (this.prepareAdjustPos()) 18071 { 18072 this.DIV.style.display = 'block'; 18073 this.adjustPos(); 18074 18075 BX.CHint.openHints.add(this); 18076 18077 BX.bind(window, 'scroll', BX.proxy(this.__onscroll, this)); 18078 18079 if (this.PARAMS.showOnce) 18080 { 18081 this.timer = setTimeout(BX.proxy(this.__hide, this), this.PARAMS.hide_timeout); 18082 } 18083 } 18084 }; 18085 18086 BX.CHint.prototype.__onscroll = function() 18087 { 18088 if (!BX.admin || !BX.admin.panel || !BX.admin.panel.isFixed()) return; 18089 18090 if (this.scrollTimer) clearTimeout(this.scrollTimer); 18091 18092 this.DIV.style.display = 'none'; 18093 this.scrollTimer = setTimeout(BX.proxy(this.Reopen, this), this.PARAMS.show_timeout); 18094 }; 18095 18096 BX.CHint.prototype.Reopen = function() 18097 { 18098 if (null != this.timer) clearTimeout(this.timer); 18099 this.timer = setTimeout(BX.proxy(this.__show, this), 50); 18100 }; 18101 18102 BX.CHint.prototype.__hide = function() 18103 { 18104 if (this.msover) return; 18105 if (!this.bInited) return; 18106 18107 BX.unbind(window, 'scroll', BX.proxy(this.Reopen, this)); 18108 18109 BX.CHint.openHints.delete(this); 18110 18111 if (this.PARAMS.showOnce) 18112 { 18113 this.Destroy(); 18114 } 18115 else 18116 { 18117 this.DIV.style.display = 'none'; 18118 } 18119 }; 18120 18121 BX.CHint.prototype.__hide_immediately = function() 18122 { 18123 this.msover = false; 18124 this.__hide(); 18125 }; 18126 18127 BX.CHint.prototype.Init = function() 18128 { 18129 this.DIV = document.body.appendChild(BX.create('DIV', { 18130 props: {className: 'bx-panel-tooltip'}, 18131 style: {display: 'none'}, 18132 children: [ 18133 BX.create('DIV', { 18134 props: {className: 'bx-panel-tooltip-top-border'}, 18135 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>' 18136 }), 18137 (this.CONTENT = BX.create('DIV', { 18138 props: {className: 'bx-panel-tooltip-content'}, 18139 children: [ 18140 BX.create('DIV', { 18141 props: {className: 'bx-panel-tooltip-underlay'}, 18142 children: [ 18143 BX.create('DIV', {props: {className: 'bx-panel-tooltip-underlay-bg'}}) 18144 ] 18145 }) 18146 ] 18147 })), 18148 18149 BX.create('DIV', { 18150 props: {className: 'bx-panel-tooltip-bottom-border'}, 18151 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>' 18152 }) 18153 ] 18154 })); 18155 18156 if (this.ID) 18157 { 18158 this.CONTENT.insertBefore(BX.create('A', { 18159 attrs: {href: 'javascript:void(0)'}, 18160 props: {className: 'bx-panel-tooltip-close'}, 18161 events: {click: BX.delegate(this.Close, this)} 18162 }), this.CONTENT.firstChild) 18163 } 18164 18165 if (this.HINT_TITLE) 18166 { 18167 this.CONTENT.appendChild( 18168 BX.create('DIV', { 18169 props: {className: 'bx-panel-tooltip-title'}, 18170 text: this.HINT_TITLE 18171 }) 18172 ) 18173 } 18174 18175 if (this.HINT) 18176 { 18177 this.CONTENT_TEXT = this.CONTENT.appendChild(BX.create('DIV', {props: {className: 'bx-panel-tooltip-text'}})).appendChild(BX.create('SPAN', {html: this.HINT})); 18178 } 18179 18180 if (this.PARAMS.preventHide) 18181 { 18182 BX.bind(this.DIV, 'mouseout', BX.proxy(this.Hide, this)); 18183 BX.bind(this.DIV, 'mouseover', BX.proxy(this.Show, this)); 18184 } 18185 18186 this.bInited = true; 18187 }; 18188 18189 BX.CHint.prototype.setContent = function(content) 18190 { 18191 this.HINT = content; 18192 18193 if (this.CONTENT_TEXT) 18194 this.CONTENT_TEXT.innerHTML = this.HINT; 18195 else 18196 this.CONTENT_TEXT = this.CONTENT.appendChild(BX.create('DIV', {props: {className: 'bx-panel-tooltip-text'}})).appendChild(BX.create('SPAN', {html: this.HINT})); 18197 }; 18198 18199 BX.CHint.prototype.prepareAdjustPos = function() 18200 { 18201 this._wnd = {scrollPos: BX.GetWindowScrollPos(),scrollSize:BX.GetWindowScrollSize()}; 18202 return BX.style(this.PARENT, 'display') != 'none'; 18203 }; 18204 18205 BX.CHint.prototype.getAdjustPos = function() 18206 { 18207 var res = {}, pos = BX.pos(this.PARENT), min_top = 0; 18208 18209 res.top = pos.bottom + this.PARAMS.dx; 18210 18211 if (BX.admin && BX.admin.panel.DIV) 18212 { 18213 min_top = BX.admin.panel.DIV.offsetHeight + this.PARAMS.dx; 18214 18215 if (BX.admin.panel.isFixed()) 18216 { 18217 min_top += this._wnd.scrollPos.scrollTop; 18218 } 18219 } 18220 18221 if (res.top < min_top) 18222 res.top = min_top; 18223 else 18224 { 18225 if (res.top + this.DIV.offsetHeight > this._wnd.scrollSize.scrollHeight) 18226 res.top = pos.top - this.PARAMS.dx - this.DIV.offsetHeight; 18227 } 18228 18229 res.left = pos.left; 18230 if (pos.left < this.PARAMS.dx) 18231 pos.left = this.PARAMS.dx; 18232 else 18233 { 18234 var floatWidth = this.DIV.offsetWidth; 18235 18236 var max_left = this._wnd.scrollSize.scrollWidth - floatWidth - this.PARAMS.dx; 18237 18238 if (res.left > max_left) 18239 res.left = max_left; 18240 } 18241 18242 return res; 18243 }; 18244 18245 BX.CHint.prototype.adjustWidth = function() 18246 { 18247 if (this.bWidthAdjusted) return; 18248 18249 var w = this.DIV.offsetWidth, h = this.DIV.offsetHeight; 18250 18251 if (w > this.PARAMS.min_width) 18252 w = Math.round(Math.sqrt(1.618*w*h)); 18253 18254 if (w < this.PARAMS.min_width) 18255 w = this.PARAMS.min_width; 18256 18257 this.DIV.style.width = w + "px"; 18258 18259 if (this._adjustWidthInt) 18260 clearInterval(this._adjustWidthInt); 18261 this._adjustWidthInt = setInterval(BX.delegate(this._adjustWidthInterval, this), 5); 18262 18263 this.bWidthAdjusted = true; 18264 }; 18265 18266 BX.CHint.prototype._adjustWidthInterval = function() 18267 { 18268 if (!this.DIV || this.DIV.style.display == 'none') 18269 clearInterval(this._adjustWidthInt); 18270 18271 var
18272 dW = 20, 18273 maxWidth = 1500, 18274 w = this.DIV.offsetWidth, 18275 w1 = this.CONTENT_TEXT.offsetWidth; 18276 18277 if (w > 0 && w1 > 0 && w - w1 < dW && w < maxWidth) 18278 { 18279 this.DIV.style.width = (w + dW) + "px"; 18280 return; 18281 } 18282 18283 clearInterval(this._adjustWidthInt); 18284 }; 18285 18286 BX.CHint.prototype.adjustPos = function() 18287 { 18288 this.adjustWidth(); 18289 18290 var pos = this.getAdjustPos(); 18291 18292 this.DIV.style.top = pos.top + 'px'; 18293 this.DIV.style.left = pos.left + 'px'; 18294 }; 18295 18296 BX.CHint.prototype.Close = function() 18297 { 18298 if (this.ID && BX.WindowManager) 18299 BX.WindowManager.saveWindowOptions(this.ID, {display: 'off'}); 18300 this.__hide_immediately(); 18301 this.Destroy(); 18302 }; 18303 18304 BX.CHint.prototype.Destroy = function() 18305 { 18306 if (this.PARENT) 18307 { 18308 BX.unbind(this.PARENT, 'mouseover', BX.proxy(this.Show, this)); 18309 BX.unbind(this.PARENT, 'mouseout', BX.proxy(this.Hide, this)); 18310 } 18311 18312 if (this.DIV) 18313 { 18314 BX.unbind(this.DIV, 'mouseover', BX.proxy(this.Show, this)); 18315 BX.unbind(this.DIV, 'mouseout', BX.proxy(this.Hide, this)); 18316 18317 BX.cleanNode(this.DIV, true); 18318 } 18319 }; 18320 18321 BX.CHint.prototype.enable = function(){this.disabled = false;}; 18322 BX.CHint.prototype.disable = function(){this.__hide_immediately(); this.disabled = true;}; 18323 18324 18325 function _adjustWait() 18326 { 18327 if (!this.bxmsg) return; 18328 18329 var arContainerPos = BX.pos(this), 18330 div_top = arContainerPos.top; 18331 18332 if (div_top < BX.GetDocElement().scrollTop) 18333 div_top = BX.GetDocElement().scrollTop + 5; 18334 18335 this.bxmsg.style.top = (div_top + 5) + 'px'; 18336 18337 if (this == BX.GetDocElement()) 18338 { 18339 this.bxmsg.style.right = '5px'; 18340 } 18341 else 18342 { 18343 this.bxmsg.style.left = (arContainerPos.right - this.bxmsg.offsetWidth - 5) + 'px'; 18344 } 18345 } 18346 18347 function _processTpl(tplNode, cb, bKillTpl) 18348 { 18349 if (tplNode) 18350 { 18351 if (bKillTpl) 18352 tplNode.parentNode.removeChild(tplNode); 18353 18354 var res = {}, nodes = BX.findChildren(tplNode, {attribute: 'data-role'}, true); 18355 18356 for (var i = 0, l = nodes.length; i < l; i++) 18357 { 18358 res[nodes[i].getAttribute('data-role')] = nodes[i]; 18359 } 18360 18361 cb.apply(tplNode, [res]); 18362 } 18363 } 18364 18365 function _checkNode(obj, params) 18366 { 18367 params = params || {}; 18368 18369 if (BX.type.isFunction(params)) 18370 return params.call(window, obj); 18371 18372 if (!params.allowTextNodes && !BX.type.isElementNode(obj)) 18373 return false; 18374 var i,j,len; 18375 for (i in params) 18376 { 18377 if(params.hasOwnProperty(i)) 18378 { 18379 switch(i) 18380 { 18381 case 'tag': 18382 case 'tagName': 18383 if (BX.type.isString(params[i])) 18384 { 18385 if (obj.tagName.toUpperCase() != params[i].toUpperCase()) 18386 return false; 18387 } 18388 else if (params[i] instanceof RegExp) 18389 { 18390 if (!params[i].test(obj.tagName)) 18391 return false; 18392 } 18393 break; 18394 18395 case 'class': 18396 case 'className': 18397 if (BX.type.isString(params[i])) 18398 { 18399 if (!BX.hasClass(obj, params[i])) 18400 return false; 18401 } 18402 else if (params[i] instanceof RegExp) 18403 { 18404 if (!BX.type.isString(obj.className) || !params[i].test(obj.className)) 18405 return false; 18406 } 18407 break; 18408 18409 case 'attr': 18410 case 'attrs': 18411 case 'attribute': 18412 if (BX.type.isString(params[i])) 18413 { 18414 if (!obj.getAttribute(params[i])) 18415 return false; 18416 } 18417 else if (BX.type.isArray(params[i])) 18418 { 18419 for (j = 0, len = params[i].length; j < len; j++) 18420 { 18421 if (params[i] && !obj.getAttribute(params[i])) 18422 return false; 18423 } 18424 } 18425 else 18426 { 18427 for (j in params[i]) 18428 { 18429 if(params[i].hasOwnProperty(j)) 18430 { 18431 var q = obj.getAttribute(j); 18432 if (params[i][j] instanceof RegExp) 18433 { 18434 if (!BX.type.isString(q) || !params[i][j].test(q)) 18435 { 18436 return false; 18437 } 18438 } 18439 else 18440 { 18441 if (q != '' + params[i][j]) 18442 { 18443 return false; 18444 } 18445 } 18446 } 18447 } 18448 } 18449 break; 18450 18451 case 'property': 18452 case 'props': 18453 if (BX.type.isString(params[i])) 18454 { 18455 if (!obj[params[i]]) 18456 return false; 18457 } 18458 else if (BX.type.isArray(params[i])) 18459 { 18460 for (j = 0, len = params[i].length; j < len; j++) 18461 { 18462 if (params[i] && !obj[params[i]]) 18463 return false;
18464 } 18465 } 18466 else 18467 { 18468 for (j in params[i]) 18469 { 18470 if (BX.type.isString(params[i][j])) 18471 { 18472 if (obj[j] != params[i][j]) 18473 return false; 18474 } 18475 else if (params[i][j] instanceof RegExp) 18476 { 18477 if (!BX.type.isString(obj[j]) || !params[i][j].test(obj[j])) 18478 return false; 18479 } 18480 } 18481 } 18482 break; 18483 18484 case 'callback': 18485 return params[i](obj); 18486 } 18487 } 18488 } 18489 18490 return true; 18491 } 18492 18493 /* garbage collector */ 18494 function Trash() 18495 { 18496 var i,len; 18497 18498 for (i = 0, len = garbageCollectors.length; i<len; i++) 18499 { 18500 try { 18501 garbageCollectors[i].callback.apply(garbageCollectors[i].context || window); 18502 delete garbageCollectors[i]; 18503 garbageCollectors[i] = null; 18504 } catch (e) {} 18505 } 18506 } 18507 18508 if(window.attachEvent) // IE 18509 window.attachEvent("onunload", Trash); 18510 else if(window.addEventListener) // Gecko / W3C 18511 window.addEventListener('unload', Trash, false); 18512 else 18513 window.onunload = Trash; 18514 /* \garbage collector */ 18515 18516// set empty ready handler 18517 BX(BX.DoNothing); 18518 window.BX = BX; 18519 18520 BX.browser.addGlobalClass(); 18521 18522 /* data storage */ 18523 BX.data = function(node, key, value) 18524 { 18525 if(typeof node == 'undefined') 18526 return undefined; 18527 18528 if(typeof key == 'undefined') 18529 return undefined; 18530 18531 if(typeof value != 'undefined') 18532 { 18533 // write to manager 18534 dataStorage.set(node, key, value); 18535 } 18536 else 18537 { 18538 var data; 18539 18540 // from manager 18541 if((data = dataStorage.get(node, key)) != undefined) 18542 { 18543 return data; 18544 } 18545 else 18546 { 18547 // from attribute data-* 18548 if('getAttribute' in node) 18549 { 18550 data = node.getAttribute('data-'+key.toString()); 18551 if(data === null) 18552 { 18553 return undefined; 18554 } 18555 return data; 18556 } 18557 } 18558 18559 return undefined; 18560 } 18561 }; 18562 18563 BX.DataStorage = function() 18564 { 18565 18566 this.keyOffset = 1; 18567 this.data = {}; 18568 this.uniqueTag = 'BX-'+Math.random(); 18569 18570 this.resolve = function(owner, create){ 18571 if(typeof owner[this.uniqueTag] == 'undefined') 18572 if(create) 18573 { 18574 try 18575 { 18576 Object.defineProperty(owner, this.uniqueTag, { 18577 value: this.keyOffset++ 18578 }); 18579 } 18580 catch(e) 18581 { 18582 owner[this.uniqueTag] = this.keyOffset++; 18583 } 18584 } 18585 else 18586 return undefined; 18587 18588 return owner[this.uniqueTag]; 18589 }; 18590 this.get = function(owner, key){ 18591 if((owner != document && !BX.type.isElementNode(owner)) || typeof key == 'undefined') 18592 return undefined; 18593 18594 owner = this.resolve(owner, false); 18595 18596 if(typeof owner == 'undefined' || typeof this.data[owner] == 'undefined') 18597 return undefined; 18598 18599 return this.data[owner][key]; 18600 }; 18601 this.set = function(owner, key, value){ 18602 18603 if((owner != document && !BX.type.isElementNode(owner)) || typeof value == 'undefined') 18604 return; 18605 18606 var o = this.resolve(owner, true); 18607 18608 if(typeof this.data[o] == 'undefined') 18609 this.data[o] = {}; 18610 18611 this.data[o][key] = value; 18612 }; 18613 }; 18614 18615// some internal variables for new logic 18616 var dataStorage = new BX.DataStorage(); // manager which BX.data() uses to keep data 18617})(window.BX); 18618 18619;(function(window) 18620{ 18621 /****************** ATTENTION ******************************* 18622 * Please do not use Bitrix CoreJS in this class. 18623 * This class can be called on page without Bitrix Framework 18624 *************************************************************/ 18625 18626 if (!window.BX) 18627 { 18628 window.BX = {}; 18629 } 18630 18631 var BX = window.BX; 18632 18633 BX.Promise = function(fn, ctx) // fn is future-reserved 18634 { 18635 this.state = null; 18636 this.value = null; 18637 this.reason = null; 18638 this.next = null; 18639 this.ctx = ctx || this; 18640 18641 this.onFulfilled = []; 18642 this.onRejected = []; 18643 }; 18644 BX.Promise.prototype.fulfill = function(value) 18645 { 18646 this.checkState(); 18647 18648 this.value = value; 18649 this.state = true; 18650 this.execute(); 18651 }; 18652 BX.Promise.prototype.reject = function(reason) 18653 { 18654 this.checkState(); 18655 18656 this.reason = reason; 18657 this.state = false; 18658 this.execute(); 18659 }; 18660 BX.Promise.prototype.then = function(onFulfilled, onRejected) 18661 { 18662 if(typeof (onFulfilled) == "function" || onFulfilled instanceof Function) 18663 { 18664 this.onFulfilled.push(onFulfilled); 18665 } 18666 if(typeof (onRejected) == "function" || onRejected instanceof Function) 18667 { 18668 this.onRejected.push(onRejected); 18669 } 18670 18671 if(this.next === null) 18672 { 18673 this.next = new BX.Promise(null, this.ctx); 18674 } 18675 18676 if(this.state !== null) // if promise was already resolved, execute immediately 18677 { 18678 this.execute(); 18679 } 18680 18681 return this.next; 18682 }; 18683 18684 BX.Promise.prototype.catch = function(onRejected) 18685 { 18686 if(typeof (onRejected) == "function" || onRejected instanceof Function) 18687 { 18688 this.onRejected.push(onRejected); 18689 } 18690 18691 if(this.next === null) 18692 { 18693 this.next = new BX.Promise(null, this.ctx); 18694 } 18695 18696 if(this.state !== null) // if promise was already resolved, execute immediately 18697 { 18698 this.execute(); 18699 } 18700 18701 return this.next; 18702 }; 18703 18704 BX.Promise.prototype.setAutoResolve = function(way, ms) 18705 { 18706 this.timer = setTimeout(function(){ 18707 if(this.state === null) 18708 { 18709 this[way ? 'fulfill' : 'reject'](); 18710 } 18711 }.bind(this), ms || 15); 18712 };
18713 BX.Promise.prototype.cancelAutoResolve = function() 18714 { 18715 clearTimeout(this.timer); 18716 }; 18717 /** 18718 * Resolve function. This function allows promise chaining, like ..then().then()... 18719 * Typical usage: 18720 * 18721 * var p = new Promise(); 18722 * 18723 * p.then(function(value){ 18724 * return someValue; // next promise in the chain will be fulfilled with someValue 18725 * }).then(function(value){ 18726 * 18727 * var p1 = new Promise(); 18728 * *** some async code here, that eventually resolves p1 *** 18729 * 18730 * return p1; // chain will resume when p1 resolved (fulfilled or rejected) 18731 * }).then(function(value){ 18732 * 18733 * // you can also do 18734 * var e = new Error(); 18735 * throw e; 18736 * // it will cause next promise to be rejected with e 18737 * 18738 * return someOtherValue; 18739 * }).then(function(value){ 18740 * ... 18741 * }, function(reason){ 18742 * // promise was rejected with reason 18743 * })...; 18744 * 18745 * p.fulfill('let`s start this chain'); 18746 * 18747 * @param x 18748 */ 18749 BX.Promise.prototype.resolve = function(x) 18750 { 18751 var this_ = this; 18752 18753 if(this === x) 18754 { 18755 this.reject(new TypeError('Promise cannot fulfill or reject itself')); // avoid recursion 18756 } 18757 // allow "pausing" promise chaining until promise x is fulfilled or rejected 18758 else if(x && x.toString() === "[object BX.Promise]") 18759 { 18760 x.then(function(value){ 18761 this_.fulfill(value); 18762 }, function(reason){ 18763 this_.reject(reason); 18764 }); 18765 } 18766 else // auto-fulfill this promise 18767 { 18768 this.fulfill(x); 18769 } 18770 }; 18771 18772 BX.Promise.prototype.toString = function() 18773 { 18774 return "[object BX.Promise]"; 18775 }; 18776 18777 BX.Promise.prototype.execute = function() 18778 { 18779 if(this.state === null) 18780 { 18781 //then() must not be called before BX.Promise resolve() happens 18782 return; 18783 } 18784 18785 var value = undefined; 18786 var reason = undefined; 18787 var x = undefined; 18788 var k; 18789 if(this.state === true) // promise was fulfill()-ed 18790 { 18791 if(this.onFulfilled.length) 18792 { 18793 try 18794 { 18795 for(k = 0; k < this.onFulfilled.length; k++) 18796 {
18797 x = this.onFulfilled[k].apply(this.ctx, [this.value]); 18798 if(typeof x != 'undefined') 18799 { 18800 value = x; 18801 } 18802 } 18803 } 18804 catch(e) 18805 { 18806 if('console' in window) 18807 { 18808 console.dir(e); 18809 } 18810 18811 if (typeof BX.debug !== 'undefined') 18812 { 18813 BX.debug(e); 18814 } 18815 18816 reason = e; // reject next 18817 } 18818 } 18819 else 18820 { 18821 value = this.value; // resolve next 18822 } 18823 } 18824 else if(this.state === false) // promise was reject()-ed 18825 { 18826 if(this.onRejected.length) 18827 { 18828 try 18829 { 18830 for(k = 0; k < this.onRejected.length; k++) 18831 { 18832 x = this.onRejected[k].apply(this.ctx, [this.reason]); 18833 if(typeof x != 'undefined') 18834 { 18835 value = x; 18836 } 18837 } 18838 } 18839 catch(e) 18840 { 18841 if('console' in window) 18842 { 18843 console.dir(e); 18844 } 18845 18846 if (typeof BX.debug !== 'undefined') 18847 { 18848 BX.debug(e); 18849 } 18850 18851 reason = e; // reject next 18852 } 18853 } 18854 else 18855 { 18856 reason = this.reason; // reject next 18857 } 18858 } 18859 18860 if(this.next !== null) 18861 { 18862 if(typeof reason != 'undefined') 18863 { 18864 this.next.reject(reason); 18865 } 18866 else if(typeof value != 'undefined') 18867 { 18868 this.next.resolve(value); 18869 } 18870 } 18871 }; 18872 BX.Promise.prototype.checkState = function() 18873 { 18874 if(this.state !== null) 18875 { 18876 throw new Error('You can not do fulfill() or reject() multiple times'); 18877 } 18878 }; 18879})(window); 18880 18881 18882 18883;(function(window){ 18884 18885if (window.BX.ajax) 18886 return; 18887 18888var 18889 BX = window.BX, 18890 18891 tempDefaultConfig = {}, 18892 defaultConfig = { 18893 method: 'GET', // request method: GET|POST 18894 dataType: 'html', // type of data loading: html|json|script 18895 timeout: 0, // request timeout in seconds. 0 for browser-default 18896 async: true, // whether request is asynchronous or not 18897 processData: true, // any data processing is disabled if false, only callback call 18898 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 18899 emulateOnload: true, 18900 skipAuthCheck: false, // whether to check authorization failure (SHOUD be set to true for CORS requests) 18901 start: true, // send request immediately (if false, request can be started manually via XMLHttpRequest object returned) 18902 cache: true, // whether NOT to add random addition to URL 18903 preparePost: true, // whether set Content-Type x-www-form-urlencoded in POST 18904 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'}] 18905 lsTimeout: 30, //local storage data TTL. useless without lsId. 18906 lsForce: false //wheter to force query instead of using localStorage data. useless without lsId. 18907/* 18908other parameters: 18909 url: url to get/post 18910 data: data to post 18911 onsuccess: successful request callback. BX.proxy may be used. 18912 onfailure: request failure callback. BX.proxy may be used. 18913 onprogress: request progress callback. BX.proxy may be used. 18914 18915 lsId: local storage id - for constantly updating queries which can communicate via localStorage. core_ls.js needed 18916 18917any of the default parameters can be overridden. defaults can be changed by BX.ajax.Setup() - for all further requests! 18918*/ 18919 }, 18920 ajax_session = null, 18921 loadedScripts = {}, 18922 loadedScriptsQueue = [], 18923 r = { 18924 'url_utf': /[^\034-\254]+/g, 18925 'script_self': /\/bitrix\/js\/main\/core\/core(_ajax)*.js$/i, 18926 'script_self_window': /\/bitrix\/js\/main\/core\/core_window.js$/i, 18927 'script_self_admin': /\/bitrix\/js\/main\/core\/core_admin.js$/i, 18928 'script_onload': /window.onload/g 18929 }; 18930 18931// low-level method 18932BX.ajax = function(config) 18933{ 18934 var status, data; 18935
18936 if (!config || !config.url || !BX.type.isString(config.url)) 18937 { 18938 return false; 18939 } 18940 18941 for (var i in tempDefaultConfig) 18942 if (typeof (config[i]) == "undefined") config[i] = tempDefaultConfig[i]; 18943 18944 tempDefaultConfig = {}; 18945 18946 for (i in defaultConfig) 18947 if (typeof (config[i]) == "undefined") config[i] = defaultConfig[i]; 18948 18949 config.method = config.method.toUpperCase(); 18950 18951 if (!BX.localStorage) 18952 config.lsId = null; 18953 18954 if (BX.browser.IsIE()) 18955 { 18956 var result = r.url_utf.exec(config.url); 18957 if (result) 18958 { 18959 do 18960 { 18961 config.url = config.url.replace(result, BX.util.urlencode(result)); 18962 result = r.url_utf.exec(config.url); 18963 } while (result); 18964 } 18965 } 18966 18967 if(config.dataType == 'json') 18968 config.emulateOnload = false; 18969 18970 if (!config.cache && config.method == 'GET') 18971 config.url = BX.ajax._uncache(config.url); 18972 18973 if (config.method == 'POST') 18974 { 18975 if (config.preparePost) 18976 { 18977 config.data = BX.ajax.prepareData(config.data); 18978 } 18979 else if (getLastContentTypeHeader(config.headers) === 'application/json') 18980 { 18981 config.data = JSON.stringify(config.data); 18982 } 18983 } 18984 18985 var bXHR = true; 18986 if (config.lsId && !config.lsForce) 18987 { 18988 var v = BX.localStorage.get('ajax-' + config.lsId); 18989 if (v !== null) 18990 { 18991 bXHR = false; 18992 18993 var lsHandler = function(lsData) { 18994 if (lsData.key == 'ajax-' + config.lsId && lsData.value != 'BXAJAXWAIT') 18995 { 18996 var data = lsData.value, 18997 bRemove = !!lsData.oldValue && data == null; 18998 if (!bRemove) 18999 BX.ajax.__run(config, data); 19000 else if (config.onfailure) 19001 config.onfailure("timeout"); 19002 19003 BX.removeCustomEvent('onLocalStorageChange', lsHandler); 19004 } 19005 }; 19006 19007 if (v == 'BXAJAXWAIT') 19008 { 19009 BX.addCustomEvent('onLocalStorageChange', lsHandler); 19010 } 19011 else 19012 { 19013 setTimeout(function() {lsHandler({key: 'ajax-' + config.lsId, value: v})}, 10); 19014 } 19015 } 19016 } 19017 19018 if (bXHR) 19019 { 19020 config.xhr = BX.ajax.xhr(); 19021 if (!config.xhr) return; 19022 19023 if (config.lsId) 19024 { 19025 BX.localStorage.set('ajax-' + config.lsId, 'BXAJAXWAIT', config.lsTimeout); 19026 } 19027 19028 config.xhr.open(config.method, config.url, config.async); 19029 19030 if (!config.skipBxHeader && !BX.ajax.isCrossDomain(config.url)) 19031 { 19032 config.xhr.setRequestHeader('Bx-ajax', 'true'); 19033 } 19034 19035 if (config.method == 'POST' && config.preparePost) 19036 { 19037 config.xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); 19038 } 19039 if (typeof(config.headers) == "object") 19040 { 19041 for (i = 0; i < config.headers.length; i++) 19042 config.xhr.setRequestHeader(config.headers[i].name, config.headers[i].value); 19043 } 19044 19045 if(!!config.onprogress) 19046 { 19047 BX.bind(config.xhr, 'progress', config.onprogress); 19048 } 19049 19050 var bRequestCompleted = false; 19051 var onreadystatechange = config.xhr.onreadystatechange = function(additional) 19052 { 19053 if (bRequestCompleted) 19054 return; 19055 19056 if (additional === 'timeout') 19057 { 19058 if (config.onfailure) 19059 { 19060 config.onfailure("timeout"); 19061 } 19062 19063 BX.onCustomEvent(config.xhr, 'onAjaxFailure', ['timeout', '', config]); 19064 19065 config.xhr.onreadystatechange = BX.DoNothing; 19066 config.xhr.abort(); 19067 19068 if (config.async) 19069 { 19070 config.xhr = null; 19071 } 19072 } 19073 else 19074 { 19075 if (config.xhr.readyState == 4 || additional == 'run') 19076 { 19077 status = BX.ajax.xhrSuccess(config.xhr) ? "success" : "error"; 19078 bRequestCompleted = true; 19079 config.xhr.onreadystatechange = BX.DoNothing; 19080 19081 if (status == 'success') 19082 { 19083 var authHeader = (!!config.skipAuthCheck || BX.ajax.isCrossDomain(config.url)) 19084 ? false 19085 : config.xhr.getResponseHeader('X-Bitrix-Ajax-Status'); 19086 19087 if(!!authHeader && authHeader == 'Authorize') 19088 { 19089 if (config.onfailure) 19090 { 19091 config.onfailure("auth", config.xhr.status); 19092 } 19093 19094 BX.onCustomEvent(config.xhr, 'onAjaxFailure', ['auth', config.xhr.status, config]); 19095 } 19096 else 19097 { 19098 var data = config.xhr.responseText; 19099 19100 if (config.lsId) 19101 { 19102 BX.localStorage.set('ajax-' + config.lsId, data, config.lsTimeout); 19103 } 19104 19105 BX.ajax.__run(config, data); 19106 } 19107 } 19108 else 19109 { 19110 if (config.onfailure) 19111 { 19112 config.onfailure("status", config.xhr.status); 19113 } 19114 19115 BX.onCustomEvent(config.xhr, 'onAjaxFailure', ['status', config.xhr.status, config]); 19116 } 19117 19118 if (config.async) 19119 { 19120 config.xhr = null; 19121 } 19122 } 19123 } 19124 }; 19125 19126 if (config.async && config.timeout > 0) 19127 { 19128 setTimeout(function() { 19129 if (config.xhr && !bRequestCompleted) 19130 { 19131 onreadystatechange("timeout"); 19132 } 19133 }, config.timeout * 1000); 19134 } 19135 19136 if (config.start) 19137 {
19138 config.xhr.send(config.data); 19139 19140 if (!config.async) 19141 { 19142 onreadystatechange('run'); 19143 } 19144 } 19145 19146 return config.xhr; 19147 } 19148}; 19149 19150BX.ajax.xhr = function() 19151{ 19152 if (window.XMLHttpRequest) 19153 { 19154 try {return new XMLHttpRequest();} catch(e){} 19155 } 19156 else if (window.ActiveXObject) 19157 { 19158 try { return new window.ActiveXObject("Msxml2.XMLHTTP.6.0"); } 19159 catch(e) {} 19160 try { return new window.ActiveXObject("Msxml2.XMLHTTP.3.0"); } 19161 catch(e) {} 19162 try { return new window.ActiveXObject("Msxml2.XMLHTTP"); } 19163 catch(e) {} 19164 try { return new window.ActiveXObject("Microsoft.XMLHTTP"); } 19165 catch(e) {} 19166 throw new Error("This browser does not support XMLHttpRequest."); 19167 } 19168 19169 return null; 19170}; 19171 19172BX.ajax.isCrossDomain = function(url, location) 19173{ 19174 location = location || window.location; 19175 19176 //Relative URL gets a current protocol 19177 if (url.indexOf("//") === 0) 19178 { 19179 url = location.protocol + url; 19180 } 19181 19182 //Fast check 19183 if (url.indexOf("http") !== 0) 19184 { 19185 return false; 19186 } 19187 19188 var link = window.document.createElement("a"); 19189 link.href = url; 19190 19191 return link.protocol !== location.protocol || 19192 link.hostname !== location.hostname || 19193 BX.ajax.getHostPort(link.protocol, link.host) !== BX.ajax.getHostPort(location.protocol, location.host); 19194}; 19195 19196BX.ajax.getHostPort = function(protocol, host) 19197{ 19198 var match = /:(\d+)$/.exec(host); 19199 if (match) 19200 { 19201 return match[1]; 19202 } 19203 else 19204 { 19205 if (protocol === "http:") 19206 { 19207 return "80"; 19208 } 19209 else if (protocol === "https:") 19210 { 19211 return "443"; 19212 } 19213 } 19214 19215 return ""; 19216}; 19217 19218BX.ajax.__prepareOnload = function(scripts) 19219{ 19220 if (scripts.length > 0) 19221 { 19222 BX.ajax['onload_' + ajax_session] = null; 19223 19224 for (var i=0,len=scripts.length;i<len;i++) 19225 { 19226 if (scripts[i].isInternal) 19227 { 19228 scripts[i].JS = scripts[i].JS.replace(r.script_onload, 'BX.aja
19228x.onload_' + ajax_session); 19229 } 19230 } 19231 } 19232 19233 BX.CaptureEventsGet(); 19234 BX.CaptureEvents(window, 'load'); 19235}; 19236 19237BX.ajax.__runOnload = function() 19238{ 19239 if (null != BX.ajax['onload_' + ajax_session]) 19240 { 19241 BX.ajax['onload_' + ajax_session].apply(window); 19242 BX.ajax['onload_' + ajax_session] = null; 19243 } 19244 19245 var h = BX.CaptureEventsGet(); 19246 19247 if (h) 19248 { 19249 for (var i=0; i<h.length; i++) 19250 h[i].apply(window); 19251 } 19252}; 19253 19254BX.ajax.__run = function(config, data) 19255{ 19256 if (!config.processData) 19257 { 19258 if (config.onsuccess) 19259 { 19260 config.onsuccess(data); 19261 } 19262 19263 BX.onCustomEvent(config.xhr, 'onAjaxSuccess', [data, config]); 19264 } 19265 else 19266 { 19267 data = BX.ajax.processRequestData(data, config); 19268 } 19269}; 19270 19271 19272BX.ajax._onParseJSONFailure = function(data) 19273{ 19274 this.jsonFailure = true; 19275 this.jsonResponse = data; 19276 this.jsonProactive = /^\[WAF\]/.test(data); 19277}; 19278 19279BX.ajax.processRequestData = function(data, config) 19280{ 19281 var result, scripts = [], styles = []; 19282 switch (config.dataType.toUpperCase()) 19283 { 19284 case 'JSON': 19285 19286 var context = config.xhr || {}; 19287 BX.addCustomEvent(context, 'onParseJSONFailure', BX.proxy(BX.ajax._onParseJSONFailure, config)); 19288 result = BX.parseJSON(data, context); 19289 BX.removeCustomEvent(context, 'onParseJSONFailure', BX.proxy(BX.ajax._onParseJSONFailure, config)); 19290 19291 if(!!result && BX.type.isArray(result['bxjs'])) 19292 { 19293 for(var i = 0; i < result['bxjs'].length; i++) 19294 { 19295 if(BX.type.isNotEmptyString(result['bxjs'][i])) 19296 { 19297 scripts.push({ 19298 "isInternal": false, 19299 "JS": result['bxjs'][i], 19300 "bRunFirst": config.scriptsRunFirst 19301 }); 19302 } 19303 else 19304 { 19305 scripts.push(result['bxjs'][i]) 19306 } 19307 } 19308 } 19309 19310 if(!!result && BX.type.isArray(result['bxcss'])) 19311 { 19312 styles = result['bxcss']; 19313 } 19314 19315 break; 19316 case 'SCRIPT': 19317 scripts.push({"isInternal": true, "JS": data, "bRunFirst": config.scriptsRunFirst}); 19318 result = data; 19319 break; 19320 19321 default: // HTML 19322 var ob = BX.processHTML(data, config.scriptsRunFirst); 19323 result = ob.HTML; scripts = ob.SCRIPT; styles = ob.STYLE; 19324 break; 19325 } 19326 19327 var bSessionCreated = false; 19328 if (null == ajax_session) 19329 { 19330 ajax_session = parseInt(Math.random() * 1000000); 19331 bSessionCreated = true; 19332 } 19333 19334 if (styles.length > 0) 19335 BX.loadCSS(styles); 19336 19337 if (config.emulateOnload) 19338 BX.ajax.__prepareOnload(scripts); 19339 19340 var cb = BX.DoNothing; 19341 if(config.emulateOnload || bSessionCreated) 19342 { 19343 cb = BX.defer(function() 19344 { 19345 if (config.emulateOnload) 19346 BX.ajax.__runOnload(); 19347 if (bSessionCreated) 19348 ajax_session = null; 19349 BX.onCustomEvent(config.xhr, 'onAjaxSuccessFinish', [config]); 19350 }); 19351 } 19352 19353 try 19354 { 19355 if (!!config.jsonFailure) 19356 { 19357 throw {type: 'json_failure', data: config.jsonResponse, bProactive: config.jsonProactive}; 19358 } 19359 19360 config.scripts = scripts; 19361 19362 BX.ajax.processScripts(config.scripts, true); 19363 19364 if (config.onsuccess) 19365 { 19366 config.onsuccess(result); 19367 } 19368 19369 BX.onCustomEvent(config.xhr, 'onAjaxSuccess', [result, config]); 19370 19371 BX.ajax.processScripts(config.scripts, false, cb); 19372 } 19373 catch (e) 19374 { 19375 if (config.onfailure) 19376 config.onfailure("processing", e); 19377 BX.onCustomEvent(config.xhr, 'onAjaxFailure', ['processing', e, config]); 19378 } 19379}; 19380 19381BX.ajax.processScripts = function(scripts, bRunFirst, cb) 19382{ 19383 var scriptsExt = [], scriptsInt = ''; 19384 19385 cb = cb || BX.DoNothing; 19386 19387 for (var i = 0, length = scripts.length; i < length; i++) 19388 { 19389 if (typeof bRunFirst != 'undefined' && bRunFirst != !!scripts[i].bRunFirst) 19390 continue; 19391 19392 if (scripts[i].isInternal) 19393 scriptsInt += ';' + scripts[i].JS; 19394 else 19395 scriptsExt.push(scripts[i].JS); 19396 } 19397 19398 scriptsExt = BX.util.array_unique(scriptsExt); 19399 var inlineScripts = scriptsInt.length > 0 ? function() { BX.evalGlobal(scriptsInt); } : BX.DoNothing; 19400 19401 if (scriptsExt.length > 0) 19402 { 19403 BX.load(scriptsExt, function() { 19404 inlineScripts(); 19405 cb(); 19406 }); 19407 } 19408 else 19409 { 19410 inlineScripts(); 19411 cb(); 19412 } 19413}; 19414 19415// TODO: extend this function to use with any data objects or forms 19416BX.ajax.prepareData = function(arData, prefix) 19417{ 19418 var data = ''; 19419 if (BX.type.isString(arData)) 19420 data = arData; 19421 else if (null != arData) 19422 { 19423 for(var i in arData) 19424 { 19425 if (arData.hasOwnProperty(i)) 19426 { 19427 if (data.length > 0) 19428 data += '&'; 19429 var name = BX.util.urlencode(i); 19430 if(prefix)
19431 name = prefix + '[' + name + ']'; 19432 if(typeof arData[i] == 'object') 19433 data += BX.ajax.prepareData(arData[i], name); 19434 else 19435 data += name + '=' + BX.util.urlencode(arData[i]); 19436 } 19437 } 19438 } 19439 return data; 19440}; 19441 19442BX.ajax.xhrSuccess = function(xhr) 19443{ 19444 return (xhr.status >= 200 && xhr.status < 300) || xhr.status === 304 || xhr.status === 1223 || xhr.status === 0; 19445}; 19446 19447BX.ajax.Setup = function(config, bTemp) 19448{ 19449 bTemp = !!bTemp; 19450 19451 for (var i in config) 19452 { 19453 if (bTemp) 19454 tempDefaultConfig[i] = config[i]; 19455 else 19456 defaultConfig[i] = config[i]; 19457 } 19458}; 19459 19460BX.ajax.replaceLocalStorageValue = function(lsId, data, ttl) 19461{ 19462 if (!!BX.localStorage) 19463 BX.localStorage.set('ajax-' + lsId, data, ttl); 19464}; 19465 19466 19467BX.ajax._uncache = function(url) 19468{ 19469 return url + ((url.indexOf('?') !== -1 ? "&" : "?") + '_=' + (new Date()).getTime()); 19470}; 19471 19472/* simple interface */ 19473BX.ajax.get = function(url, data, callback) 19474{ 19475 if (BX.type.isFunction(data)) 19476 { 19477 callback = data; 19478 data = ''; 19479 } 19480 19481 data = BX.ajax.prepareData(data); 19482 19483 if (data) 19484 { 19485 url += (url.indexOf('?') !== -1 ? "&" : "?") + data; 19486 data = ''; 19487 } 19488 19489 return BX.ajax({ 19490 'method': 'GET', 19491 'dataType': 'html', 19492 'url': url, 19493 'data': '', 19494 'onsuccess': callback 19495 }); 19496}; 19497 19498BX.ajax.getCaptcha = function(callback) 19499{ 19500 return BX.ajax.loadJSON('/bitrix/tools/ajax_captcha.php', callback); 19501}; 19502 19503BX.ajax.insertToNode = function(url, node) 19504{ 19505 node = BX(node); 19506 if (!!node) 19507 { 19508 var eventArgs = { cancel: false }; 19509 BX.onCustomEvent('onAjaxInsertToNode', [{ url: url, node: node, eventArgs: eventArgs }]); 19510 if(eventArgs.cancel === true) 19511 { 19512 return; 19513 } 19514 19515 var show = null; 19516 if (!tempDefaultConfig.denyShowWait) 19517 { 19518 show = BX.showWait(node); 19519 delete tempDefaultConfig.denyShowWait; 19520 } 19521 19522 return BX.ajax.get(url, function(data) { 19523 node.innerHTML = data; 19524 BX.closeWait(node, show); 19525 }); 19526 } 19527}; 19528 19529BX.ajax.post = function(url, data, callback) 19530{ 19531 data = BX.ajax.prepareData(data); 19532 19533 return BX.ajax({ 19534 'method': 'POST', 19535 'dataType': 'html', 19536 'url': url, 19537 'data': data, 19538 'onsuccess': callback 19539 }); 19540}; 19541 19542/** 19543 * BX.ajax with BX.Promise 19544 * 19545 * @param config 19546 * @returns {BX.Promise|false} 19547 */ 19548BX.ajax.promise = function(config) 19549{ 19550 var result = new BX.Promise(); 19551 19552 config.onsuccess = function(data) 19553 { 19554 result.fulfill(data); 19555 }; 19556 config.onfailure = function(reason, data) 19557 { 19558 result.reject({ 19559 reason: reason, 19560 data: data 19561 }); 19562 }; 19563 config.onprogress = function(data) 19564 { 19565 if (data.position == 0 && data.totalSize == 0) 19566 { 19567 result.reject({ 19568 reason: 'progress', 19569 data: data 19570 }); 19571 } 19572 }; 19573 19574 var xhr = BX.ajax(config); 19575 if (xhr) 19576 { 19577 if (typeof config.onrequeststart === 'function') 19578 { 19579 config.onrequeststart(xhr); 19580 } 19581 } 19582 else 19583 { 19584 result.reject({ 19585 reason: "init", 19586 data: false 19587 }); 19588 } 19589 19590 return result; 19591}; 19592 19593/* load and execute external file script with onload emulation */ 19594BX.ajax.loadScriptAjax = function(script_src, callback, bPreload) 19595{ 19596 if (BX.type.isArray(script_src)) 19597 { 19598 for (var i=0,len=script_src.length;i<len;i++) 19599 { 19600 BX.ajax.loadScriptAjax(script_src[i], callback, bPreload); 19601 } 19602 } 19603 else 19604 { 19605 var script_src_test = script_src.replace(/\.js\?.*/, '.js'); 19606 19607 if (r.script_self.test(script_src_test)) return; 19608 if (r.script_self_window.test(script_src_test) && BX.CWindow) return; 19609 if (r.script_self_admin.test(script_src_test) && BX.admin) return; 19610 19611 if (typeof loadedScripts[script_src_test] == 'undefined') 19612 { 19613 if (!!bPreload) 19614 { 19615 loadedScripts[script_src_test] = ''; 19616 return BX.loadScript(script_src); 19617 } 19618 else 19619 { 19620 return BX.ajax({ 19621 url: script_src, 19622 method: 'GET', 19623 dataType: 'script', 19624 processData: true, 19625 emulateOnload: false, 19626 scriptsRunFirst: true, 19627 async: false, 19628 start: true, 19629 onsuccess: function(result) { 19630 loadedScripts[script_src_test] = result; 19631 if (callback) 19632 callback(result); 19633 } 19634 }); 19635 } 19636 } 19637 else if (callback) 19638 { 19639 callback(loadedScripts[script_src_test]); 19640 } 19641 } 19642}; 19643 19644/* non-xhr loadings */ 19645BX.ajax.loadJSON = function(url, data, callback, callback_failure) 19646{ 19647 if (BX.type.isFunction(data)) 19648 { 19649 callback_failure = callback; 19650 callback = data; 19651 data = ''; 19652 } 19653
19654 data = BX.ajax.prepareData(data); 19655 19656 if (data) 19657 { 19658 url += (url.indexOf('?') !== -1 ? "&" : "?") + data; 19659 data = ''; 19660 } 19661 19662 return BX.ajax({ 19663 'method': 'GET', 19664 'dataType': 'json', 19665 'url': url, 19666 'onsuccess': callback, 19667 'onfailure': callback_failure 19668 }); 19669}; 19670 19671var getLastContentTypeHeader = function (headers) { 19672 if (!BX.Type.isArray(headers)) 19673 { 19674 return null; 19675 } 19676 var lastHeader = headers 19677 .filter(function (header) { 19678 return header.name === 'Content-Type'; 19679 }) 19680 .pop(); 19681 19682 return lastHeader ? lastHeader.value : null; 19683}; 19684 19685var prepareAjaxGetParameters = function(config) 19686{ 19687 var getParameters = config.getParameters || {}; 19688 if (BX.type.isNotEmptyString(config.analyticsLabel)) 19689 { 19690 getParameters.analyticsLabel = config.analyticsLabel; 19691 } 19692 else if (BX.type.isNotEmptyObject(config.analyticsLabel)) 19693 { 19694 getParameters.analyticsLabel = config.analyticsLabel; 19695 } 19696 if (typeof config.mode !== 'undefined') 19697 { 19698 getParameters.mode = config.mode; 19699 } 19700 if (config.navigation) 19701 { 19702 if(config.navigation.page) 19703 { 19704 getParameters.nav = 'page-' + config.navigation.page; 19705 } 19706 if(config.navigation.size) 19707 { 19708 if(getParameters.nav) 19709 { 19710 getParameters.nav += '-'; 19711 } 19712 else 19713 { 19714 getParameters.nav = ''; 19715 } 19716 getParameters.nav += 'size-' + config.navigation.size; 19717 } 19718 } 19719 19720 return getParameters; 19721}; 19722 19723var prepareAjaxConfig = function(config) 19724{ 19725 config = BX.type.isPlainObject(config) ? config : {}; 19726 19727 if (typeof config.json !== 'undefined') 19728 { 19729 if (!BX.type.isPlainObject(config.json)) 19730 { 19731 throw new Error('Wrong `config.json`, plain object expected.') 19732 } 19733 19734 config.headers = config.headers || []; 19735 config.headers.push({name: 'Content-Type', value: 'application/json'}); 19736 config.headers.push({name: 'X-Bitrix-Csrf-Token', value: BX.bitrix_sessid()}); 19737 if (BX.message.SITE_ID) 19738 { 19739 config.headers.push({name: 'X-Bitrix-Site-Id', value: BX.message.SITE_ID}); 19740 } 19741 19742 config.data = config.json; 19743 config.preparePost = false; 19744 } 19745 else if (config.data instanceof FormData) 19746 { 19747 config.preparePost = false; 19748 19749 config.data.append('sessid', BX.bitrix_sessid()); 19750 if (BX.message.SITE_ID) 19751 { 19752 config.data.append('SITE_ID', BX.message.SITE_ID); 19753 } 19754 if (typeof config.signedParameters !== 'undefined') 19755 { 19756 config.data.append('signedParameters', config.signedParameters); 19757 } 19758 } 19759 else 19760 { 19761 config.data = BX.type.isPlainObject(config.data) ? config.data : {}; 19762 if (BX.message.SITE_ID) 19763 { 19764 config.data.SITE_ID = BX.message.SITE_ID; 19765 } 19766 config.data.sessid = BX.bitrix_sessid(); 19767 if (typeof config.signedParameters !== 'undefined') 19768 { 19769 config.data.signedParameters = config.signedParameters; 19770 } 19771 } 19772 19773 if (!config.method) 19774 { 19775 config.method = 'POST' 19776 } 19777 19778 return config; 19779}; 19780 19781var buildAjaxPromiseToRestoreCsrf = function(config, withoutRestoringCsrf) 19782{ 19783 withoutRestoringCsrf = withoutRestoringCsrf || false; 19784 var originalConfig = BX.clone(config); 19785 var request = null; 19786 19787 var onrequeststart = config.onrequeststart; 19788 config.onrequeststart = function(xhr) { 19789 request = xhr; 19790 if (BX.type.isFunction(onrequeststart)) 19791 { 19792 onrequeststart(xhr); 19793 } 19794 }; 19795 var onrequeststartOrig = originalConfig.onrequeststart; 19796 originalConfig.onrequeststart = function(xhr) { 19797 request = xhr; 19798 if (BX.type.isFunction(onrequeststartOrig)) 19799 { 19800 onrequeststartOrig(xhr); 19801 } 19802 }; 19803 19804 var promise = BX.ajax.promise(config); 19805 19806 return promise.then(function(response) { 19807 if (!withoutRestoringCsrf && BX.type.isPlainObject(response) && BX.type.isArray(response.errors)) 19808 { 19809 var csrfProblem = false; 19810 response.errors.forEach(function(error) { 19811 if (error.code === 'invalid_csrf' && error.customData.csrf) 19812 { 19813 BX.message({'bitrix_sessid': error.customData.csrf}); 19814 originalConfig.data.sessid = BX.bitrix_sessid(); 19815 19816 csrfProblem = true; 19817 } 19818 }); 19819 19820 if (csrfProblem) 19821 { 19822 return buildAjaxPromiseToRestoreCsrf(originalConfig, true); 19823 } 19824 } 19825 19826 if (!BX.type.isPlainObject(response) || response.status !== 'success') 19827 { 19828 var errorPromise = new BX.Promise(); 19829 errorPromise.reject(response); 19830 19831 return errorPromise; 19832 } 19833 19834 return response; 19835 }).catch(function(data) { 19836 var ajaxReject = new BX.Promise(); 19837 19838 if (BX.type.isPlainObject(data) && data.status && data.hasOwnProperty('data')) 19839 { 19840 ajaxReject.reject(data); 19841 } 19842 else 19843 { 19844 ajaxReject.reject({ 19845 status: 'error', 19846 data: { 19847 ajaxRejectData: data 19848 }, 19849 errors: [ 19850 {
19851 code: 'NETWORK_ERROR', 19852 message: 'Network error' 19853 } 19854 ] 19855 }); 19856 } 19857 19858 return ajaxReject; 19859 }).then(function(response){ 19860 19861 var assetsLoaded = new BX.Promise(); 19862 19863 var headers = request.getAllResponseHeaders().trim().split(/[\r\n]+/); 19864 var headerMap = {}; 19865 headers.forEach(function (line) { 19866 var parts = line.split(': '); 19867 var header = parts.shift().toLowerCase(); 19868 headerMap[header] = parts.join(': '); 19869 }); 19870 19871 if (!headerMap['x-process-assets']) 19872 { 19873 assetsLoaded.fulfill(response); 19874 19875 return assetsLoaded; 19876 } 19877 19878 var assets = BX.prop.getObject(BX.prop.getObject(response, "data", {}), "assets", {}); 19879 var promise = new Promise(function(resolve, reject) { 19880 var css = BX.prop.getArray(assets, "css", []); 19881 BX.load(css, function(){ 19882 BX.loadScript( 19883 BX.prop.getArray(assets, "js", []), 19884 resolve 19885 ); 19886 }); 19887 }); 19888 promise.then(function(){ 19889 var strings = BX.prop.getArray(assets, "string", []); 19890 var stringAsset = strings.join('\n'); 19891 BX.html(null, stringAsset).then(function(){ 19892 assetsLoaded.fulfill(response); 19893 }); 19894 }); 19895 19896 return assetsLoaded; 19897 }); 19898}; 19899 19900/** 19901 * 19902 * @param {string} action 19903 * @param {Object} config 19904 * @param {?string|?Object} [config.analyticsLabel] 19905 * @param {string} [config.method='POST'] 19906 * @param {Object} [config.data] 19907 * @param {?Object} [config.getParameters] 19908 * @param {?Object} [config.headers] 19909 * @param {?Object} [config.timeout] 19910 * @param {Object} [config.navigation] 19911 * @param {number} [config.navigation.page] 19912 */ 19913BX.ajax.runAction = function(action, config) 19914{ 19915 config = prepareAjaxConfig(config); 19916 var getParameters = prepareAjaxGetParameters(config); 19917 getParameters.action = action; 19918
19919 var url = '/bitrix/services/main/ajax.php?' + BX.ajax.prepareData(getParameters); 19920 return buildAjaxPromiseToRestoreCsrf({ 19921 method: config.method, 19922 dataType: 'json', 19923 url: url, 19924 data: config.data, 19925 timeout: config.timeout, 19926 preparePost: config.preparePost, 19927 headers: config.headers, 19928 onrequeststart: config.onrequeststart 19929 }); 19930}; 19931 19932/** 19933 * 19934 * @param {string} component 19935 * @param {string} action 19936 * @param {Object} config 19937 * @param {?string|?Object} [config.analyticsLabel] 19938 * @param {?string} [config.signedParameters] 19939 * @param {string} [config.method='POST'] 19940 * @param {string} [config.mode='ajax'] Ajax or class. 19941 * @param {Object} [config.data] 19942 * @param {?Object} [config.getParameters] 19943 * @param {?array} [config.headers] 19944 * @param {?number} [config.timeout] 19945 * @param {Object} [config.navigation] 19946 */ 19947BX.ajax.runComponentAction = function (component, action, config) 19948{ 19949 config = prepareAjaxConfig(config); 19950 config.mode = config.mode || 'ajax'; 19951 19952 var getParameters = prepareAjaxGetParameters(config); 19953 getParameters.c = component; 19954 getParameters.action = action; 19955
19956 var url = '/bitrix/services/main/ajax.php?' + BX.ajax.prepareData(getParameters); 19957 19958 return buildAjaxPromiseToRestoreCsrf({ 19959 method: config.method, 19960 dataType: 'json', 19961 url: url, 19962 data: config.data, 19963 timeout: config.timeout, 19964 preparePost: config.preparePost, 19965 headers: config.headers, 19966 onrequeststart: (config.onrequeststart ? config.onrequeststart : null) 19967 }); 19968}; 19969 19970/* 19971arObs = [{ 19972 url: url, 19973 type: html|script|json|css, 19974 callback: function 19975}] 19976*/ 19977BX.ajax.load = function(arObs, callback) 19978{ 19979 if (!BX.type.isArray(arObs)) 19980 arObs = [arObs]; 19981 19982 var cnt = 0; 19983 19984 if (!BX.type.isFunction(callback)) 19985 callback = BX.DoNothing; 19986 19987 var handler = function(data) 19988 { 19989 if (BX.type.isFunction(this.callback)) 19990 this.callback(data); 19991 19992 if (++cnt >= len) 19993 callback(); 19994 }; 19995 19996 for (var i = 0, len = arObs.length; i<len; i++) 19997 { 19998 switch(arObs[i].type.toUpperCase()) 19999 { 20000 case 'SCRIPT': 20001 BX.loadScript([arObs[i].url], BX.proxy(handler, arObs[i])); 20002 break; 20003 case 'CSS': 20004 BX.loadCSS([arObs[i].url]); 20005 20006 if (++cnt >= len) 20007 callback(); 20008 break; 20009 case 'JSON': 20010 BX.ajax.loadJSON(arObs[i].url, BX.proxy(handler, arObs[i])); 20011 break; 20012 20013 default: 20014 BX.ajax.get(arObs[i].url, '', BX.proxy(handler, arObs[i])); 20015 break; 20016 } 20017 } 20018}; 20019 20020/* ajax form sending */ 20021BX.ajax.submit = function(obForm, callback) 20022{ 20023 if (!obForm.target) 20024 { 20025 if (null == obForm.BXFormTarget) 20026 { 20027 var frame_name = 'formTarget_' + Math.random(); 20028 obForm.BXFormTarget = document.body.appendChild(BX.create('IFRAME', { 20029 props: { 20030 name: frame_name, 20031 id: frame_name, 20032 src: 'javascript:void(0)' 20033 }, 20034 style: { 20035 display: 'none' 20036 } 20037 })); 20038 } 20039 20040 obForm.target = obForm.BXFormTarget.name; 20041 } 20042 20043 obForm.BXFormCallback = callback; 20044 BX.bind(obForm.BXFormTarget, 'load', BX.proxy(BX.ajax._submit_callback, obForm)); 20045 20046 BX.submit(obForm); 20047 20048 return false; 20049}; 20050 20051BX.ajax.submitComponentForm = function(obForm, container, bWait) 20052{ 20053 if (!obForm.target) 20054 { 20055 if (null == obForm.BXFormTarget) 20056 { 20057 var frame_name = 'formTarget_' + Math.random(); 20058 obForm.BXFormTarget = document.body.appendChild(BX.create('IFRAME', { 20059 props: { 20060 name: frame_name, 20061 id: frame_name, 20062 src: 'javascript:void(0)' 20063 }, 20064 style: { 20065 display: 'none' 20066 } 20067 })); 20068 } 20069 20070 obForm.target = obForm.BXFormTarget.name; 20071 } 20072 20073 if (!!bWait) 20074 var w = BX.showWait(container); 20075 20076 obForm.BXFormCallback = function(d) { 20077 if (!!bWait) 20078 BX.closeWait(w); 20079 20080 var callOnload = function(){ 20081 if(!!window.bxcompajaxframeonload) 20082 { 20083 setTimeout(function(){window.bxcompajaxframeonload();window.bxcompajaxframeonload=null;}, 10); 20084 } 20085 }; 20086 20087 BX(container).innerHTML = d; 20088 BX.onCustomEvent('onAjaxSuccess', [null,null,callOnload]); 20089 }; 20090 20091 BX.bind(obForm.BXFormTarget, 'load', BX.proxy(BX.ajax._submit_callback, obForm)); 20092 20093 return true; 20094}; 20095 20096// func will be executed in form context 20097BX.ajax._submit_callback = function() 20098{ 20099 //opera and IE8 triggers onload event even on empty iframe 20100 try 20101 { 20102 if(this.BXFormTarget.contentWindow.location.href.indexOf('http') != 0) 20103 return; 20104 } catch (e) { 20105 return; 20106 } 20107 20108 if (this.BXFormCallback) 20109 this.BXFormCallback.apply(this, [this.BXFormTarget.contentWindow.document.body.innerHTML]); 20110 20111 BX.unbindAll(this.BXFormTarget); 20112}; 20113 20114BX.ajax.prepareForm = function(obForm, data) 20115{ 20116 data = (!!data ? data : {}); 20117 var i, ii, el, 20118 _data = [], 20119 n = obForm.elements.length, 20120 files = 0, length = 0; 20121 if(!!obForm) 20122 { 20123 for (i = 0; i < n; i++) 20124 { 20125 el = obForm.elements[i]; 20126 if (el.disabled) 20127 continue; 20128 20129 if(!el.type) 20130 continue; 20131 20132 switch(el.type.toLowerCase()) 20133 { 20134 case 'text': 20135 case 'textarea': 20136 case 'password': 20137 case 'number': 20138 case 'hidden': 20139 case 'select-one': 20140 _data.push({name: el.name, value: el.value}); 20141 length += (el.name.length + el.value.length); 20142 break; 20143 case 'file': 20144 if (!!el.files) 20145 { 20146 for (ii = 0; ii < el.files.length; ii++) 20147 { 20148 files++; 20149 _data.push({name: el.name, value: el.files[ii], file : true}); 20150 length += el.files[ii].size; 20151 } 20152 } 20153 break; 20154 case 'radio': 20155 case 'checkbox': 20156 if(el.checked) 20157 { 20158 _data.push({name: el.name, value: el.value}); 20159 length += (el.name.length + el.value.length); 20160 } 20161 break; 20162 case 'select-multiple': 20163 for (var j = 0; j < el.options.length; j++) 20164 { 20165 if (el.options[j].selected) 20166 { 20167 _data.push({name : el.name, value : el.options[j].value}); 20168 length += (el.name.length + el.options[j].length); 20169 } 20170 } 20171 break; 20172 default: 20173 break; 20174 } 20175 } 20176 20177 i = 0; length = 0; 20178 var current = data, name, rest, pp, tmpKey; 20179 20180 while(i < _data.length) 20181 { 20182 var p = _data[i].name.indexOf('['); 20183 if (tmpKey) 20184 { 20185 current[_data[i].name] = {}; 20186 current[_data[i].name][tmpKey.replace(/\[|\]/gi, '')] = _data[i].value; 20187 current = data; 20188 tmpKey = null; 20189 i++; 20190 } 20191 else if (p == -1) 20192 { 20193 current[_data[i].name] = _data[i].value; 20194 current = data; 20195 i++; 20196 } 20197 else 20198 {
20199 name = _data[i].name.substring(0, p); 20200 rest = _data[i].name.substring(p+1); 20201 pp = rest.indexOf(']'); 20202 20203 if(pp == -1) 20204 { 20205 if (!current[name]) 20206 current[name] = []; 20207 current = data; 20208 i++; 20209 } 20210 else if(pp == 0) 20211 { 20212 if (!current[name]) 20213 current[name] = []; 20214 //No index specified - so take the next integer 20215 current = current[name]; 20216 _data[i].name = '' + current.length; 20217 if (rest.substring(pp+1).indexOf('[') === 0) 20218 tmpKey = rest.substring(0, pp) + rest.substring(pp+1); 20219 } 20220 else 20221 { 20222 if (!current[name]) 20223 current[name] = {}; 20224 //Now index name becomes and name and we go deeper into the array 20225 current = current[name]; 20226 _data[i].name = rest.substring(0, pp) + rest.substring(pp+1); 20227 } 20228 } 20229 } 20230 } 20231 return {data : data, filesCount : files, roughSize : length}; 20232}; 20233BX.ajax.submitAjax = function(obForm, config) 20234{ 20235 config = (config !== null && typeof config == "object" ? config : {}); 20236 config.url = (config["url"] || obForm.getAttribute("action")); 20237 20238 var additionalData = (config["data"] || {}); 20239 config.data = BX.ajax.prepareForm(obForm).data; 20240 for (var ii in additionalData) 20241 { 20242 if (additionalData.hasOwnProperty(ii)) 20243 { 20244 config.data[ii] = additionalData[ii]; 20245 } 20246 } 20247 20248 if (!window["FormData"]) 20249 { 20250 BX.ajax(config); 20251 } 20252 else 20253 { 20254 var isFile = function(item) 20255 { 20256 var res = Object.prototype.toString.call(item); 20257 return (res == '[object File]' || res == '[object Blob]'); 20258 }, 20259 appendToForm = function(fd, key, val) 20260 { 20261 if (!!val && typeof val == "object" && !isFile(val)) 20262 { 20263 for (var ii in val) 20264 { 20265 if (val.hasOwnProperty(ii)) 20266 { 20267 appendToForm(fd, (key == '' ? ii : key + '[' + ii + ']'), val[ii]); 20268 } 20269 } 20270 } 20271 else 20272 fd.append(key, (!!val ? val : '')); 20273 }, 20274 prepareData = function(arData) 20275 { 20276 var data = {}; 20277 if (null != arData) 20278 { 20279 if(typeof arData == 'object') 20280 { 20281 for(var i in arData) 20282 { 20283 if (arData.hasOwnProperty(i)) 20284 { 20285 var name = BX.util.urlencode(i); 20286 if(typeof arData[i] == 'object' && arData[i]["file"] !== true) 20287 data[name] = prepareData(arData[i]); 20288 else if (arData[i]["file"] === true) 20289 data[name] = arData[i]["value"]; 20290 else 20291 data[name] = BX.util.urlencode(arData[i]); 20292 } 20293 } 20294 } 20295 else 20296 data = BX.util.urlencode(arData); 20297 } 20298 return data; 20299 }, 20300 fd = new window.FormData(); 20301 20302 if (config.method !== 'POST') 20303 { 20304 config.data = BX.ajax.prepareData(config.data); 20305 if (config.data) 20306 { 20307 config.url += (config.url.indexOf('?') !== -1 ? "&" : "?") + config.data; 20308 config.data = ''; 20309 } 20310 } 20311 else 20312 { 20313 if (config.preparePost === true) 20314 config.data = prepareData(config.data); 20315 appendToForm(fd, '', config.data); 20316 config.data = fd; 20317 } 20318 20319 config.preparePost = false; 20320 config.start = false;
20321 20322 var xhr = BX.ajax(config); 20323 if (!!config["onprogress"]) 20324 xhr.upload.addEventListener( 20325 'progress', 20326 function(e){ 20327 var percent = null; 20328 if(e.lengthComputable && (e.total || e["totalSize"])) { 20329 percent = e.loaded * 100 / (e.total || e["totalSize"]); 20330 } 20331 config["onprogress"](e, percent); 20332 } 20333 ); 20334 xhr.send(fd); 20335 } 20336}; 20337 20338BX.ajax.UpdatePageData = function (arData) 20339{ 20340 if (arData.TITLE) 20341 BX.ajax.UpdatePageTitle(arData.TITLE); 20342 if (arData.WINDOW_TITLE || arData.TITLE) 20343 BX.ajax.UpdateWindowTitle(arData.WINDOW_TITLE || arData.TITLE); 20344 if (arData.NAV_CHAIN) 20345 BX.ajax.UpdatePageNavChain(arData.NAV_CHAIN); 20346 if (arData.CSS && arData.CSS.length > 0) 20347 BX.loadCSS(arData.CSS); 20348 if (arData.SCRIPTS && arData.SCRIPTS.length > 0) 20349 { 20350 var f = function(result,config,cb){ 20351 20352 if(!!config && BX.type.isArray(config.scripts)) 20353 { 20354 for(var i=0,l=arData.SCRIPTS.length;i<l;i++) 20355 { 20356 config.scripts.push({isInternal:false,JS:arData.SCRIPTS[i]}); 20357 } 20358 } 20359 else 20360 { 20361 BX.loadScript(arData.SCRIPTS,cb); 20362 } 20363 20364 BX.removeCustomEvent('onAjaxSuccess',f); 20365 }; 20366 BX.addCustomEvent('onAjaxSuccess',f); 20367 } 20368 else 20369 { 20370 var f1 = function(result,config,cb){ 20371 if(BX.type.isFunction(cb)) 20372 { 20373 cb(); 20374 } 20375 BX.removeCustomEvent('onAjaxSuccess',f1); 20376 }; 20377 BX.addCustomEvent('onAjaxSuccess', f1); 20378 } 20379}; 20380 20381BX.ajax.UpdatePageTitle = function(title) 20382{ 20383 var obTitle = BX('pagetitle'); 20384 if (obTitle) 20385 { 20386 obTitle.removeChild(obTitle.firstChild); 20387 if (!obTitle.firstChild) 20388 obTitle.appendChild(document.createTextNode(title)); 20389 else 20390 obTitle.insertBefore(document.createTextNode(title), obTitle.firstChild); 20391 } 20392}; 20393 20394BX.ajax.UpdateWindowTitle = function(title) 20395{ 20396 document.title = title; 20397}; 20398 20399BX.ajax.UpdatePageNavChain = function(nav_chain) 20400{ 20401 var obNavChain = BX('navigation'); 20402 if (obNavChain) 20403 { 20404 obNavChain.innerHTML = nav_chain; 20405 } 20406}; 20407 20408/* user options handling */ 20409BX.userOptions = { 20410 options: null, 20411 bSend: false, 20412 delay: 5000, 20413 path: '/bitrix/admin/user_options.php?' 20414}; 20415 20416BX.userOptions.setAjaxPath = function(url) 20417{ 20418 BX.userOptions.path = url.indexOf('?') == -1? url+'?': url+'&'; 20419} 20420BX.userOptions.save = function(sCategory, sName, sValName, sVal, bCommon) 20421{ 20422 if (null == BX.userOptions.options) 20423 BX.userOptions.options = {}; 20424 20425 bCommon = !!bCommon; 20426 BX.userOptions.options[sCategory+'.'+sName+'.'+sValName] = [sCategory, sName, sValName, sVal, bCommon]; 20427 20428 var sParam = BX.userOptions.__get(); 20429 if (sParam != '') 20430 document.cookie = BX.message('COOKIE_PREFIX')+"_LAST_SETTINGS=" + encodeURIComponent(sParam) + "&sessid="+BX.bitrix_sessid()+"; expires=Thu, 31 Dec 2020 23:59:59 GMT; path=/;"; 20431 20432 if(!BX.userOptions.bSend) 20433 { 20434 BX.userOptions.bSend = true; 20435 setTimeout(function(){BX.userOptions.send(null)}, BX.userOptions.delay); 20436 } 20437}; 20438 20439BX.userOptions.send = function(callback) 20440{ 20441 var sParam = BX.userOptions.__get(); 20442 BX.userOptions.options = null; 20443 BX.userOptions.bSend = false; 20444 20445 if (sParam != '') 20446 { 20447 document.cookie = BX.message('COOKIE_PREFIX') + "_LAST_SETTINGS=; path=/;"; 20448 BX.ajax({ 20449 'method': 'GET', 20450 'dataType': 'html', 20451 'processData': false, 20452 'cache': false, 20453 'url': BX.userOptions.path+sParam+'&sessid='+BX.bitrix_sessid(), 20454 'onsuccess': callback 20455 }); 20456 } 20457}; 20458 20459BX.userOptions.del = function(sCategory, sName, bCommon, callback) 20460{ 20461 BX.ajax.get(BX.userOptions.path+'action=delete&c='+sCategory+'&n='+sName+(bCommon == true? '&common=Y':'')+'&sessid='+BX.bitrix_sessid(), callback); 20462}; 20463 20464BX.userOptions.__get = function() 20465{ 20466 if (!BX.userOptions.options) return ''; 20467 20468 var sParam = '', n = -1, prevParam = '', aOpt, i; 20469 20470 for (i in BX.userOptions.options) 20471 { 20472 if(BX.userOptions.options.hasOwnProperty(i)) 20473 { 20474 aOpt = BX.userOptions.options[i]; 20475 20476 if (prevParam != aOpt[0]+'.'+aOpt[1]) 20477 { 20478 n++; 20479 sParam += '&p['+n+'][c]='+BX.util.urlencode(aOpt[0]); 20480 sParam += '&p['+n+'][n]='+BX.util.urlencode(aOpt[1]); 20481 if (aOpt[4] == true) 20482 sParam += '&p['+n+'][d]=Y'; 20483 prevParam = aOpt[0]+'.'+aOpt[1]; 20484 } 20485 20486 var valueName = aOpt[2]; 20487 var value = aOpt[3]; 20488 20489 if (valueName === null) 20490 { 20491 sParam += '&p['+n+'][v]='+BX.util.urlencode(value); 20492 } 20493 else 20494 {
20495 sParam += '&p['+n+'][v]['+BX.util.urlencode(valueName)+']='+BX.util.urlencode(value); 20496 } 20497 } 20498 } 20499 20500 return sParam.substr(1); 20501}; 20502 20503BX.ajax.history = { 20504 expected_hash: '', 20505 20506 obParams: null, 20507 20508 obFrame: null, 20509 obImage: null, 20510 20511 obTimer: null, 20512 20513 bInited: false, 20514 bHashCollision: false, 20515 bPushState: !!(history.pushState && BX.type.isFunction(history.pushState)), 20516 20517 startState: null, 20518 20519 init: function(obParams) 20520 { 20521 if (BX.ajax.history.bInited) 20522 return; 20523 20524 this.obParams = obParams; 20525 var obCurrentState = this.obParams.getState(); 20526 20527 if (BX.ajax.history.bPushState) 20528 { 20529 BX.ajax.history.expected_hash = window.location.pathname; 20530 if (window.location.search) 20531 BX.ajax.history.expected_hash += window.location.search; 20532 20533 BX.ajax.history.put(obCurrentState, BX.ajax.history.expected_hash, '', true); 20534 // due to some strange thing, chrome calls popstate event on page start. so we should delay it 20535 setTimeout(function(){BX.bind(window, 'popstate', BX.ajax.history.__hashListener);}, 500); 20536 } 20537 else 20538 { 20539 BX.ajax.history.expected_hash = window.location.hash; 20540 20541 if (!BX.ajax.history.expected_hash || BX.ajax.history.expected_hash == '#') 20542 BX.ajax.history.expected_hash = '__bx_no_hash__'; 20543 20544 jsAjaxHistoryContainer.put(BX.ajax.history.expected_hash, obCurrentState); 20545 BX.ajax.history.obTimer = setTimeout(BX.ajax.history.__hashListener, 500); 20546 20547 if (BX.browser.IsIE()) 20548 { 20549 BX.ajax.history.obFrame = document.createElement('IFRAME'); 20550 BX.hide_object(BX.ajax.history.obFrame); 20551 20552 document.body.appendChild(BX.ajax.history.obFrame); 20553 20554 BX.ajax.history.obFrame.contentWindow.document.open(); 20555 BX.ajax.history.obFrame.contentWindow.document.write(BX.ajax.history.expected_hash); 20556 BX.ajax.history.obFrame.contentWindow.document.close(); 20557 } 20558 else if (BX.browser.IsOpera()) 20559 { 20560 BX.ajax.history.obImage = document.createElement('IMG'); 20561 BX.hide_object(BX.ajax.history.obImage); 20562 20563 document.body.appendChild(BX.ajax.history.obImage); 20564 20565 BX.ajax.history.obImage.setAttribute('src', 'javascript:location.href = \'javascript:BX.ajax.history.__hashListener();\';'); 20566 } 20567 } 20568 20569 BX.ajax.history.bInited = true; 20570 }, 20571 20572 __hashListener: function(e) 20573 { 20574 e = e || window.event || {state:false}; 20575 20576 if (BX.ajax.history.bPushState) 20577 { 20578 BX.ajax.history.obParams.setState(e.state||BX.ajax.history.startState); 20579 } 20580 else 20581 { 20582 if (BX.ajax.history.obTimer) 20583 { 20584 window.clearTimeout(BX.ajax.history.obTimer); 20585 BX.ajax.history.obTimer = null; 20586 } 20587 20588 var current_hash; 20589 if (null != BX.ajax.history.obFrame) 20590 current_hash = BX.ajax.history.obFrame.contentWindow.document.body.innerText; 20591 else 20592 current_hash = window.location.hash; 20593 20594 if (!current_hash || current_hash == '#') 20595 current_hash = '__bx_no_hash__'; 20596 20597 if (current_hash.indexOf('#') == 0) 20598 current_hash = current_hash.substring(1); 20599 20600 if (current_hash != BX.ajax.history.expected_hash) 20601 { 20602 var state = jsAjaxHistoryContainer.get(current_hash); 20603 if (state) 20604 { 20605 BX.ajax.history.obParams.setState(state); 20606 20607 BX.ajax.history.expected_hash = current_hash; 20608 if (null != BX.ajax.history.obFrame) 20609 { 20610 var __hash = current_hash == '__bx_no_hash__' ? '' : current_hash; 20611 if (window.location.hash != __hash && window.location.hash != '#' + __hash) 20612 window.location.hash = __hash; 20613 } 20614 } 20615 } 20616 20617 BX.ajax.history.obTimer = setTimeout(BX.ajax.history.__hashListener, 500); 20618 } 20619 }, 20620 20621 put: function(state, new_hash, new_hash1, bStartState) 20622 { 20623 if (this.bPushState) 20624 { 20625 if(!bStartState) 20626 { 20627 history.pushState(state, '', new_hash); 20628 } 20629 else 20630 { 20631 BX.ajax.history.startState = state; 20632 } 20633 } 20634 else 20635 { 20636 if (typeof new_hash1 != 'undefined') 20637 new_hash = new_hash1; 20638 else 20639 new_hash = 'view' + new_hash; 20640 20641 jsAjaxHistoryContainer.put(new_hash, state); 20642 BX.ajax.history.expected_hash = new_hash; 20643 20644 window.location.hash = BX.util.urlencode(new_hash); 20645 20646 if (null != BX.ajax.history.obFrame) 20647 { 20648 BX.ajax.history.obFrame.contentWindow.document.open(); 20649 BX.ajax.history.obFrame.contentWindow.document.write(new_hash); 20650 BX.ajax.history.obFrame.contentWindow.document.close(); 20651 } 20652 } 20653 }, 20654 20655 checkRedirectStart: function(param_name, param_value) 20656 { 20657 var current_hash = window.location.hash; 20658 if (current_hash.substring(0, 1) == '#') current_hash = current_hash.substring(1); 20659 20660 var test = current_hash.substring(0, 5); 20661 if (test == 'view/' || test == 'view%') 20662 { 20663 BX.ajax.history.bHashCollision = true;
20664 document.write('<' + 'div id="__ajax_hash_collision_' + param_value + '" style="display: none;">'); 20665 } 20666 }, 20667 20668 checkRedirectFinish: function(param_name, param_value) 20669 { 20670 document.write('</div>'); 20671 20672 var current_hash = window.location.hash; 20673 if (current_hash.substring(0, 1) == '#') current_hash = current_hash.substring(1); 20674 20675 BX.ready(function () 20676 { 20677 var test = current_hash.substring(0, 5); 20678 if (test == 'view/' || test == 'view%') 20679 { 20680 var obColNode = BX('__ajax_hash_collision_' + param_value); 20681 var obNode = obColNode.firstChild; 20682 BX.cleanNode(obNode); 20683 obColNode.style.display = 'block'; 20684 20685 // IE, Opera and Chrome automatically modifies hash with urlencode, but FF doesn't ;-( 20686 if (test != 'view%') 20687 current_hash = BX.util.urlencode(current_hash); 20688 20689 current_hash += (current_hash.indexOf('%3F') == -1 ? '%3F' : '%26') + param_name + '=' + param_value; 20690 20691 var url = '/bitrix/tools/ajax_redirector.php?hash=' + current_hash; 20692 20693 BX.ajax.insertToNode(url, obNode); 20694 } 20695 }); 20696 } 20697}; 20698 20699BX.ajax.component = function(node) 20700{ 20701 this.node = node; 20702}; 20703 20704BX.ajax.component.prototype.getState = function() 20705{ 20706 var state = { 20707 'node': this.node, 20708 'title': window.document.title, 20709 'data': BX(this.node).innerHTML 20710 }; 20711 20712 var obNavChain = BX('navigation'); 20713 if (null != obNavChain) 20714 state.nav_chain = obNavChain.innerHTML; 20715 20716 BX.onCustomEvent(BX(state.node), "onComponentAjaxHistoryGetState", [state]); 20717 20718 return state; 20719}; 20720 20721BX.ajax.component.prototype.setState = function(state) 20722{ 20723 BX(state.node).innerHTML = state.data; 20724 BX.ajax.UpdatePageTitle(state.title); 20725 20726 if (state.nav_chain) 20727 { 20728 BX.ajax.UpdatePageNavChain(state.nav_chain); 20729 } 20730 20731 BX.onCustomEvent(BX(state.node), "onComponentAjaxHistorySetState", [state]); 20732}; 20733 20734var jsAjaxHistoryContainer = { 20735 arHistory: {}, 20736 20737 put: function(hash, state) 20738 { 20739 this.arHistory[hash] = state; 20740 }, 20741 20742 get: function(hash) 20743 { 20744 return this.arHistory[hash]; 20745 } 20746}; 20747 20748 20749BX.ajax.FormData = function() 20750{ 20751 this.elements = []; 20752 this.files = []; 20753 this.features = {}; 20754 this.isSupported(); 20755 this.log('BX FormData init'); 20756}; 20757 20758BX.ajax.FormData.isSupported = function() 20759{ 20760 var f = new BX.ajax.FormData(); 20761 var result = f.features.supported; 20762 f = null; 20763 return result; 20764}; 20765 20766BX.ajax.FormData.prototype.log = function(o) 20767{ 20768 if (false) { 20769 try { 20770 if (BX.browser.IsIE()) o = JSON.stringify(o); 20771 console.log(o); 20772 } catch(e) {} 20773 } 20774}; 20775 20776BX.ajax.FormData.prototype.isSupported = function() 20777{ 20778 var f = {}; 20779 f.fileReader = (window.FileReader && window.FileReader.prototype.readAsBinaryString); 20780 f.readFormData = f.sendFormData = !!(window.FormData); 20781 f.supported = !!(f.readFormData && f.sendFormData); 20782 this.features = f; 20783 this.log('features:'); 20784 this.log(f); 20785 20786 return f.supported; 20787}; 20788 20789BX.ajax.FormData.prototype.append = function(name, value) 20790{ 20791 if (typeof(value) === 'object') { // seems to be files element 20792 this.files.push({'name': name, 'value':value}); 20793 } else { 20794 this.elements.push({'name': name, 'value':value}); 20795 } 20796}; 20797 20798BX.ajax.FormData.prototype.send = function(url, callbackOk, callbackProgress, callbackError) 20799{ 20800 this.log('FD send'); 20801 this.xhr = BX.ajax({ 20802 'method': 'POST', 20803 'dataType': 'html', 20804 'url': url, 20805 'onsuccess': callbackOk, 20806 'onfailure': callbackError, 20807 'start': false, 20808 'preparePost':false 20809 }); 20810 20811 if (callbackProgress) 20812 { 20813 this.xhr.upload.addEventListener( 20814 'progress', 20815 function(e) { 20816 if (e.lengthComputable) 20817 callbackProgress(e.loaded / (e.total || e.totalSize)); 20818 }, 20819 false 20820 ); 20821 } 20822 20823 if (this.features.readFormData && this.features.sendFormData) 20824 { 20825 var fd = new FormData(); 20826 this.log('use browser formdata'); 20827 for (var i in this.elements) 20828 { 20829 if(this.elements.hasOwnProperty(i)) 20830 fd.append(this.elements[i].name,this.elements[i].value); 20831 } 20832 for (i in this.files) 20833 { 20834 if(this.files.hasOwnProperty(i)) 20835 fd.append(this.files[i].name, this.files[i].value); 20836 } 20837 this.xhr.send(fd); 20838 } 20839 20840 return this.xhr; 20841}; 20842 20843BX.addCustomEvent('onAjaxFailure', BX.debug); 20844})(window); 20845 20846 20847 20848(function (exports,main_core) { 20849 'use strict'; 20850 20851 var LazyLoad = { 20852 observer: null, 20853 images: {}, 20854 imageStatus: { 20855 hidden: -2, 20856 error: -1, 20857 "undefined": 0, 20858 inited: 1, 20859 loaded: 2 20860 }, 20861 imageTypes: { 20862 image: 1, 20863 background: 2 20864 },
20865 initObserver: function initObserver() { 20866 this.observer = new IntersectionObserver(this.onIntersection.bind(this), { 20867 rootMargin: '20% 0% 20% 0%', 20868 threshold: 0.10 20869 }); 20870 }, 20871 onIntersection: function onIntersection(entries) { 20872 entries.forEach(function (entry) { 20873 if (entry.isIntersecting) { 20874 this.showImage(entry.target); 20875 } 20876 }.bind(this)); 20877 }, 20878 registerImage: function registerImage(id, isImageVisibleCallback, options) { 20879 if (this.observer === null) { 20880 this.initObserver(); 20881 } 20882 20883 options = options || {}; 20884 20885 if (!main_core.Type.isStringFilled(id)) { 20886 return; 20887 } 20888 20889 if (main_core.Type.isObject(this.images[id])) { 20890 return; 20891 } 20892 20893 var element = document.getElementById(id); 20894 20895 if (!main_core.Type.isDomNode(element)) { 20896 return; 20897 } 20898 20899 this.observer.observe(element); 20900 this.images[id] = { 20901 id: id, 20902 node: null, 20903 src: null, 20904 dataSrcName: options.dataSrcName || 'src', 20905 type: null, 20906 func: main_core.Type.isFunction(isImageVisibleCallback) ? isImageVisibleCallback : null, 20907 status: this.imageStatus.undefined 20908 }; 20909 }, 20910 registerImages: function registerImages(ids, isImageVisibleCallback, options) { 20911 if (main_core.Type.isArray(ids)) { 20912 for (var i = 0, length = ids.length; i < length; i++) { 20913 this.registerImage(ids[i], isImageVisibleCallback, options); 20914 } 20915 } 20916 }, 20917 showImage: function showImage(imageNode) { 20918 var imageNodeId = imageNode.id; 20919 20920 if (!main_core.Type.isStringFilled(imageNodeId)) { 20921 return; 20922 } 20923 20924 var image = this.images[imageNodeId]; 20925 20926 if (!main_core.Type.isPlainObject(image)) { 20927 return; 20928 } 20929 20930 if (image.status == this.imageStatus.undefined) { 20931 this.initImage(image); 20932 } 20933 20934 if (image.status !== this.imageStatus.inited) { 20935 return; 20936 } 20937 20938 if (!image.node || !image.node.parentNode) { 20939 image.node = null; 20940 image.status = this.imageStatus.error; 20941 return; 20942 } 20943 20944 if (image.type == this.imageTypes.image) { 20945 image.node.src = image.src; 20946 } else { 20947 image.node.style.backgroundImage = "url('" + image.src + "')"; 20948 } 20949 20950 image.node.dataset[image.dataSrcName] = ""; 20951 image.status = this.imageStatus.loaded; 20952 }, 20953 showImages: function showImages(checkOwnVisibility) { 20954 checkOwnVisibility = checkOwnVisibility !== false; 20955 20956 for (var id in this.images) { 20957 if (!this.images.hasOwnProperty(id)) { 20958 continue; 20959 } 20960 20961 var image = this.images[id]; 20962 20963 if (image.status == this.imageStatus.undefined) { 20964 this.initImage(image); 20965 } 20966 20967 if (image.status !== this.imageStatus.inited) { 20968 continue; 20969 } 20970 20971 if (!image.node || !image.node.parentNode) { 20972 image.node = null; 20973 image.status = this.imageStatus.error; 20974 continue; 20975 } 20976 20977 var isImageVisible = true; 20978 20979 if (checkOwnVisibility && main_core.Type.isFunction(image.func)) { 20980 isImageVisible = image.func(image); 20981 } 20982 20983 if (isImageVisible === true && this.isElementVisibleOnScreen(image.node)) { 20984 if (image.type == this.imageTypes.image) { 20985 image.node.src = image.src; 20986 } else { 20987 image.node.style.backgroundImage = "url('" + image.src + "')"; 20988 } 20989 20990 image.node.dataset[image.dataSrcName] = ""; 20991 image.status = this.imageStatus.loaded; 20992 } 20993 } 20994 }, 20995 initImage: function initImage(image) { 20996 image.status = this.imageStatus.error; 20997 var node = document.getElementById(image.id); 20998 20999 if (!main_core.Type.isDomNode(node)) { 21000 return; 21001 } 21002 21003 var src = node.dataset[image.dataSrcName]; 21004 21005 if (main_core.Type.isStringFilled(src)) { 21006 image.node = node; 21007 image.src = src; 21008 image.status = this.imageStatus.inited; 21009 image.type = image.node.tagName.toLowerCase() == "img" ? this.imageTypes.image : this.imageTypes.background; 21010 } 21011 }, 21012 isElementVisibleOnScreen: function isElementVisibleOnScreen(element) { 21013 var coords = this.getElementCoords(element); 21014 var windowTop = window.pageYOffset || document.documentElement.scrollTop; 21015 var windowBottom = windowTop + document.documentElement.clientHeight; 21016 coords.bottom = coords.top + element.offsetHeight; 21017 return coords.top > windowTop && coords.top < windowBottom || // topVisible 21018 coords.bottom < windowBottom && coords.bottom > windowTop // bottomVisible 21019 ; 21020 }, 21021 isElementVisibleOn2Screens: function isElementVisibleOn2Screens(element) { 21022 var windowHeight = document.documentElement.clientHeight; 21023 var windowTop = window.pageYOffset || document.documentElement.scrollTop; 21024 var windowBottom = windowTop + windowHeight; 21025 var coords = this.getElementCoords(element); 21026 coords.bottom = coords.top + element.offsetHeight; 21027 windowTop -= windowHeight; 21028 windowBottom += windowHeight; 21029 return coords.top > windowTop && coords.top < windowBottom || // topVisible 21030 coords.bottom < windowBottom && coords.bottom > windowTop // bottomVisible 21031 ; 21032 }, 21033 getElementCoords: function getElementCoords(element) { 21034 var box = element.getBoundingClientRect(); 21035 return { 21036 originTop: box.top, 21037 originLeft: box.left, 21038 top: box.top + window.pageYOffset, 21039 left: box.left + window.pageXOffset 21040 }; 21041 }, 21042 onScroll: function onScroll() {}, 21043 clearImages: function clearImages() { 21044 this.images = []; 21045 } 21046 }; 21047 21048 exports.LazyLoad = LazyLoad; 21049 21050}((this.BX = this.BX || {}),BX)); 21051 21052 21053 21054(function (exports) { 21055 'use strict'; 21056 21057 var ParamBag = 21058 /*#__PURE__*/ 21059 function () { 21060 function ParamBag() { 21061 var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 21062 babelHelpers.classCallCheck(this, ParamBag); 21063 21064 if (!!params && babelHelpers.typeof(params) === 'object') { 21065 this.params = new Map(Object.entries(params)); 21066 } else { 21067 this.params = new Map(); 21068 } 21069 } 21070 21071 babelHelpers.createClass(ParamBag, [{ 21072 key: "getParam", 21073 value: function getParam(key) { 21074 var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 21075 21076 if (this.params.has(key)) { 21077 return this.params.get(key); 21078 } 21079 21080 return defaultValue; 21081 } 21082 }, { 21083 key: "setParam", 21084 value: function setParam(key, value) { 21085 this.params.set(key, value); 21086 } 21087 }, { 21088 key: "clear", 21089 value: function clear() { 21090 this.params.clear(); 21091 } 21092 }], [{ 21093 key: "create", 21094 value: function create() { 21095 var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 21096 return new ParamBag(params); 21097 } 21098 }]); 21099 return ParamBag; 21100 }(); 21101 21102 exports.ParamBag = ParamBag; 21103 21104}((this.BX = this.BX || {}))); 21105 21106 21107 21108(function() { 21109 BX.FixFontSize = function(params) 21110 { 21111 var widthNode, computedStyles, width; 21112 21113 this.node = null; 21114 this.prevWindowSize = 0; 21115 this.prevWrapperSize = 0; 21116 this.mainWrapper = null; 21117 this.textWrapper = null; 21118 this.objList = params.objList; 21119 this.minFontSizeList = []; 21120 this.minFontSize = 0; 21121 21122 if (params.onresize) 21123 { 21124 this.prevWindowSize = window.innerWidth || document.documentElement.clientWidth; 21125 BX.bind(window, 'resize', BX.throttle(this.onResize, 350, this)); 21126 } 21127 21128 if (params.onAdaptiveResize) 21129 { 21130 widthNode = this.objList[0].scaleBy || this.objList[0].node; 21131 computedStyles = getComputedStyle(widthNode); 21132 this.prevWrapperSize = parseInt(computedStyles["width"]) - parseInt(computedStyles["paddingLeft"]) - parseInt(computedStyles["paddingRight"]); 21133 BX.bind(window, 'resize', BX.throttle(this.onAdaptiveResize, 350, this)); 21134 } 21135 21136 this.createTestNodes(); 21137 this.decrease(); 21138 }; 21139 21140 BX.FixFontSize.prototype = 21141 { 21142 createTestNodes: function() 21143 { 21144 this.textWrapper = BX.create('div',{ 21145 style : { 21146 display : 'inline-block', 21147 whiteSpace : 'nowrap' 21148 } 21149 }); 21150 21151 this.mainWrapper = BX.create('div',{ 21152 style : { 21153 height : 0, 21154 overflow : 'hidden' 21155 }, 21156 children : [this.textWrapper] 21157 }); 21158 21159 }, 21160 insertTestNodes: function() 21161 { 21162 document.body.appendChild(this.mainWrapper); 21163 }, 21164 removeTestNodes: function() 21165 { 21166 document.body.removeChild(this.mainWrapper); 21167 }, 21168 decrease: function() 21169 { 21170 var width, 21171 fontSize, 21172 widthNode, 21173 computedStyles; 21174 21175 this.insertTestNodes(); 21176
21177 for(var i=this.objList.length-1; i>=0; i--) 21178 { 21179 widthNode = this.objList[i].scaleBy || this.objList[i].node; 21180 computedStyles = getComputedStyle(widthNode); 21181 width = parseInt(computedStyles["width"]) - parseInt(computedStyles["paddingLeft"]) - parseInt(computedStyles["paddingRight"]); 21182 fontSize = parseInt(getComputedStyle(this.objList[i].node)["font-size"]); 21183 21184 this.textWrapperSetStyle(this.objList[i].node); 21185 21186 if(this.textWrapperInsertText(this.objList[i].node)) 21187 { 21188 while(this.textWrapper.offsetWidth > width && fontSize > 0) 21189 { 21190 this.textWrapper.style.fontSize = --fontSize + 'px'; 21191 } 21192 21193 if(this.objList[i].smallestValue) 21194 { 21195 this.minFontSize = this.minFontSize ? Math.min(this.minFontSize, fontSize) : fontSize; 21196 21197 this.minFontSizeList.push(this.objList[i].node) 21198 } 21199 else 21200 { 21201 this.objList[i].node.style.fontSize = fontSize + 'px'; 21202 } 21203 } 21204 } 21205 21206 if(this.minFontSizeList.length > 0) 21207 this.setMinFont(); 21208 21209 this.removeTestNodes(); 21210 21211 }, 21212 increase: function() 21213 { 21214 this.insertTestNodes(); 21215 var width, 21216 fontSize, 21217 widthNode, 21218 computedStyles; 21219 21220 this.insertTestNodes(); 21221 21222 for(var i=this.objList.length-1; i>=0; i--) 21223 { 21224 widthNode = this.objList[i].scaleBy || this.objList[i].node; 21225 computedStyles = getComputedStyle(widthNode); 21226 width = parseInt(computedStyles["width"]) - parseInt(computedStyles["paddingLeft"]) - parseInt(computedStyles["paddingRight"]); 21227 fontSize = parseInt(getComputedStyle(this.objList[i].node)["font-size"]); 21228 21229 this.textWrapperSetStyle(this.objList[i].node); 21230 21231 if(this.textWrapperInsertText(this.objList[i].node)) 21232 { 21233 while(this.textWrapper.offsetWidth < width && fontSize < this.objList[i].maxFontSize) 21234 { 21235 this.textWrapper.style.fontSize = ++fontSize + 'px'; 21236 } 21237 21238 fontSize--; 21239 21240 if(this.objList[i].smallestValue) 21241 { 21242 this.minFontSize = this.minFontSize ? Math.min(this.minFontSize, fontSize) : fontSize; 21243 21244 this.minFontSizeList.push(this.objList[i].node) 21245 } 21246 else 21247 { 21248 this.objList[i].node.style.fontSize = fontSize + 'px'; 21249 } 21250 } 21251 } 21252 21253 if(this.minFontSizeList.length > 0) 21254 this.setMinFont(); 21255 21256 this.removeTestNodes(); 21257 }, 21258 setMinFont : function() 21259 { 21260 for(var i = this.minFontSizeList.length-1; i>=0; i--) 21261 { 21262 this.minFontSizeList[i].style.fontSize = this.minFontSize + 'px'; 21263 } 21264 21265 this.minFontSize = 0; 21266 }, 21267 onResize : function() 21268 { 21269 var width = window.innerWidth || document.documentElement.clientWidth; 21270 21271 if(this.prevWindowSize > width) 21272 this.decrease(); 21273 21274 else if (this.prevWindowSize < width) 21275 this.increase(); 21276 21277 this.prevWindowSize = width; 21278 }, 21279 onAdaptiveResize : function() 21280 { 21281 var widthNode = this.objList[0].scaleBy || this.objList[0].node, 21282 computedStyles = getComputedStyle(widthNode), 21283 width = parseInt(computedStyles["width"]) - parseInt(computedStyles["paddingLeft"]) - parseInt(computedStyles["paddingRight"]); 21284 21285 if (this.prevWrapperSize > width) 21286 this.decrease(); 21287 else if (this.prevWrapperSize < width) 21288 this.increase(); 21289 21290 this.prevWrapperSize = width; 21291 }, 21292 textWrapperInsertText : function(node) 21293 { 21294 if(node.textContent){ 21295 this.textWrapper.textContent = node.textContent; 21296 return true; 21297 } 21298 else if(node.innerText) 21299 { 21300 this.textWrapper.innerText = node.innerText; 21301 return true; 21302 } 21303 else { 21304 return false; 21305 } 21306 }, 21307 textWrapperSetStyle : function(node) 21308 { 21309 this.textWrapper.style.fontFamily = getComputedStyle(node)["font-family"]; 21310 this.textWrapper.style.fontSize = getComputedStyle(node)["font-size"]; 21311 this.textWrapper.style.fontStyle = getComputedStyle(node)["font-style"]; 21312 this.textWrapper.style.fontWeight = getComputedStyle(node)["font-weight"]; 21313 this.textWrapper.style.lineHeight = getComputedStyle(node)["line-height"]; 21314 } 21315 }; 21316 21317 BX.FixFontSize.init = function(params) 21318 { 21319 return new BX.FixFontSize(params); 21320 }; 21321})(); 21322 21323})(); 21324//# 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.