vendor: 5,522 bytes, lines 1-108
1/*! elementor - v2.4.5 - 30-01-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 = 207); 86/******/ }) 87/************************************************************************/ 88/******/ ({ 89 90/***/ 18: 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/***/ 20: 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__(6); 205 206var _module2 = _interopRequireDefault(_module); 207 208var _viewModule = __webpack_require__(7); 209 210var _viewModule2 = _interopRequireDefault(_viewModule); 211 212var _masonry = __webpack_require__(21); 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/***/ 207: 229/***/ (function(module, exports, __webpack_require__) { 230 231"use strict"; 232 233 234var _modules = __webpack_require__(20); 235 236var _modules2 = _interopRequireDefault(_modules); 237 238var _document = __webpack_require__(18); 239 240var _document2 = _interopRequireDefault(_document); 241 242function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 243 244_modules2.default.frontend = { 245 Document: _document2.default, 246 tools: { 247 StretchElement: __webpack_require__(208) 248 } 249}; 250 251/***/ }), 252 253/***/ 208: 254/***/ (function(module, exports, __webpack_require__) { 255 256"use strict"; 257 258 259module.exports = elementorModules.ViewModule.extend({ 260 getDefaultSettings: function getDefaultSettings() { 261 return { 262 element: null, 263 direction: elementorFrontend.config.is_rtl ? 'right' : 'left', 264 selectors: { 265 container: window 266 } 267 }; 268 }, 269 270 getDefaultElements: function getDefaultElements() { 271 return { 272 $element: jQuery(this.getSettings('element')) 273 }; 274 }, 275 276 stretch: function stretch() {
277 var containerSelector = this.getSettings('selectors.container'), 278 $container; 279 280 try { 281 $container = jQuery(containerSelector); 282 } catch (e) {} 283 284 if (!$container || !$container.length) { 285 $container = jQuery(this.getDefaultSettings().selectors.container); 286 } 287 288 this.reset(); 289 290 var $element = this.elements.$element, 291 containerWidth = $container.outerWidth(), 292 elementOffset = $element.offset().left, 293 isFixed = 'fixed' === $element.css('position'), 294 correctOffset = isFixed ? 0 : elementOffset; 295 296 if (window !== $container[0]) { 297 var containerOffset = $container.offset().left; 298 299 if (isFixed) { 300 correctOffset = containerOffset; 301 } 302 if (elementOffset > containerOffset) { 303 correctOffset = elementOffset - containerOffset; 304 } 305 } 306 307 if (!isFixed) { 308 if (elementorFrontend.config.is_rtl) { 309 correctOffset = containerWidth - ($element.outerWidth() + correctOffset); 310 } 311 312 correctOffset = -correctOffset; 313 } 314 315 var css = {}; 316 317 css.width = containerWidth + 'px'; 318 319 css[this.getSettings('direction')] = correctOffset + 'px'; 320 321 $element.css(css); 322 }, 323 324 reset: function reset() { 325 var css = {}; 326 327 css.width = ''; 328 329 css[this.getSettings('direction')] = ''; 330 331 this.elements.$element.css(css); 332 } 333}); 334 335/***/ }), 336 337/***/ 21: 338/***/ (function(module, exports, __webpack_require__) { 339 340"use strict"; 341 342 343var _viewModule = __webpack_require__(7); 344 345var _viewModule2 = _interopRequireDefault(_viewModule); 346 347function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 348 349module.exports = _viewModule2.default.extend({ 350 351 getDefaultSettings: function getDefaultSettings() { 352 return { 353 container: null, 354 items: null, 355 columnsCount: 3, 356 verticalSpaceBetween: 30 357 }; 358 }, 359 360 getDefaultElements: function getDefaultElements() { 361 return { 362 $container: jQuery(this.getSettings('container')), 363 $items: jQuery(this.getSettings('items')) 364 }; 365 }, 366 367 run: function run() { 368 var heights = [], 369 distanceFromTop = this.elements.$container.position().top, 370 settings = this.getSettings(), 371 columnsCount = settings.columnsCount; 372 373 distanceFromTop += parseInt(this.elements.$container.css('margin-top'), 10); 374 375 this.elements.$items.each(function (index) { 376 var row = Math.floor(index / columnsCount), 377 $item = jQuery(this), 378 itemHeight = $item[0].getBoundingClientRect().height + settings.verticalSpaceBetween; 379 380 if (row) { 381 var itemPosition = $item.position(), 382 indexAtRow = index % columnsCount, 383 pullHeight = itemPosition.top - distanceFromTop - heights[indexAtRow]; 384 385 pullHeight -= parseInt($item.css('margin-top'), 10); 386 387 pullHeight *= -1; 388 389 $item.css('margin-top', pullHeight + 'px'); 390 391 heights[indexAtRow] += itemHeight; 392 } else { 393 heights.push(itemHeight); 394 } 395 }); 396 } 397}); 398 399/***/ }), 400 401/***/ 6: 402/***/ (function(module, exports, __webpack_require__) { 403 404"use strict"; 405 406 407var _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; }; 408 409var Module = function Module() { 410 var $ = jQuery, 411 instanceParams = arguments, 412 self = this, 413 events = {}; 414 415 var settings = void 0; 416 417 var ensureClosureMethods = function ensureClosureMethods() { 418 $.each(self, function (methodName) { 419 var oldMethod = self[methodName]; 420 421 if ('function' !== typeof oldMethod) { 422 return; 423 } 424 425 self[methodName] = function () { 426 return oldMethod.apply(self, arguments); 427 }; 428 }); 429 }; 430 431 var initSettings = function initSettings() { 432 settings = self.getDefaultSettings(); 433 434 var instanceSettings = instanceParams[0]; 435 436 if (instanceSettings) { 437 $.extend(settings, instanceSettings); 438 } 439 }; 440 441 var init = function init() { 442 self.__construct.apply(self, instanceParams); 443 444 ensureClosureMethods(); 445 446 initSettings(); 447 448 self.trigger('init'); 449 }; 450 451 this.getItems = function (items, itemKey) { 452 if (itemKey) { 453 var keyStack = itemKey.split('.'), 454 currentKey = keyStack.splice(0, 1); 455 456 if (!keyStack.length) { 457 return items[currentKey]; 458 } 459 460 if (!items[currentKey]) { 461 return; 462 } 463 464 return this.getItems(items[currentKey], keyStack.join('.')); 465 } 466 467 return items; 468 }; 469
470 this.getSettings = function (setting) { 471 return this.getItems(settings, setting); 472 }; 473 474 this.setSettings = function (settingKey, value, settingsContainer) { 475 if (!settingsContainer) { 476 settingsContainer = settings; 477 } 478 479 if ('object' === (typeof settingKey === 'undefined' ? 'undefined' : _typeof(settingKey))) { 480 $.extend(settingsContainer, settingKey); 481 482 return self; 483 } 484 485 var keyStack = settingKey.split('.'), 486 currentKey = keyStack.splice(0, 1); 487 488 if (!keyStack.length) { 489 settingsContainer[currentKey] = value; 490 491 return self; 492 } 493 494 if (!settingsContainer[currentKey]) { 495 settingsContainer[currentKey] = {}; 496 } 497 498 return self.setSettings(keyStack.join('.'), value, settingsContainer[currentKey]); 499 }; 500 501 this.forceMethodImplementation = function (methodArguments) { 502 var functionName = methodArguments.callee.name; 503 504 throw new ReferenceError('The method ' + functionName + ' must to be implemented in the inheritor child.'); 505 }; 506 507 this.on = function (eventName, callback) { 508 if ('object' === (typeof eventName === 'undefined' ? 'undefined' : _typeof(eventName))) { 509 $.each(eventName, function (singleEventName) { 510 self.on(singleEventName, this); 511 }); 512 513 return self; 514 } 515 516 var eventNames = eventName.split(' '); 517 518 eventNames.forEach(function (singleEventName) { 519 if (!events[singleEventName]) { 520 events[singleEventName] = []; 521 } 522 523 events[singleEventName].push(callback); 524 }); 525 526 return self; 527 }; 528 529 this.off = function (eventName, callback) { 530 if (!events[eventName]) { 531 return self; 532 } 533 534 if (!callback) { 535 delete events[eventName]; 536 537 return self; 538 } 539 540 var callbackIndex = events[eventName].indexOf(callback); 541 542 if (-1 !== callbackIndex) { 543 delete events[eventName][callbackIndex]; 544 } 545 546 return self; 547 }; 548 549 this.trigger = function (eventName) { 550 var methodName = 'on' + eventName[0].toUpperCase() + eventName.slice(1), 551 params = Array.prototype.slice.call(arguments, 1); 552 553 if (self[methodName]) { 554 self[methodName].apply(self, params); 555 } 556 557 var callbacks = events[eventName]; 558 559 if (!callbacks) { 560 return self; 561 } 562 563 $.each(callbacks, function (index, callback) { 564 callback.apply(self, params); 565 }); 566 567 return self; 568 }; 569 570 init(); 571}; 572 573Module.prototype.__construct = function () {}; 574 575Module.prototype.getDefaultSettings = function () { 576 return {}; 577}; 578 579Module.extendsCount = 0; 580 581Module.extend = function (properties) { 582 var $ = jQuery, 583 parent = this; 584 585 var child = function child() { 586 return parent.apply(this, arguments); 587 }; 588 589 $.extend(child, parent); 590 591 child.prototype = Object.create($.extend({}, parent.prototype, properties)); 592 593 child.prototype.constructor = child; 594 595 /* 596 * Constructor ID is used to set an unique ID 597 * to every extend of the Module. 598 * 599 * It's useful in some cases such as unique 600 * listener for frontend handlers. 601 */ 602 var constructorID = ++Module.extendsCount; 603 604 child.prototype.getConstructorID = function () { 605 return constructorID; 606 }; 607 608 child.__super__ = parent.prototype; 609 610 return child; 611}; 612 613module.exports = Module; 614 615/***/ }), 616 617/***/ 7: 618/***/ (function(module, exports, __webpack_require__) { 619 620"use strict"; 621 622 623var _module = __webpack_require__(6); 624 625var _module2 = _interopRequireDefault(_module); 626 627function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 628 629module.exports = _module2.default.extend({ 630 elements: null, 631 632 getDefaultElements: function getDefaultElements() { 633 return {}; 634 }, 635 636 bindEvents: function bindEvents() {}, 637 638 onInit: function onInit() { 639 this.initElements(); 640 641 this.bindEvents(); 642 }, 643 644 initElements: function initElements() { 645 this.elements = this.getDefaultElements(); 646 } 647}); 648 649/***/ }) 650 651/******/ }); 652//# 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.