/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

var _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; };

var _window$themehouse$co2;

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
// http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating

// requestAnimationFrame polyfill by Erik Möller. fixes from Paul Irish and Tino Zijdel

// MIT license

var polyfills = function polyfills() {
    var lastTime = 0;
    var vendors = ["ms", "moz", "webkit", "o"];
    for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
        window.requestAnimationFrame = window[vendors[x] + "RequestAnimationFrame"];
        window.cancelAnimationFrame = window[vendors[x] + "CancelAnimationFrame"] || window[vendors[x] + "CancelRequestAnimationFrame"];
    }

    if (!window.requestAnimationFrame) {
        window.requestAnimationFrame = function (callback) {
            var currTime = new Date().getTime();
            var timeToCall = Math.max(0, 16 - (currTime - lastTime));
            var id = window.setTimeout(function () {
                callback(currTime + timeToCall);
            }, timeToCall);
            lastTime = currTime + timeToCall;
            return id;
        };
    }

    if (!window.cancelAnimationFrame) {
        window.cancelAnimationFrame = function (id) {
            clearTimeout(id);
        };
    }

    (function (ElementProto) {
        if (typeof ElementProto.matches !== "function") {
            ElementProto.matches = ElementProto.msMatchesSelector || ElementProto.mozMatchesSelector || ElementProto.webkitMatchesSelector || function matches(selector) {
                var element = this;
                var elements = (element.document || element.ownerDocument).querySelectorAll(selector);
                var index = 0;

                while (elements[index] && elements[index] !== element) {
                    ++index;
                }

                return Boolean(elements[index]);
            };
        }

        if (typeof ElementProto.closest !== "function") {
            ElementProto.closest = function closest(selector) {
                var element = this;

                while (element && element.nodeType === 1) {
                    if (element.matches(selector)) {
                        return element;
                    }

                    element = element.parentNode;
                }
                return null;
            };
        }
    })(window.Element.prototype);

    if (typeof Object.assign !== "function") {
        // Must be writable: true, enumerable: false, configurable: true
        Object.defineProperty(Object, "assign", {
            value: function assign(target, varArgs) {
                // .length of function is 2
                "use strict";

                if (target == null) {
                    // TypeError if undefined or null
                    throw new TypeError("Cannot convert undefined or null to object");
                }

                var to = Object(target);

                for (var index = 1; index < arguments.length; index++) {
                    var nextSource = arguments[index];

                    if (nextSource != null) {
                        // Skip over if undefined or null
                        for (var nextKey in nextSource) {
                            // Avoid bugs when hasOwnProperty is shadowed
                            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
                                to[nextKey] = nextSource[nextKey];
                            }
                        }
                    }
                }
                return to;
            },
            writable: true,
            configurable: true
        });
    }
};

polyfills();

__webpack_require__(1);

var version = "20210125";

if (typeof window.themehouse === "undefined") {
    window.themehouse = {};
}

if (typeof window.themehouse.data === "undefined") {
    window.themehouse.data = {};
}

if (typeof window.themehouse.common === "undefined") {
    window.themehouse.common = {};
}

