vendor: 5,522 bytes, lines 1-108
1/*! elementor - v2.5.9 - 18-03-2019 */ 2/******/ (function(modules) { // webpackBootstrap 3/******/ // The module cache 4/******/ var installedModules = {}; 5/******/ 6/******/ // The require function 7/******/ function __webpack_require__(moduleId) { 8/******/ 9/******/ // Check if module is in cache 10/******/ if(installedModules[moduleId]) { 11/******/ return installedModules[moduleId].exports; 12/******/ } 13/******/ // Create a new module (and put it into the cache) 14/******/ var module = installedModules[moduleId] = { 15/******/ i: moduleId, 16/******/ l: false, 17/******/ exports: {} 18/******/ }; 19/******/ 20/******/ // Execute the module function 21/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 22/******/ 23/******/ // Flag the module as loaded 24/******/ module.l = true; 25/******/ 26/******/ // Return the exports of the module 27/******/ return module.exports; 28/******/ } 29/******/ 30/******/ 31/******/ // expose the modules object (__webpack_modules__) 32/******/ __webpack_require__.m = modules; 33/******/ 34/******/ // expose the module cache 35/******/ __webpack_require__.c = installedModules; 36/******/ 37/******/ // define getter function for harmony exports 38/******/ __webpack_require__.d = function(exports, name, getter) { 39/******/ if(!__webpack_require__.o(exports, name)) { 40/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 41/******/ } 42/******/ }; 43/******/ 44/******/ // define __esModule on exports 45/******/ __webpack_require__.r = function(exports) { 46/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 47/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 48/******/ } 49/******/ Object.defineProperty(exports, '__esModule', { value: true }); 50/******/ }; 51/******/ 52/******/ // create a fake namespace object 53/******/ // mode & 1: value is a module id, require it 54/******/ // mode & 2: merge all properties of value into the ns 55/******/ // mode & 4: return value when already ns object 56/******/ // mode & 8|1: behave like require 57/******/ __webpack_require__.t = function(value, mode) { 58/******/ if(mode & 1) value = __webpack_require__(value); 59/******/ if(mode & 8) return value; 60/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 61/******/ var ns = Object.create(null); 62/******/ __webpack_require__.r(ns); 63/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 64/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 65/******/ return ns; 66/******/ }; 67/******/ 68/******/ // getDefaultExport function for compatibility with non-harmony modules 69/******/ __webpack_require__.n = function(module) { 70/******/ var getter = module && module.__esModule ? 71/******/ function getDefault() { return module['default']; } : 72/******/ function getModuleExports() { return module; }; 73/******/ __webpack_require__.d(getter, 'a', getter); 74/******/ return getter; 75/******/ }; 76/******/ 77/******/ // Object.prototype.hasOwnProperty.call 78/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 79/******/ 80/******/ // __webpack_public_path__ 81/******/ __webpack_require__.p = ""; 82/******/ 83/******/ 84/******/ // Load entry module and return exports 85/******/ return __webpack_require__(__webpack_require__.s = 208); 86/******/ }) 87/************************************************************************/ 88/******/ ({ 89 90/***/ 17: 91/***/ (function(module, exports, __webpack_require__) { 92 93"use strict"; 94 95 96Object.defineProperty(exports, "__esModule", { 97 value: true 98}); 99 100var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 101 102var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 103 104function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 105 106function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 107 108function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { c
108onstructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 109 110var _class = function (_elementorModules$Vie) { 111 _inherits(_class, _elementorModules$Vie); 112 113 function _class() { 114 _classCallCheck(this, _class); 115 116 return _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments)); 117 } 118 119 _createClass(_class, [{ 120 key: 'getDefaultSettings', 121 value: function getDefaultSettings() { 122 return { 123 selectors: { 124 elements: '.elementor-element', 125 nestedDocumentElements: '.elementor .elementor-element' 126 }, 127 classes: { 128 editMode: 'elementor-edit-mode' 129 } 130 }; 131 } 132 }, { 133 key: 'getDefaultElements', 134 value: function getDefaultElements() { 135 var selectors = this.getSettings('selectors'); 136 137 return { 138 $elements: this.$element.find(selectors.elements).not(this.$element.find(selectors.nestedDocumentElements)) 139 }; 140 } 141 }, { 142 key: 'getDocumentSettings', 143 value: function getDocumentSettings(setting) { 144 var elementSettings = void 0; 145 146 if (this.isEdit) { 147 elementSettings = {}; 148 149 var settings = elementor.settings.page.model; 150 151 jQuery.each(settings.getActiveControls(), function (controlKey) { 152 elementSettings[controlKey] = settings.attributes[controlKey]; 153 }); 154 } else { 155 elementSettings = this.$element.data('elementor-settings') || {}; 156 } 157 158 return this.getItems(elementSettings, setting); 159 } 160 }, { 161 key: 'runElementsHandlers', 162 value: function runElementsHandlers() { 163 this.elements.$elements.each(function (index, element) { 164 return elementorFrontend.elementsHandler.runReadyTrigger(element); 165 }); 166 } 167 }, { 168 key: 'onInit', 169 value: function onInit() { 170 this.$element = this.getSettings('$element'); 171 172 _get(_class.prototype.__proto__ || Object.getPrototypeOf(_class.prototype), 'onInit', this).call(this); 173 174 this.isEdit = this.$element.hasClass(this.getSettings('classes.editMode')); 175 176 if (this.isEdit) { 177 elementor.settings.page.model.on('change', this.onSettingsChange.bind(this)); 178 } else { 179 this.runElementsHandlers(); 180 } 181 } 182 }, { 183 key: 'onSettingsChange', 184 value: function onSettingsChange() {} 185 }]); 186 187 return _class; 188}(elementorModules.ViewModule); 189 190exports.default = _class; 191 192/***/ }), 193 194/***/ 19: 195/***/ (function(module, exports, __webpack_require__) { 196 197"use strict"; 198 199 200Object.defineProperty(exports, "__esModule", { 201 value: true 202}); 203 204var _module = __webpack_require__(5); 205 206var _module2 = _interopRequireDefault(_module); 207 208var _viewModule = __webpack_require__(6); 209 210var _viewModule2 = _interopRequireDefault(_viewModule); 211 212var _masonry = __webpack_require__(20); 213 214var _masonry2 = _interopRequireDefault(_masonry); 215 216function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 217 218exports.default = window.elementorModules = { 219 Module: _module2.default, 220 ViewModule: _viewModule2.default, 221 utils: { 222 Masonry: _masonry2.default 223 } 224}; 225 226/***/ }), 227 228/***/ 20: 229/***/ (function(module, exports, __webpack_require__) { 230 231"use strict"; 232 233 234var _viewModule = __webpack_require__(6); 235 236var _viewModule2 = _interopRequireDefault(_viewModule); 237 238function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 239 240module.exports = _viewModule2.default.extend({ 241 242 getDefaultSettings: function getDefaultSettings() { 243 return { 244 container: null, 245 items: null, 246 columnsCount: 3, 247 verticalSpaceBetween: 30 248 }; 249 }, 250 251 getDefaultElements: function getDefaultElements() { 252 return { 253 $container: jQuery(this.getSettings('container')), 254 $items: jQuery(this.getSettings('items')) 255 }; 256 }, 257 258 run: function run() { 259 var heights = [], 260 distanceFromTop = this.elements.$container.position().top, 261 settings = this.getSettings(), 262 columnsCount = settings.columnsCount; 263 264 distanceFromTop += parseInt(this.elements.$container.css('margin-top'), 10); 265 266 this.elements.$items.each(function (index) { 267 var row = Math.floor(index / columnsCount), 268 $item = jQuery(this), 269 itemHeight = $item[0].getBoundingClientRect().height + settings.verticalSpaceBetween; 270 271 if (row) { 272 var itemPosition = $item.position(), 273 indexAtRow = index % columnsCount, 274 pullHeight = itemPosition.top - distanceFromTop - heights[indexAtRow]; 275 276 pullHeight -= parseInt($item.css('margin-top'), 10); 277 278 pullHeight *= -1; 279 280 $item.css('margin-top', pullHeight + 'px'); 281 282 heights[indexAtRow] += itemHeight; 283 } else { 284 heights.push(itemHeight); 285 } 286 }); 287 } 288}); 289 290/***/ }), 291 292/***/ 208: 293/***/ (function(module, exports, __webpack_require__) { 294 295"use strict"; 296 297 298var _modules = __webpack_require__(19); 299 300var _modules2 = _interopRequireDefault(_modules); 301 302var _document = __webpack_require__(17); 303 304var _document2 = _interopRequireDefault(_document); 305 306var _stretchElement = __webpack_require__(209); 307 308var _stretchElement2 = _interopRequireDefault(_stretchElement); 309 310var _base = __webpack_require__(210); 311 312var _base2 = _interopRequireDefault(_base); 313 314function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 315 316_modules2.default.frontend = { 317 Document: _document2.default, 318 tools: { 319 StretchElement: _stretchElement2.default 320 }, 321 handlers: { 322 Base: _base2.default 323 } 324}; 325 326/***/ }), 327 328/***/ 209: 329/***/ (function(module, exports, __webpack_require__) { 330 331"use strict"; 332 333 334module.exports = elementorModules.ViewModule.extend({ 335 getDefaultSettings: function getDefaultSettings() { 336 return { 337 element: null, 338 direction: elementorFrontend.config.is_rtl ? 'right' : 'left', 339 selectors: { 340 container: window 341 } 342 }; 343 }, 344 345 getDefaultElements: function getDefaultElements() { 346 return { 347 $element: jQuery(this.getSettings('element')) 348 }; 349 }, 350 351 stretch: function stretch() {
352 var containerSelector = this.getSettings('selectors.container'), 353 $container; 354 355 try { 356 $container = jQuery(containerSelector); 357 } catch (e) {} 358 359 if (!$container || !$container.length) { 360 $container = jQuery(this.getDefaultSettings().selectors.container); 361 } 362 363 this.reset(); 364 365 var $element = this.elements.$element, 366 containerWidth = $container.outerWidth(), 367 elementOffset = $element.offset().left, 368 isFixed = 'fixed' === $element.css('position'), 369 correctOffset = isFixed ? 0 : elementOffset; 370 371 if (window !== $container[0]) { 372 var containerOffset = $container.offset().left; 373 374 if (isFixed) { 375 correctOffset = containerOffset; 376 } 377 if (elementOffset > containerOffset) { 378 correctOffset = elementOffset - containerOffset; 379 } 380 } 381 382 if (!isFixed) { 383 if (elementorFrontend.config.is_rtl) { 384 correctOffset = containerWidth - ($element.outerWidth() + correctOffset); 385 } 386 387 correctOffset = -correctOffset; 388 } 389 390 var css = {}; 391 392 css.width = containerWidth + 'px'; 393 394 css[this.getSettings('direction')] = correctOffset + 'px'; 395 396 $element.css(css); 397 }, 398 399 reset: function reset() { 400 var css = {}; 401 402 css.width = ''; 403 404 css[this.getSettings('direction')] = ''; 405 406 this.elements.$element.css(css); 407 } 408}); 409 410/***/ }), 411 412/***/ 210: 413/***/ (function(module, exports, __webpack_require__) { 414 415"use strict"; 416 417 418module.exports = elementorModules.ViewModule.extend({ 419 $element: null, 420 421 editorListeners: null, 422 423 onElementChange: null, 424 425 onEditSettingsChange: null, 426 427 onGeneralSettingsChange: null, 428 429 onPageSettingsChange: null, 430 431 isEdit: null, 432 433 __construct: function __construct(settings) { 434 this.$element = settings.$element; 435 436 this.isEdit = this.$element.hasClass('elementor-element-edit-mode'); 437 438 if (this.isEdit) { 439 this.addEditorListeners(); 440 } 441 }, 442 443 findElement: function findElement(selector) { 444 var $mainElement = this.$element; 445 446 return $mainElement.find(selector).filter(function () { 447 return jQuery(this).closest('.elementor-element').is($mainElement); 448 }); 449 }, 450 451 getUniqueHandlerID: function getUniqueHandlerID(cid, $element) { 452 if (!cid) { 453 cid = this.getModelCID(); 454 } 455 456 if (!$element) { 457 $element = this.$element; 458 } 459 460 return cid + $element.attr('data-element_type') + this.getConstructorID(); 461 }, 462 463 initEditorListeners: function initEditorListeners() { 464 var self = this; 465 466 self.editorListeners = [{ 467 event: 'element:destroy', 468 to: elementor.channels.data, 469 callback: function callback(removedModel) { 470 if (removedModel.cid !== self.getModelCID()) { 471 return; 472 } 473 474 self.onDestroy(); 475 } 476 }]; 477 478 if (self.onElementChange) { 479 var elementType = self.getWidgetType() || self.getElementType(); 480 481 var eventName = 'change'; 482 483 if ('global' !== elementType) { 484 eventName += ':' + elementType; 485 } 486 487 self.editorListeners.push({ 488 event: eventName, 489 to: elementor.channels.editor, 490 callback: function callback(controlView, elementView) { 491 var elementViewHandlerID = self.getUniqueHandlerID(elementView.model.cid, elementView.$el); 492 493 if (elementViewHandlerID !== self.getUniqueHandlerID()) { 494 return; 495 } 496 497 self.onElementChange(controlView.model.get('name'), controlView, elementView); 498 } 499 }); 500 } 501 502 if (self.onEditSettingsChange) { 503 self.editorListeners.push({ 504 event: 'change:editSettings', 505 to: elementor.channels.editor, 506 callback: function callback(changedModel, view) { 507 if (view.model.cid !== self.getModelCID()) { 508 return; 509 } 510 511 self.onEditSettingsChange(Object.keys(changedModel.changed)[0]); 512 } 513 }); 514 } 515 516 ['page', 'general'].forEach(function (settingsType) { 517 var listenerMethodName = 'on' + settingsType[0].toUpperCase() + settingsType.slice(1) + 'SettingsChange'; 518 519 if (self[listenerMethodName]) { 520 self.editorListeners.push({ 521 event: 'change', 522 to: elementor.settings[settingsType].model, 523 callback: function callback(model) { 524 self[listenerMethodName](model.changed); 525 } 526 }); 527 } 528 }); 529 }, 530 531 getEditorListeners: function getEditorListeners() { 532 if (!this.editorListeners) { 533 this.initEditorListeners(); 534 } 535 536 return this.editorListeners; 537 }, 538 539 addEditorListeners: function addEditorListeners() { 540 var uniqueHandlerID = this.getUniqueHandlerID(); 541
542 this.getEditorListeners().forEach(function (listener) { 543 elementorFrontend.addListenerOnce(uniqueHandlerID, listener.event, listener.callback, listener.to); 544 }); 545 }, 546 547 removeEditorListeners: function removeEditorListeners() { 548 var uniqueHandlerID = this.getUniqueHandlerID(); 549 550 this.getEditorListeners().forEach(function (listener) { 551 elementorFrontend.removeListeners(uniqueHandlerID, listener.event, null, listener.to); 552 }); 553 }, 554 555 getElementType: function getElementType() { 556 return this.$element.data('element_type'); 557 }, 558 559 getWidgetType: function getWidgetType() { 560 var widgetType = this.$element.data('widget_type'); 561 562 if (!widgetType) { 563 return; 564 } 565 566 return widgetType.split('.')[0]; 567 }, 568 569 getID: function getID() { 570 return this.$element.data('id'); 571 }, 572 573 getModelCID: function getModelCID() { 574 return this.$element.data('model-cid'); 575 }, 576 577 getElementSettings: function getElementSettings(setting) { 578 var elementSettings = {}; 579 580 var modelCID = this.getModelCID(); 581 582 if (this.isEdit && modelCID) { 583 var settings = elementorFrontend.config.elements.data[modelCID], 584 attributes = settings.attributes; 585 586 var type = attributes.widgetType || attributes.elType; 587 588 if (attributes.isInner) { 589 type = 'inner-' + type; 590 } 591 592 var settingsKeys = elementorFrontend.config.elements.keys[type]; 593 594 if (!settingsKeys) { 595 settingsKeys = elementorFrontend.config.elements.keys[type] = []; 596 597 jQuery.each(settings.controls, function (name, control) { 598 if (control.frontend_available) { 599 settingsKeys.push(name); 600 } 601 }); 602 } 603 604 jQuery.each(settings.getActiveControls(), function (controlKey) { 605 if (-1 !== settingsKeys.indexOf(controlKey)) { 606 elementSettings[controlKey] = attributes[controlKey]; 607 } 608 }); 609 } else { 610 elementSettings = this.$element.data('settings') || {}; 611 } 612 613 return this.getItems(elementSettings, setting); 614 }, 615 616 getEditSettings: function getEditSettings(setting) { 617 var attributes = {}; 618 619 if (this.isEdit) { 620 attributes = elementorFrontend.config.elements.editSettings[this.getModelCID()].attributes; 621 } 622 623 return this.getItems(attributes, setting); 624 }, 625 626 getCurrentDeviceSetting: function getCurrentDeviceSetting(settingKey) { 627 return elementorFrontend.getCurrentDeviceSetting(this.getElementSettings(), settingKey); 628 }, 629 630 onDestroy: function onDestroy() { 631 this.removeEditorListeners(); 632 633 if (this.unbindEvents) { 634 this.unbindEvents(); 635 } 636 } 637}); 638 639/***/ }), 640 641/***/ 5: 642/***/ (function(module, exports, __webpack_require__) { 643 644"use strict"; 645 646 647var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; 648 649var Module = function Module() { 650 var $ = jQuery, 651 instanceParams = arguments, 652 self = this, 653 events = {}; 654 655 var settings = void 0; 656 657 var ensureClosureMethods = function ensureClosureMethods() { 658 $.each(self, function (methodName) { 659 var oldMethod = self[methodName]; 660 661 if ('function' !== typeof oldMethod) { 662 return; 663 } 664 665 self[methodName] = function () { 666 return oldMethod.apply(self, arguments); 667 }; 668 }); 669 }; 670 671 var initSettings = function initSettings() { 672 settings = self.getDefaultSettings(); 673 674 var instanceSettings = instanceParams[0]; 675 676 if (instanceSettings) { 677 $.extend(true, settings, instanceSettings); 678 } 679 }; 680 681 var init = function init() { 682 self.__construct.apply(self, instanceParams); 683 684 ensureClosureMethods(); 685 686 initSettings(); 687 688 self.trigger('init'); 689 }; 690 691 this.getItems = function (items, itemKey) { 692 if (itemKey) { 693 var keyStack = itemKey.split('.'), 694 currentKey = keyStack.splice(0, 1); 695 696 if (!keyStack.length) { 697 return items[currentKey]; 698 } 699 700 if (!items[currentKey]) { 701 return; 702 } 703 704 return this.getItems(items[currentKey], keyStack.join('.')); 705 } 706 707 return items; 708 }; 709 710 this.getSettings = function (setting) { 711 return this.getItems(settings, setting); 712 }; 713 714 this.setSettings = function (settingKey, value, settingsContainer) { 715 if (!settingsContainer) { 716 settingsContainer = settings; 717 } 718 719 if ('object' === (typeof settingKey === 'undefined' ? 'undefined' : _typeof(sett
719ingKey))) { 720 $.extend(settingsContainer, settingKey); 721 722 return self; 723 } 724 725 var keyStack = settingKey.split('.'), 726 currentKey = keyStack.splice(0, 1); 727 728 if (!keyStack.length) { 729 settingsContainer[currentKey] = value; 730 731 return self; 732 } 733 734 if (!settingsContainer[currentKey]) { 735 settingsContainer[currentKey] = {}; 736 } 737 738 return self.setSettings(keyStack.join('.'), value, settingsContainer[currentKey]); 739 }; 740 741 this.forceMethodImplementation = function (methodArguments) { 742 var functionName = methodArguments.callee.name; 743 744 throw new ReferenceError('The method ' + functionName + ' must to be implemented in the inheritor child.'); 745 }; 746 747 this.on = function (eventName, callback) { 748 if ('object' === (typeof eventName === 'undefined' ? 'undefined' : _typeof(eventName))) { 749 $.each(eventName, function (singleEventName) { 750 self.on(singleEventName, this); 751 }); 752 753 return self; 754 } 755 756 var eventNames = eventName.split(' '); 757 758 eventNames.forEach(function (singleEventName) { 759 if (!events[singleEventName]) { 760 events[singleEventName] = []; 761 } 762 763 events[singleEventName].push(callback); 764 }); 765 766 return self; 767 }; 768 769 this.off = function (eventName, callback) { 770 if (!events[eventName]) { 771 return self; 772 } 773 774 if (!callback) { 775 delete events[eventName]; 776 777 return self; 778 } 779 780 var callbackIndex = events[eventName].indexOf(callback); 781 782 if (-1 !== callbackIndex) { 783 delete events[eventName][callbackIndex]; 784 } 785 786 return self; 787 }; 788 789 this.trigger = function (eventName) { 790 var methodName = 'on' + eventName[0].toUpperCase() + eventName.slice(1), 791 params = Array.prototype.slice.call(arguments, 1); 792 793 if (self[methodName]) { 794 self[methodName].apply(self, params); 795 } 796 797 var callbacks = events[eventName]; 798 799 if (!callbacks) { 800 return self; 801 } 802 803 $.each(callbacks, function (index, callback) { 804 callback.apply(self, params); 805 }); 806 807 return self; 808 }; 809 810 init(); 811}; 812 813Module.prototype.__construct = function () {}; 814 815Module.prototype.getDefaultSettings = function () { 816 return {}; 817}; 818 819Module.extendsCount = 0; 820 821Module.extend = function (properties) { 822 var $ = jQuery, 823 parent = this; 824 825 var child = function child() { 826 return parent.apply(this, arguments); 827 }; 828 829 $.extend(child, parent); 830 831 child.prototype = Object.create($.extend({}, parent.prototype, properties)); 832 833 child.prototype.constructor = child; 834 835 /* 836 * Constructor ID is used to set an unique ID 837 * to every extend of the Module. 838 * 839 * It's useful in some cases such as unique 840 * listener for frontend handlers. 841 */ 842 var constructorID = ++Module.extendsCount; 843 844 child.prototype.getConstructorID = function () { 845 return constructorID; 846 }; 847 848 child.__super__ = parent.prototype; 849 850 return child; 851}; 852 853module.exports = Module; 854 855/***/ }), 856 857/***/ 6: 858/***/ (function(module, exports, __webpack_require__) { 859 860"use strict"; 861 862 863var _module = __webpack_require__(5); 864 865var _module2 = _interopRequireDefault(_module); 866 867function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 868 869module.exports = _module2.default.extend({ 870 elements: null, 871 872 getDefaultElements: function getDefaultElements() { 873 return {}; 874 }, 875 876 bindEvents: function bindEvents() {}, 877 878 onInit: function onInit() { 879 this.initElements(); 880 881 this.bindEvents(); 882 }, 883 884 initElements: function initElements() { 885 this.elements = this.getDefaultElements(); 886 } 887}); 888 889/***/ }) 890 891/******/ }); 892//# sourceMappingURL=frontend-modules.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.