File: /var/www/newfaith.focalat.com/new-faith/wp-content/themes/christian/assets/js/frontend.js
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 143:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
var _interopRequireDefault = __webpack_require__(600);
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = void 0;
var _classCallCheck2 = _interopRequireDefault(__webpack_require__(100));
var _createClass2 = _interopRequireDefault(__webpack_require__(870));
var cmsmastersAssetsLoader = /*#__PURE__*/function () {
function cmsmastersAssetsLoader() {
(0, _classCallCheck2.default)(this, cmsmastersAssetsLoader);
}
(0, _createClass2.default)(cmsmastersAssetsLoader, [{
key: "getScriptElement",
value: function getScriptElement(src) {
var scriptElement = document.createElement('script');
scriptElement.src = src;
return scriptElement;
}
}, {
key: "getStyleElement",
value: function getStyleElement(src) {
var styleElement = document.createElement('link');
styleElement.rel = 'stylesheet';
styleElement.href = src;
return styleElement;
}
}, {
key: "load",
value: function load(type, key) {
var _this = this;
var assetData = cmsmasters_localize_vars.assets_data[type][key];
if (!assetData.loader) {
assetData.loader = new Promise(function (resolve) {
var element = 'style' === type ? _this.getStyleElement(assetData.src) : _this.getScriptElement(assetData.src);
element.onload = function () {
return resolve(true);
};
var parent = 'head' === assetData.parent ? assetData.parent : 'body';
document[parent].appendChild(element);
});
}
return assetData.loader;
}
}]);
return cmsmastersAssetsLoader;
}();
exports["default"] = cmsmastersAssetsLoader;
/***/ }),
/***/ 354:
/***/ (() => {
"use strict";
// Detect Touch Device
(function () {
var isTouchDevice = ('ontouchstart' in document.documentElement);
if (isTouchDevice) {
jQuery('body').addClass('cmsmasters-is-touch');
}
})();
/***/ }),
/***/ 953:
/***/ (() => {
"use strict";
// Header Search
jQuery('.cmsmasters-header-search-button-toggle').on('click', function () {
jQuery('.cmsmasters-header-search-form').addClass('cmsmasters-show');
jQuery('.cmsmasters-header-search-form').find('input[type=search]').focus();
});
jQuery('.cmsmasters-header-search-form__close').on('click', function () {
jQuery('.cmsmasters-header-search-form').removeClass('cmsmasters-show');
});
/***/ }),
/***/ 331:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
var _interopRequireDefault = __webpack_require__(600);
var _mediaWidth = _interopRequireDefault(__webpack_require__(696));
// Header Top Toggle
jQuery('.cmsmasters-header-top-toggle__inner').on('click', function () {
var headerTopBut = jQuery(this),
headerTopOuter = jQuery('.cmsmasters-header-top__outer');
if (headerTopBut.hasClass('cmsmasters-active')) {
headerTopOuter.slideUp();
headerTopBut.removeClass('cmsmasters-active');
} else {
headerTopOuter.slideDown();
headerTopBut.addClass('cmsmasters-active');
}
});
jQuery(window).on('resize', function () {
if ((0, _mediaWidth.default)() > cmsmasters_localize_vars.mobile_max_breakpoint) {
jQuery('.cmsmasters-header-top-toggle__inner').removeClass('cmsmasters-active');
jQuery('.cmsmasters-header-top__outer').css('display', '');
}
});
/***/ }),
/***/ 668:
/***/ (() => {
"use strict";
jQuery.fn.cmsmastersMasonryGrid = function (args) {
var container = this;
if (container.length < 1) {
return;
}
var defaults = {
itemClass: '.cmsmasters-archive-post'
};
var obj = {};
obj = {
init: function init() {
obj.options = jQuery.extend({}, defaults, args);
obj.container = container;
obj.items = obj.container.find(obj.options.itemClass);
document.addEventListener('cmsmasters_customize_change_css_var', function () {
setTimeout(function () {
obj.run();
});
});
obj.container.imagesLoaded(function () {
obj.run();
});
jQuery(window).on('resize', function () {
setTimeout(function () {
obj.run();
}, 300);
});
},
getColumns: function getColumns() {
var stringSearch = ' ',
str = obj.container.css('grid-template-columns');
var count = 1;
for (var i = 0; i < str.length; count += +(stringSearch === str[i++])) {
void 0;
}
return count;
},
run: function run() {
var heights = [],
distanceFromTop = obj.container.position().top + parseInt(obj.container.css('margin-top'), 10),
columns = obj.getColumns(),
space = parseInt(obj.container.css('grid-row-gap'), 10);
obj.items.removeAttr('style');
obj.items.each(function (index) {
var row = Math.floor(index / columns),
$item = jQuery(this),
itemHeight = $item[0].getBoundingClientRect().height + space;
if (row) {
var itemPosition = $item.position(),
indexAtRow = index % columns;
var pullHeight = itemPosition.top - distanceFromTop - heights[indexAtRow];
pullHeight -= parseInt($item.css('margin-top'), 10);
pullHeight *= -1;
$item.css('margin-top', pullHeight + 'px');
heights[indexAtRow] += itemHeight;
} else {
heights.push(itemHeight);
}
});
}
};
obj.init();
};
jQuery('.cmsmasters-archive.cmsmasters-grid.cmsmasters-masonry').cmsmastersMasonryGrid();
/***/ }),
/***/ 696:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = cmsmastersMediaWidth;
// Media Width
function cmsmastersMediaWidth() {
var mediaWidth = parseInt(jQuery('.cmsmasters-responsive-width').css('width'));
return mediaWidth;
}
/***/ }),
/***/ 841:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
var _interopRequireDefault = __webpack_require__(600);
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = void 0;
var _classCallCheck2 = _interopRequireDefault(__webpack_require__(100));
var _createClass2 = _interopRequireDefault(__webpack_require__(870));
var cmsmastersPagePreloader = /*#__PURE__*/function () {
function cmsmastersPagePreloader() {
(0, _classCallCheck2.default)(this, cmsmastersPagePreloader);
this.$container = document.querySelector('.cmsmasters-page-preloader');
if (!this.$container) {
return;
}
this.classes = this.getClasses();
this.bindEvents();
}
(0, _createClass2.default)(cmsmastersPagePreloader, [{
key: "getClasses",
value: function getClasses() {
return {
entering: 'cmsmasters-page-preloader--entering',
entered: 'cmsmasters-page-preloader--entered',
exiting: 'cmsmasters-page-preloader--exiting',
preview: 'cmsmasters-page-preloader--preview'
};
}
}, {
key: "bindEvents",
value: function bindEvents() {
window.addEventListener('pageshow', this.onPageShow.bind(this));
window.addEventListener('beforeunload', this.onPageBeforeUnload.bind(this));
// window.addEventListener( 'pagehide', this.onPageBeforeUnload.bind( this ) );
// window.addEventListener( 'unload', this.onPageUnload.bind( this ) );
}
}, {
key: "onPageShow",
value: function onPageShow() {
var _this = this;
// To disable animation on back / forward click.
if (this.$container.classList.contains(this.classes.exiting)) {
this.$container.classList.add(this.classes.entered);
this.$container.classList.remove(this.classes.exiting);
}
// Animate the loader on page load.
this.animateState('entering').then(function () {
_this.$container.classList.add(_this.classes.entered);
});
}
}, {
key: "onPageBeforeUnload",
value: function onPageBeforeUnload() {
var _this2 = this;
this.$container.classList.remove(this.classes.entered);
this.animateState('exiting').then(function () {
_this2.$container.classList.add(_this2.classes.exiting);
});
}
}, {
key: "animateState",
value: function animateState(state) {
var _this$classes,
_this3 = this;
var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
var className = (_this$classes = this.classes) === null || _this$classes === void 0 ? void 0 : _this$classes[state];
if (!className) {
return new Promise(function (resolve, reject) {
reject(state);
});
}
// Remove and add the class again to force the animation, since it's using `animation-fill-mode: forwards`.
this.$container.classList.remove(className);
this.$container.classList.add(className);
var animationDuration = parseInt(this.getCssVar('--cmsmasters-page-preloader-animation-duration')) || 0;
return new Promise(function (resolve) {
setTimeout(function () {
_this3.$container.classList.remove(className);
resolve(state);
}, animationDuration + delay);
});
}
}, {
key: "getCssVar",
value: function getCssVar(variable) {
return window.getComputedStyle(document.documentElement).getPropertyValue(variable);
}
}]);
return cmsmastersPagePreloader;
}();
exports["default"] = cmsmastersPagePreloader;
new cmsmastersPagePreloader();
/***/ }),
/***/ 709:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
var _interopRequireDefault = __webpack_require__(600);
var _mediaWidth = _interopRequireDefault(__webpack_require__(696));
// Responsive Navigation
jQuery.fn.cmsmastersResponsiveNav = function (args) {
var defaults = {
submenu: 'ul.sub-menu, ul.children',
respButton: '.cmsmasters-burger-menu-button__toggle',
startWidth: cmsmasters_localize_vars.tablet_breakpoint
},
el = this;
var obj = {
init: function init() {
obj.options = jQuery.extend({}, defaults, args);
obj.el = el;
obj.params = {};
obj.params.subLinkToggle = void 0;
obj.setVars();
obj.restartNav();
},
setVars: function setVars() {
obj.params.parentNav = obj.el.closest('.cmsmasters-menu');
obj.params.submenu = obj.el.find(obj.options.submenu);
obj.params.subLink = obj.params.submenu.closest('li').find('> a');
obj.params.subText = obj.params.submenu.closest('li').find('> a:not([href])');
obj.params.respButton = jQuery(obj.options.respButton);
obj.params.startWidth = obj.options.startWidth;
obj.params.win = jQuery(window);
obj.params.trigger = false;
obj.params.counter = 0;
obj.startEvent();
obj.params.subLink.each(function () {
jQuery(this).addClass('cmsmasters-has-child-indicator').find('.cmsmasters-menu__item').append('<span class="cmsmasters-child-indicator cmsmasters-theme-icon-nav-arrow"></span>');
});
},
buildNav: function buildNav() {
obj.params.trigger = true;
obj.params.counter = 1;
obj.params.subLinkToggle = obj.params.subLink.find('.cmsmasters-child-indicator');
obj.params.submenu.hide();
obj.attachEvents();
},
restartNav: function restartNav() {
if (!obj.params.trigger && (0, _mediaWidth.default)() < obj.params.startWidth) {
obj.buildNav();
} else if (obj.params.trigger && (0, _mediaWidth.default)() >= obj.params.startWidth) {
obj.destroyNav();
}
},
resetNav: function resetNav() {
obj.params.subLinkToggle.removeClass('cmsmasters-active');
obj.params.submenu.hide();
},
destroyNav: function destroyNav() {
obj.params.subLink.each(function () {
jQuery(this).find('.cmsmasters-menu__item').find('.cmsmasters-child-indicator').removeClass('cmsmasters-active');
});
obj.params.submenu.css('display', '');
obj.params.respButton.removeClass('cmsmasters-active');
obj.params.parentNav.css('display', '');
obj.params.trigger = false;
obj.detachEvents();
},
startEvent: function startEvent() {
obj.params.win.on('resize', function () {
obj.restartNav();
});
},
attachEvents: function attachEvents() {
obj.params.subLinkToggle.on('click', function () {
if (jQuery(this).hasClass('cmsmasters-active')) {
jQuery(this).removeClass('cmsmasters-active').closest('li').find('ul.sub-menu, ul.children').hide();
jQuery(this).closest('li').find('span.cmsmasters-child-indicator').removeClass('cmsmasters-active');
} else {
jQuery(this).addClass('cmsmasters-active');
jQuery(this).closest('li').find('> ul.sub-menu, > ul.children').show();
}
return false;
});
obj.params.subText.on('click', function () {
jQuery(this).find('span.cmsmasters-child-indicator').trigger('click');
});
obj.params.respButton.on('click', function () {
if (obj.params.trigger && jQuery(this).hasClass('cmsmasters-active')) {
obj.resetNav();
}
if (jQuery(this).is(':not(.cmsmasters-active)')) {
obj.params.parentNav.css({
display: 'block'
});
jQuery(this).addClass('cmsmasters-active');
} else {
obj.params.parentNav.css({
display: 'none'
});
jQuery(this).removeClass('cmsmasters-active');
}
return false;
});
},
detachEvents: function detachEvents() {
obj.params.subLinkToggle.off('click');
obj.params.respButton.off('click');
}
};
obj.init();
};
jQuery('.cmsmasters-header-top-menu__list').cmsmastersResponsiveNav({
respButton: '.cmsmasters-header-top-burger-menu-button__toggle'
});
jQuery('.cmsmasters-header-mid-menu__list').cmsmastersResponsiveNav({
respButton: '.cmsmasters-header-mid-burger-menu-button__toggle'
});
jQuery('.cmsmasters-header-bot-menu__list').cmsmastersResponsiveNav({
respButton: '.cmsmasters-header-bot-burger-menu-button__toggle'
});
/***/ }),
/***/ 175:
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
var _interopRequireDefault = __webpack_require__(600);
var _regenerator = _interopRequireDefault(__webpack_require__(50));
var _asyncToGenerator2 = _interopRequireDefault(__webpack_require__(461));
var _assetsLoader = _interopRequireDefault(__webpack_require__(143));
// Swiper Slider Run
jQuery.fn.cmsmastersSwiperSlider = function () {
var el = this,
parentClass = '.cmsmasters-swiper',
defaults = {
loop: false,
pagination: {
clickable: true
},
autoHeight: true
};
var obj = {};
obj = {
init: function () {
var _init = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
var assetsLoader;
return _regenerator.default.wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
obj.container = "#".concat(el.attr('id'), " ").concat(parentClass, "__container");
obj.options = jQuery(el).data('options');
if ('none' !== obj.options.pagination) {
defaults.pagination.el = jQuery(el).find("".concat(parentClass, "__pagination-items")).get(0);
defaults.pagination.type = obj.options.pagination;
if ('bullets' === obj.options.pagination) {
if ('dynamic' === obj.options.bullets_type) {
defaults.pagination.dynamicBullets = true;
} else if ('numbered' === obj.options.bullets_type) {
defaults.pagination.renderBullet = function (index, className) {
return "<span class=\"".concat(className, "\">").concat(index + 1, "</span>");
};
}
}
}
if (true === obj.options.arrows) {
defaults.navigation = {
nextEl: jQuery(el).find("".concat(parentClass, "__button.cmsmasters-next")).get(0),
prevEl: jQuery(el).find("".concat(parentClass, "__button.cmsmasters-prev")).get(0)
};
}
obj.settings = jQuery.extend({}, defaults, el.data('settings'));
if (window.Swiper) {
_context.next = 9;
break;
}
assetsLoader = new _assetsLoader.default();
_context.next = 9;
return assetsLoader.load('script', 'swiper');
case 9:
obj.run_slider();
case 10:
case "end":
return _context.stop();
}
}, _callee);
}));
function init() {
return _init.apply(this, arguments);
}
return init;
}(),
run_slider: function run_slider() {
var swiper = new Swiper(obj.container, obj.settings);
if (true === obj.options.pause_on_hover) {
jQuery(obj.container).hover(function () {
swiper.autoplay.stop();
}, function () {
swiper.autoplay.start();
});
}
document.addEventListener('cmsmasters_customize_change_css_var', function () {
setTimeout(function () {
swiper.update();
});
});
}
};
obj.init();
};
jQuery('.cmsmasters-swiper').each(function () {
jQuery(this).cmsmastersSwiperSlider();
});
/***/ }),
/***/ 461:
/***/ ((module) => {
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _asyncToGenerator(fn) {
return function () {
var self = this,
args = arguments;
return new Promise(function (resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
/***/ }),
/***/ 100:
/***/ ((module) => {
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
/***/ }),
/***/ 870:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
var toPropertyKey = __webpack_require__(739);
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, toPropertyKey(descriptor.key), descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor;
}
module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
/***/ }),
/***/ 600:
/***/ ((module) => {
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
"default": obj
};
}
module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
/***/ }),
/***/ 609:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
var _typeof = (__webpack_require__(425)["default"]);
function _regeneratorRuntime() {
"use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
return exports;
}, module.exports.__esModule = true, module.exports["default"] = module.exports;
var exports = {},
Op = Object.prototype,
hasOwn = Op.hasOwnProperty,
defineProperty = Object.defineProperty || function (obj, key, desc) {
obj[key] = desc.value;
},
$Symbol = "function" == typeof Symbol ? Symbol : {},
iteratorSymbol = $Symbol.iterator || "@@iterator",
asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
function define(obj, key, value) {
return Object.defineProperty(obj, key, {
value: value,
enumerable: !0,
configurable: !0,
writable: !0
}), obj[key];
}
try {
define({}, "");
} catch (err) {
define = function define(obj, key, value) {
return obj[key] = value;
};
}
function wrap(innerFn, outerFn, self, tryLocsList) {
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
generator = Object.create(protoGenerator.prototype),
context = new Context(tryLocsList || []);
return defineProperty(generator, "_invoke", {
value: makeInvokeMethod(innerFn, self, context)
}), generator;
}
function tryCatch(fn, obj, arg) {
try {
return {
type: "normal",
arg: fn.call(obj, arg)
};
} catch (err) {
return {
type: "throw",
arg: err
};
}
}
exports.wrap = wrap;
var ContinueSentinel = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
var IteratorPrototype = {};
define(IteratorPrototype, iteratorSymbol, function () {
return this;
});
var getProto = Object.getPrototypeOf,
NativeIteratorPrototype = getProto && getProto(getProto(values([])));
NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
function defineIteratorMethods(prototype) {
["next", "throw", "return"].forEach(function (method) {
define(prototype, method, function (arg) {
return this._invoke(method, arg);
});
});
}
function AsyncIterator(generator, PromiseImpl) {
function invoke(method, arg, resolve, reject) {
var record = tryCatch(generator[method], generator, arg);
if ("throw" !== record.type) {
var result = record.arg,
value = result.value;
return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
invoke("next", value, resolve, reject);
}, function (err) {
invoke("throw", err, resolve, reject);
}) : PromiseImpl.resolve(value).then(function (unwrapped) {
result.value = unwrapped, resolve(result);
}, function (error) {
return invoke("throw", error, resolve, reject);
});
}
reject(record.arg);
}
var previousPromise;
defineProperty(this, "_invoke", {
value: function value(method, arg) {
function callInvokeWithMethodAndArg() {
return new PromiseImpl(function (resolve, reject) {
invoke(method, arg, resolve, reject);
});
}
return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
}
});
}
function makeInvokeMethod(innerFn, self, context) {
var state = "suspendedStart";
return function (method, arg) {
if ("executing" === state) throw new Error("Generator is already running");
if ("completed" === state) {
if ("throw" === method) throw arg;
return doneResult();
}
for (context.method = method, context.arg = arg;;) {
var delegate = context.delegate;
if (delegate) {
var delegateResult = maybeInvokeDelegate(delegate, context);
if (delegateResult) {
if (delegateResult === ContinueSentinel) continue;
return delegateResult;
}
}
if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
if ("suspendedStart" === state) throw state = "completed", context.arg;
context.dispatchException(context.arg);
} else "return" === context.method && context.abrupt("return", context.arg);
state = "executing";
var record = tryCatch(innerFn, self, context);
if ("normal" === record.type) {
if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
return {
value: record.arg,
done: context.done
};
}
"throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
}
};
}
function maybeInvokeDelegate(delegate, context) {
var methodName = context.method,
method = delegate.iterator[methodName];
if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
var record = tryCatch(method, delegate.iterator, context.arg);
if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
var info = record.arg;
return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
}
function pushTryEntry(locs) {
var entry = {
tryLoc: locs[0]
};
1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
}
function resetTryEntry(entry) {
var record = entry.completion || {};
record.type = "normal", delete record.arg, entry.completion = record;
}
function Context(tryLocsList) {
this.tryEntries = [{
tryLoc: "root"
}], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
}
function values(iterable) {
if (iterable) {
var iteratorMethod = iterable[iteratorSymbol];
if (iteratorMethod) return iteratorMethod.call(iterable);
if ("function" == typeof iterable.next) return iterable;
if (!isNaN(iterable.length)) {
var i = -1,
next = function next() {
for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
return next.value = undefined, next.done = !0, next;
};
return next.next = next;
}
}
return {
next: doneResult
};
}
function doneResult() {
return {
value: undefined,
done: !0
};
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
value: GeneratorFunctionPrototype,
configurable: !0
}), defineProperty(GeneratorFunctionPrototype, "constructor", {
value: GeneratorFunction,
configurable: !0
}), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
var ctor = "function" == typeof genFun && genFun.constructor;
return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
}, exports.mark = function (genFun) {
return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
}, exports.awrap = function (arg) {
return {
__await: arg
};
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
return this;
}), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
void 0 === PromiseImpl && (PromiseImpl = Promise);
var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
return result.done ? result.value : iter.next();
});
}, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
return this;
}), define(Gp, "toString", function () {
return "[object Generator]";
}), exports.keys = function (val) {
var object = Object(val),
keys = [];
for (var key in object) keys.push(key);
return keys.reverse(), function next() {
for (; keys.length;) {
var key = keys.pop();
if (key in object) return next.value = key, next.done = !1, next;
}
return next.done = !0, next;
};
}, exports.values = values, Context.prototype = {
constructor: Context,
reset: function reset(skipTempReset) {
if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
},
stop: function stop() {
this.done = !0;
var rootRecord = this.tryEntries[0].completion;
if ("throw" === rootRecord.type) throw rootRecord.arg;
return this.rval;
},
dispatchException: function dispatchException(exception) {
if (this.done) throw exception;
var context = this;
function handle(loc, caught) {
return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
}
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i],
record = entry.completion;
if ("root" === entry.tryLoc) return handle("end");
if (entry.tryLoc <= this.prev) {
var hasCatch = hasOwn.call(entry, "catchLoc"),
hasFinally = hasOwn.call(entry, "finallyLoc");
if (hasCatch && hasFinally) {
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
} else if (hasCatch) {
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
} else {
if (!hasFinally) throw new Error("try statement without catch or finally");
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
}
}
}
},
abrupt: function abrupt(type, arg) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
var finallyEntry = entry;
break;
}
}
finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
var record = finallyEntry ? finallyEntry.completion : {};
return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
},
complete: function complete(record, afterLoc) {
if ("throw" === record.type) throw record.arg;
return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
},
finish: function finish(finallyLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
}
},
"catch": function _catch(tryLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc === tryLoc) {
var record = entry.completion;
if ("throw" === record.type) {
var thrown = record.arg;
resetTryEntry(entry);
}
return thrown;
}
}
throw new Error("illegal catch attempt");
},
delegateYield: function delegateYield(iterable, resultName, nextLoc) {
return this.delegate = {
iterator: values(iterable),
resultName: resultName,
nextLoc: nextLoc
}, "next" === this.method && (this.arg = undefined), ContinueSentinel;
}
}, exports;
}
module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
/***/ }),
/***/ 64:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
var _typeof = (__webpack_require__(425)["default"]);
function _toPrimitive(input, hint) {
if (_typeof(input) !== "object" || input === null) return input;
var prim = input[Symbol.toPrimitive];
if (prim !== undefined) {
var res = prim.call(input, hint || "default");
if (_typeof(res) !== "object") return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (hint === "string" ? String : Number)(input);
}
module.exports = _toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
/***/ }),
/***/ 739:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
var _typeof = (__webpack_require__(425)["default"]);
var toPrimitive = __webpack_require__(64);
function _toPropertyKey(arg) {
var key = toPrimitive(arg, "string");
return _typeof(key) === "symbol" ? key : String(key);
}
module.exports = _toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
/***/ }),
/***/ 425:
/***/ ((module) => {
function _typeof(obj) {
"@babel/helpers - typeof";
return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
return typeof obj;
} : function (obj) {
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
}, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
}
module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
/***/ }),
/***/ 50:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
// TODO(Babel 8): Remove this file.
var runtime = __webpack_require__(609)();
module.exports = runtime;
// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
try {
regeneratorRuntime = runtime;
} catch (accidentalStrictMode) {
if (typeof globalThis === "object") {
globalThis.regeneratorRuntime = runtime;
} else {
Function("r", "regeneratorRuntime = r")(runtime);
}
}
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/************************************************************************/
var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
(() => {
"use strict";
/* Frontend Script */
__webpack_require__(143);
__webpack_require__(354);
__webpack_require__(696);
__webpack_require__(841);
__webpack_require__(668);
__webpack_require__(709);
__webpack_require__(331);
__webpack_require__(953);
__webpack_require__(175);
})();
/******/ })()
;
//# sourceMappingURL=frontend.js.map