window.themehouse.common[version] = (_window$themehouse$co2 = {
    events: {},
    debug: false,
    values: {},
    timeout: null,

    measureScroll: function measureScroll() {
        window.themehouse.common[version].values.scrollX = window.scrollX;
        window.themehouse.common[version].values.scrollY = window.scrollY;
    },

    measureResize: function measureResize() {
        window.themehouse.common[version].values.innerWidth = window.innerWidth;
        window.themehouse.common[version].values.innerHeight = window.innerHeight;
        window.themehouse.common[version].values.offsetHeight = window.document.body.offsetHeight;
        window.themehouse.common[version].values.offsetWidth = window.document.body.offsetWidth;
    },

    register: function register(config) {
        if (typeof window.themehouse.common[version].events[config.phase] === "undefined") {
            window.themehouse.common[version].events[config.phase] = [];
        }

        window.themehouse.common[version].events[config.phase].push(config);

        window.themehouse.common[version].ensureRun();
    },


    ensureRun: function ensureRun() {
        if (window.themehouse.common[version].timeout !== null) {
            window.clearTimeout(window.themehouse.common[version].timeout);
        }
        window.themehouse.common[version].timeout = window.setTimeout(window.themehouse.common[version].initMissing, 500);
    },

    initMissing: function initMissing() {
        window.themehouse.common[version].timeout = null;
        var phases = ["initGet", "afterGet", "initSet", "afterSet"];
        for (var phaseIndex = 0, phaseLen = phases.length; phaseIndex < phaseLen; phaseIndex++) {
            var phase = phases[phaseIndex];
            var events = window.themehouse.common[version].events[phase];
            if (events) {
                for (var eventIndex = 0, eventLen = events.length; eventIndex < eventLen; eventIndex++) {
                    var event = events[eventIndex];
                    if (event.hasRun !== true) {
                        window.themehouse.common[version].runEvent(eventIndex, phase);
                    }
                }
            }
        }
    },

    init: function init() {
        var _this = this;

        var common = window.themehouse.common[version];
        var phaseTime = common.time();

        this.measureScroll();
        this.measureResize();
        window.themehouse.common[version].run("initGet");
        window.themehouse.common[version].run("initSet");

        window.addEventListener("resize", function () {
            _this.measureScroll();
            _this.measureResize();
            window.themehouse.common[version].run("resizeGet");
            window.themehouse.common[version].run("resizeSet");
        });
        window.addEventListener("scroll", function () {
            _this.measureScroll();
            window.themehouse.common[version].run("scrollGet");
            window.themehouse.common[version].run("scrollSet");
        });

        window.setTimeout(function () {
            window.themehouse.common[version].run("afterGet"); // low priority
            window.themehouse.common[version].run("afterSet");
        }, 0);

        if (common.debug) {
            console.log("Total Register: " + common.round(common.time() - phaseTime, 5) + " ms");
            console.log("=====================");
        }
    },
    measureWindowSize: function measureWindowSize() {
        window.themehouse.data.windowWidth = window.innerWidth;
        window.themehouse.data.windowHeight = window.innerHeight;
    }
}, _defineProperty(_window$themehouse$co2, "measureScroll", function measureScroll() {
    window.themehouse.data.scrollX = window.scrollX;
    window.themehouse.data.scrollY = window.scrollY;
}), _defineProperty(_window$themehouse$co2, "run", function run(phase) {
    var common = window.themehouse.common[version];
    var events = common.events[phase] || [];
    var debug = common.debug;
    var phaseTime = common.time();
    for (var i = 0, len = events.length; i < len; i++) {
        common.runEvent(i, phase);
    }

    if (debug) {
        console.log("Total " + phase + ": " + common.round(common.time() - phaseTime, 5) + " ms");
        console.log("=====================");
    }
}), _defineProperty(_window$themehouse$co2, "runEvent", function runEvent(eventIndex, phase) {
    var common = window.themehouse.common[version];
    var debug = common.debug;
    var _window$themehouse$co = window.themehouse.common[version].events[phase][eventIndex],
        func = _window$themehouse$co.func,
        addon = _window$themehouse$co.addon;


    window.themehouse.common[version].events[phase][eventIndex].hasRun = true;

    if (typeof func === "function") {
        var time = common.time();
        func();
        if (debug) {
            console.log(addon + "-" + phase + ": " + common.round(common.time() - time, 5) + " ms");
        }
    }
}), _defineProperty(_window$themehouse$co2, "time", function time() {
    if (window.themehouse.common[version] === false) return 0;
    if (typeof window.performance === "undefined") {
        return Date.now();
    }
    return window.performance.now ? window.performance.now() + window.performance.timing.navigationStart : Date.now();
}), _defineProperty(_window$themehouse$co2, "round", function round(num) {
    var points = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;

    return Math.round(num * Math.pow(10, points)) / Math.pow(10, points);
}), _defineProperty(_window$themehouse$co2, "fetch", function fetch(link) {
    window.jQuery.ajax(link);
}), _defineProperty(_window$themehouse$co2, "log", function log() {
    for (var _len = arguments.length, msg = Array(_len), _key = 0; _key < _len; _key++) {
        msg[_key] = arguments[_key];
    }

    console.log(msg); // eslint-disable-line no-console
}), _defineProperty(_window$themehouse$co2, "warn", function warn() {
    for (var _len2 = arguments.length, msg = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        msg[_key2] = arguments[_key2];
    }

    console.warn(msg); // eslint-disable-line no-console
}), _defineProperty(_window$themehouse$co2, "error", function error() {
    for (var _len3 = arguments.length, msg = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
        msg[_key3] = arguments[_key3];
    }

    console.error(msg); // eslint-disable-line no-console
}), _defineProperty(_window$themehouse$co2, "resizeFire", function resizeFire() {
    if (window.document.createEvent) {
        // W3C
        var ev = window.document.createEvent("Event");
        ev.initEvent("resize", true, true);
        window.dispatchEvent(ev);
    } else {
        // IE
        window.document.fireEvent("onresize");
    }
}), _window$themehouse$co2);

window.document.addEventListener("DOMContentLoaded", function () {
    var init = true;
    if (_typeof(window.themehouse) === "object") {
        if (_typeof(window.themehouse.settings) === "object") {
            if (_typeof(window.themehouse.settings.common) === "object") {
                if (_typeof(window.themehouse.settings.common[version]) === "object") {
                    var commonSettings = window.themehouse.settings.common[version];
                    if (commonSettings.init === false) {
                        init = false;
                    }
                }
            }
        }
    }
    if (init) {
        window.themehouse.common[version].init();
    }
});

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {/*!
Copyright (C) 2015 by WebReflection

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

*/
(function (Object, GOPS) {
  'use strict';

  // (C) Andrea Giammarchi - Mit Style

  if (GOPS in Object) { return; }

  var
    setDescriptor,
    G = typeof global === typeof G ? window : global,
    id = 0,
    random = String(Math.random()),
    prefix = '__\x01symbol:',
    prefixLength = prefix.length,
    internalSymbol = '__\x01symbol@@' + random,
    DP = 'defineProperty',
    DPies = 'defineProperties',
    GOPN = 'getOwnPropertyNames',
    GOPD = 'getOwnPropertyDescriptor',
    PIE = 'propertyIsEnumerable',
    gOPN = Object[GOPN],
    gOPD = Object[GOPD],
    create = Object.create,
    keys = Object.keys,
    freeze = Object.freeze || Object,
    defineProperty = Object[DP],
    $defineProperties = Object[DPies],
    descriptor = gOPD(Object, GOPN),
    ObjectProto = Object.prototype,
    hOP = ObjectProto.hasOwnProperty,
    pIE = ObjectProto[PIE],
    toString = ObjectProto.toString,
    addInternalIfNeeded = function (o, uid, enumerable) {
      if (!hOP.call(o, internalSymbol)) {
        defineProperty(o, internalSymbol, {
          enumerable: false,
          configurable: false,
          writable: false,
          value: {}
        });
      }
      o[internalSymbol]['@@' + uid] = enumerable; // eslint-disable-line no-param-reassign
    },
    createWithSymbols = function (proto, descriptors) {
      var self = create(proto);
      gOPN(descriptors).forEach(function (key) {
        if (propertyIsEnumerable.call(descriptors, key)) {
          $defineProperty(self, key, descriptors[key]);
        }
      });
      return self;
    },
    copyAsNonEnumerable = function (descriptor) {
      var newDescriptor = create(descriptor);
      newDescriptor.enumerable = false;
      return newDescriptor;
    },
    get = function get() {},
    onlyNonSymbols = function (name) {
      // eslint-disable-next-line eqeqeq
      return name != internalSymbol && !hOP.call(source, name);
    },
    onlySymbols = function (name) {
      // eslint-disable-next-line eqeqeq
      return name != internalSymbol && hOP.call(source, name);
    },
    propertyIsEnumerable = function propertyIsEnumerable(key) {
      var uid = String(key);
      return onlySymbols(uid) ? hOP.call(this, uid) && !!this[internalSymbol] && this[internalSymbol]['@@' + uid] : pIE.call(this, key);
    },
    setAndGetSymbol = function (uid) {
      var descriptor = {
        enumerable: false,
        configurable: true,
        get: get,
        set: function (value) {
          setDescriptor(this, uid, {
            enumerable: false,
            configurable: true,
            writable: true,
            value: value
          });
          addInternalIfNeeded(this, uid, true);
        }
      };
      defineProperty(ObjectProto, uid, descriptor);
      source[uid] = defineProperty(
        Object(uid),
        'constructor',
        sourceConstructor
      );
      return freeze(source[uid]);
    },
    Symbol = function Symbol(description) {
      if (this instanceof Symbol) {
        throw new TypeError('Symbol is not a constructor');
      }
      return setAndGetSymbol(prefix.concat(description || '', random, ++id));
    },
    source = create(null),
    sourceConstructor = { value: Symbol },
    sourceMap = function (uid) {
      return source[uid];
    },
    $defineProperty = function defineProp(o, key, descriptor) {
      var uid = String(key);
      if (onlySymbols(uid)) {
        setDescriptor(o, uid, descriptor.enumerable ? copyAsNonEnumerable(descriptor) : descriptor);
        addInternalIfNeeded(o, uid, !!descriptor.enumerable);
      } else {
        defineProperty(o, key, descriptor);
      }
      return o;
    },
    $getOwnPropertySymbols = function getOwnPropertySymbols(o) {
      return gOPN(o).filter(onlySymbols).map(sourceMap);
    };
  descriptor.value = $defineProperty;
  defineProperty(Object, DP, descriptor);

  descriptor.value = $getOwnPropertySymbols;
  defineProperty(Object, GOPS, descriptor);

  descriptor.value = function getOwnPropertyNames(o) {
    return gOPN(o).filter(onlyNonSymbols);
  };
  defineProperty(Object, GOPN, descriptor);

  descriptor.value = function defineProperties(o, descriptors) {
    var symbols = $getOwnPropertySymbols(descriptors);
    if (symbols.length) {
      keys(descriptors).concat(symbols).forEach(function (uid) {
        if (propertyIsEnumerable.call(descriptors, uid)) {
          $defineProperty(o, uid, descriptors[uid]);
        }
      });
    } else {
      $defineProperties(o, descriptors);
    }
    return o;
  };
  defineProperty(Object, DPies, descriptor);

  descriptor.value = propertyIsEnumerable;
  defineProperty(ObjectProto, PIE, descriptor);

  descriptor.value = Symbol;
  defineProperty(G, 'Symbol', descriptor);

  // defining `Symbol.for(key)`
  descriptor.value = function (key) {
    var uid = prefix.concat(prefix, key, random);
    return uid in ObjectProto ? source[uid] : setAndGetSymbol(uid);
  };
  defineProperty(Symbol, 'for', descriptor);

  // defining `Symbol.keyFor(symbol)`
  descriptor.value = function (symbol) {
    if (onlyNonSymbols(symbol)) { throw new TypeError(symbol + ' is not a symbol'); }
    if (!hOP.call(source, symbol)) {
      return void 0;
    }
    var label = symbol.slice(prefixLength);
    if (label.slice(0, prefixLength) !== prefix) {
      return void 0;
    }
    label = label.slice(prefixLength);
    if (label === random) {
      return void 0;
    }
    label = label.slice(0, label.length - random.length);
    return label.length > 0 ? label : void 0;
  };
  defineProperty(Symbol, 'keyFor', descriptor);

  descriptor.value = function getOwnPropertyDescriptor(o, key) {
    var descriptor = gOPD(o, key);
    if (descriptor && onlySymbols(key)) {
      descriptor.enumerable = propertyIsEnumerable.call(o, key);
    }
    return descriptor;
  };
  defineProperty(Object, GOPD, descriptor);

  descriptor.value = function (proto, descriptors) {
    return arguments.length === 1 || typeof descriptors === 'undefined' ? create(proto) : createWithSymbols(proto, descriptors);
  };
  defineProperty(Object, 'create', descriptor);

  descriptor.value = function () {
    var str = toString.call(this);
    return str === '[object String]' && onlySymbols(this) ? '[object Symbol]' : str;
  };
  defineProperty(ObjectProto, 'toString', descriptor);

  try { // fails in few pre ES 5.1 engines
    if (
      create(defineProperty({}, prefix, {
        get: function () {
          return defineProperty(this, prefix, { value: true })[prefix];
        }
      }))[prefix] === true
    ) {
      setDescriptor = defineProperty;
    } else {
      throw 'IE11'; // eslint-disable-line no-throw-literal
    }
  } catch (o_O) { // eslint-disable-line camelcase
    setDescriptor = function (o, key, descriptor) {
      var protoDescriptor = gOPD(ObjectProto, key);
      delete ObjectProto[key];
      defineProperty(o, key, descriptor);
      defineProperty(ObjectProto, key, protoDescriptor);
    };
  }

}(Object, 'getOwnPropertySymbols'));

(function (O, Symbol) {
  'use strict';

  var
    dP = O.defineProperty,
    ObjectProto = O.prototype,
    toString = ObjectProto.toString,
    toStringTag = 'toStringTag',
    descriptor;
  [
    'iterator', // A method returning the default iterator for an object. Used by for...of.
    'match', // A method that matches against a string, also used to determine if an object may be used as a regular expression. Used by String.prototype.match().
    'replace', // A method that replaces matched substrings of a string. Used by String.prototype.replace().
    'search', // A method that returns the index within a string that matches the regular expression. Used by String.prototype.search().
    'split', // A method that splits a string at the indices that match a regular expression. Used by String.prototype.split().
    'hasInstance', // A method determining if a constructor object recognizes an object as its instance. Used by instanceof.
    'isConcatSpreadable', // A Boolean value indicating if an object should be flattened to its array elements. Used by Array.prototype.concat().
    'unscopables', // An Array of string values that are property values. These are excluded from the with environment bindings of the associated objects.
    'species', // A constructor function that is used to create derived objects.
    'toPrimitive', // A method converting an object to a primitive value.
    toStringTag // A string value used for the default description of an object. Used by Object.prototype.toString().
  ].forEach(function (name) {
    if (!(name in Symbol)) {
      dP(Symbol, name, { value: Symbol(name) });
      if (name === toStringTag) {
        descriptor = O.getOwnPropertyDescriptor(ObjectProto, 'toString');
        descriptor.value = function () {
          var str = toString.call(this);
          var tst = this == null ? this : this[Symbol.toStringTag];
          return tst == null ? str : '[object ' + tst + ']';
        };
        dP(ObjectProto, 'toString', descriptor);
      }
    }
  });
}(Object, Symbol));

(function (Si, AP, SP) {

  function returnThis() { return this; }

  /*
   * make Arrays usable as iterators
   * so that other iterables can copy same logic
   */
  if (!AP[Si]) {
    // eslint-disable-next-line no-param-reassign
    AP[Si] = function () {
      var
        i = 0,
        self = this,
        iterator = {
          next: function next() {
            var done = self.length <= i;
            return done ? { done: done } : { done: done, value: self[i++] };
          }
        };
      iterator[Si] = returnThis;
      return iterator;
    };
  }

  /*
   * make Strings usable as iterators
   * to simplify Array.from and for/of like loops
   */
  if (!SP[Si]) {
    // eslint-disable-next-line no-param-reassign
    SP[Si] = function () {
      var
        fromCodePoint = String.fromCodePoint,
        self = this,
        i = 0,
        length = self.length,
        iterator = {
          next: function next() {
            var
              done = length <= i,
              c = done ? '' : fromCodePoint(self.codePointAt(i));
            i += c.length;
            return done ? { done: done } : { done: done, value: c };
          }
        };
      iterator[Si] = returnThis;
      return iterator;
    };
  }

}(Symbol.iterator, Array.prototype, String.prototype));

module.exports = Object.getOwnPropertySymbols;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))

/***/ }),
/* 2 */
/***/ (function(module, exports) {

var g;

// This works in non-strict mode
g = (function() {
	return this;
})();

try {
	// This works if eval is allowed (see CSP)
	g = g || Function("return this")() || (1,eval)("this");
} catch(e) {
	// This works if the window reference is available
	if(typeof window === "object")
		g = window;
}

// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}

module.exports = g;


/***/ })
/******/ ]);