vue-scroll-fixed-navbar
Version:
A Simple vue scroll fixed navbar package which will help you to fix the top header or navbar while scrolling the screen.
4,946 lines • 140 kB
JavaScript
module.exports =
/******/ (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, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // 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 = "fb15");
/******/ })
/************************************************************************/
/******/ ({
/***/ "06cf":
/***/ (function(module, exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__("83ab");
var propertyIsEnumerableModule = __webpack_require__("d1e7");
var createPropertyDescriptor = __webpack_require__("5c6c");
var toIndexedObject = __webpack_require__("fc6a");
var toPrimitive = __webpack_require__("c04e");
var has = __webpack_require__("5135");
var IE8_DOM_DEFINE = __webpack_require__("0cfb");
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
// `Object.getOwnPropertyDescriptor` method
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
O = toIndexedObject(O);
P = toPrimitive(P, true);
if (IE8_DOM_DEFINE) try {
return $getOwnPropertyDescriptor(O, P);
} catch (error) { /* empty */ }
if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);
};
/***/ }),
/***/ "0cfb":
/***/ (function(module, exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__("83ab");
var fails = __webpack_require__("d039");
var createElement = __webpack_require__("cc12");
// Thank's IE8 for his funny defineProperty
module.exports = !DESCRIPTORS && !fails(function () {
// eslint-disable-next-line es/no-object-defineproperty -- requied for testing
return Object.defineProperty(createElement('div'), 'a', {
get: function () { return 7; }
}).a != 7;
});
/***/ }),
/***/ "1d80":
/***/ (function(module, exports) {
// `RequireObjectCoercible` abstract operation
// https://tc39.es/ecma262/#sec-requireobjectcoercible
module.exports = function (it) {
if (it == undefined) throw TypeError("Can't call method on " + it);
return it;
};
/***/ }),
/***/ "1dde":
/***/ (function(module, exports, __webpack_require__) {
var fails = __webpack_require__("d039");
var wellKnownSymbol = __webpack_require__("b622");
var V8_VERSION = __webpack_require__("2d00");
var SPECIES = wellKnownSymbol('species');
module.exports = function (METHOD_NAME) {
// We can't use this feature detection in V8 since it causes
// deoptimization and serious performance degradation
// https://github.com/zloirock/core-js/issues/677
return V8_VERSION >= 51 || !fails(function () {
var array = [];
var constructor = array.constructor = {};
constructor[SPECIES] = function () {
return { foo: 1 };
};
return array[METHOD_NAME](Boolean).foo !== 1;
});
};
/***/ }),
/***/ "23cb":
/***/ (function(module, exports, __webpack_require__) {
var toInteger = __webpack_require__("a691");
var max = Math.max;
var min = Math.min;
// Helper for a popular repeating case of the spec:
// Let integer be ? ToInteger(index).
// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
module.exports = function (index, length) {
var integer = toInteger(index);
return integer < 0 ? max(integer + length, 0) : min(integer, length);
};
/***/ }),
/***/ "23e7":
/***/ (function(module, exports, __webpack_require__) {
var global = __webpack_require__("da84");
var getOwnPropertyDescriptor = __webpack_require__("06cf").f;
var createNonEnumerableProperty = __webpack_require__("9112");
var redefine = __webpack_require__("6eeb");
var setGlobal = __webpack_require__("ce4e");
var copyConstructorProperties = __webpack_require__("e893");
var isForced = __webpack_require__("94ca");
/*
options.target - name of the target object
options.global - target is the global object
options.stat - export as static methods of target
options.proto - export as prototype methods of target
options.real - real prototype method for the `pure` version
options.forced - export even if the native feature is available
options.bind - bind methods to the target, required for the `pure` version
options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
options.unsafe - use the simple assignment of property instead of delete + defineProperty
options.sham - add a flag to not completely full polyfills
options.enumerable - export as enumerable property
options.noTargetGet - prevent calling a getter on target
*/
module.exports = function (options, source) {
var TARGET = options.target;
var GLOBAL = options.global;
var STATIC = options.stat;
var FORCED, target, key, targetProperty, sourceProperty, descriptor;
if (GLOBAL) {
target = global;
} else if (STATIC) {
target = global[TARGET] || setGlobal(TARGET, {});
} else {
target = (global[TARGET] || {}).prototype;
}
if (target) for (key in source) {
sourceProperty = source[key];
if (options.noTargetGet) {
descriptor = getOwnPropertyDescriptor(target, key);
targetProperty = descriptor && descriptor.value;
} else targetProperty = target[key];
FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
// contained in target
if (!FORCED && targetProperty !== undefined) {
if (typeof sourceProperty === typeof targetProperty) continue;
copyConstructorProperties(sourceProperty, targetProperty);
}
// add a flag to not completely full polyfills
if (options.sham || (targetProperty && targetProperty.sham)) {
createNonEnumerableProperty(sourceProperty, 'sham', true);
}
// extend global
redefine(target, key, sourceProperty, options);
}
};
/***/ }),
/***/ "241c":
/***/ (function(module, exports, __webpack_require__) {
var internalObjectKeys = __webpack_require__("ca84");
var enumBugKeys = __webpack_require__("7839");
var hiddenKeys = enumBugKeys.concat('length', 'prototype');
// `Object.getOwnPropertyNames` method
// https://tc39.es/ecma262/#sec-object.getownpropertynames
// eslint-disable-next-line es/no-object-getownpropertynames -- safe
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
return internalObjectKeys(O, hiddenKeys);
};
/***/ }),
/***/ "298e":
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0ba310cd-vue-loader-template"}!./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/cache-loader/dist/cjs.js??ref--0-0!./node_modules/vue-loader/lib??vue-loader-options!./src/components/VueScrollFixedNavbar.vue?vue&type=template&id=c7ff881c&
var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('Preview',{attrs:{"isFixed":_vm.isFixed}},[_c('div',{attrs:{"id":"myHeader"}},[_vm._t("default")],2)])}
var staticRenderFns = []
// CONCATENATED MODULE: ./src/components/VueScrollFixedNavbar.vue?vue&type=template&id=c7ff881c&
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.slice.js
var es_array_slice = __webpack_require__("fb6a");
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.freeze.js
var es_object_freeze = __webpack_require__("dca8");
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js
function _taggedTemplateLiteral(strings, raw) {
if (!raw) {
raw = strings.slice(0);
}
return Object.freeze(Object.defineProperties(strings, {
raw: {
value: Object.freeze(raw)
}
}));
}
// CONCATENATED MODULE: ./node_modules/vue-styled-components/dist/vue-styled-components.es.js
var chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
var generateAlphabeticName = function generateAlphabeticName(code) {
var lastDigit = chars[code % chars.length];
return code > chars.length ? "".concat(generateAlphabeticName(Math.floor(code / chars.length))).concat(lastDigit) : lastDigit;
};
var interleave = (function (strings, interpolations) {
return interpolations.reduce(function (array, interp, i) {
return array.concat(interp, strings[i + 1]);
}, [strings[0]]);
});
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a 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);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
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;
}
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
if (enumerableOnly) symbols = symbols.filter(function (sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
});
keys.push.apply(keys, symbols);
}
return keys;
}
function _objectSpread2(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i] != null ? arguments[i] : {};
if (i % 2) {
ownKeys(Object(source), true).forEach(function (key) {
_defineProperty(target, key, source[key]);
});
} else if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys(Object(source)).forEach(function (key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
}
return target;
}
function _toConsumableArray(arr) {
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
function _iterableToArray(iter) {
if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(n);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
/**
* lodash (Custom Build) <https://lodash.com/>
* Build: `lodash modularize exports="npm" -o ./`
* Copyright jQuery Foundation and other contributors <https://jquery.org/>
* Released under MIT license <https://lodash.com/license>
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
*/
/** `Object#toString` result references. */
var objectTag = '[object Object]';
/**
* Checks if `value` is a host object in IE < 9.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a host object, else `false`.
*/
function isHostObject(value) {
// Many host objects are `Object` objects that can coerce to strings
// despite having improperly defined `toString` methods.
var result = false;
if (value != null && typeof value.toString != 'function') {
try {
result = !!(value + '');
} catch (e) {}
}
return result;
}
/**
* Creates a unary function that invokes `func` with its argument transformed.
*
* @private
* @param {Function} func The function to wrap.
* @param {Function} transform The argument transform.
* @returns {Function} Returns the new function.
*/
function overArg(func, transform) {
return function (arg) {
return func(transform(arg));
};
}
/** Used for built-in method references. */
var funcProto = Function.prototype,
objectProto = Object.prototype;
/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;
/** Used to check objects for own properties. */
var vue_styled_components_es_hasOwnProperty = objectProto.hasOwnProperty;
/** Used to infer the `Object` constructor. */
var objectCtorString = funcToString.call(Object);
/**
* Used to resolve the
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
* of values.
*/
var objectToString = objectProto.toString;
/** Built-in value references. */
var getPrototype = overArg(Object.getPrototypeOf, Object);
/**
* Checks if `value` is object-like. A value is object-like if it's not `null`
* and has a `typeof` result of "object".
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
* @example
*
* _.isObjectLike({});
* // => true
*
* _.isObjectLike([1, 2, 3]);
* // => true
*
* _.isObjectLike(_.noop);
* // => false
*
* _.isObjectLike(null);
* // => false
*/
function isObjectLike(value) {
return !!value && typeof value == 'object';
}
/**
* Checks if `value` is a plain object, that is, an object created by the
* `Object` constructor or one with a `[[Prototype]]` of `null`.
*
* @static
* @memberOf _
* @since 0.8.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
* @example
*
* function Foo() {
* this.a = 1;
* }
*
* _.isPlainObject(new Foo);
* // => false
*
* _.isPlainObject([1, 2, 3]);
* // => false
*
* _.isPlainObject({ 'x': 0, 'y': 0 });
* // => true
*
* _.isPlainObject(Object.create(null));
* // => true
*/
function isPlainObject(value) {
if (!isObjectLike(value) || objectToString.call(value) != objectTag || isHostObject(value)) {
return false;
}
var proto = getPrototype(value);
if (proto === null) {
return true;
}
var Ctor = vue_styled_components_es_hasOwnProperty.call(proto, 'constructor') && proto.constructor;
return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
}
var lodash_isplainobject = isPlainObject;
var _uppercasePattern = /([A-Z])/g;
var msPattern = /^ms-/;
function hyphenate(string) {
return string.replace(_uppercasePattern, '-$1').toLowerCase();
}
function hyphenateStyleName(string) {
return hyphenate(string).replace(msPattern, '-ms-');
}
var hyphenateStyleName_1 = hyphenateStyleName;
var objToCss = function objToCss(obj, prevKey) {
var css = Object.keys(obj).map(function (key) {
if (lodash_isplainobject(obj[key])) return objToCss(obj[key], key);
return "".concat(hyphenateStyleName_1(key), ": ").concat(obj[key], ";");
}).join(' ');
return prevKey ? "".concat(prevKey, " {\n ").concat(css, "\n}") : css;
};
var flatten = function flatten(chunks, executionContext) {
return chunks.reduce(function (ruleSet, chunk) {
if (chunk === undefined || chunk === null || chunk === false || chunk === '') return ruleSet;
if (Array.isArray(chunk)) return [].concat(_toConsumableArray(ruleSet), _toConsumableArray(flatten(chunk, executionContext)));
if (typeof chunk === 'function') {
return executionContext ? ruleSet.concat.apply(ruleSet, _toConsumableArray(flatten([chunk(executionContext)], executionContext))) : ruleSet.concat(chunk);
}
return ruleSet.concat(lodash_isplainobject(chunk) ? objToCss(chunk) : chunk.toString());
}, []);
};
var css = (function (rules) {
for (var _len = arguments.length, interpolations = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
interpolations[_key - 1] = arguments[_key];
}
return flatten(interleave(rules, interpolations));
});
function last(arr) {
return arr[arr.length - 1];
}
function sheetForTag(tag) {
for (var i = 0; i < document.styleSheets.length; i++) {
if (document.styleSheets[i].ownerNode === tag) {
return document.styleSheets[i];
}
}
}
var isDev = function (x) {
return x === 'development' || !x;
}("development");
var isTest = "development" === 'test';
var isBrowser = typeof document !== 'undefined' && !isTest;
var oldIE = function () {
if (isBrowser) {
var div = document.createElement('div');
div.innerHTML = '<!--[if lt IE 10]><i></i><![endif]-->';
return div.getElementsByTagName('i').length === 1;
}
}();
function makeStyleTag() {
var tag = document.createElement('style');
tag.type = 'text/css';
tag.appendChild(document.createTextNode(''));
(document.head || document.getElementsByTagName('head')[0]).appendChild(tag);
return tag;
}
var StyleSheet = function () {
function StyleSheet() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref$speedy = _ref.speedy,
speedy = _ref$speedy === void 0 ? !isDev && !isTest : _ref$speedy,
_ref$maxLength = _ref.maxLength,
maxLength = _ref$maxLength === void 0 ? isBrowser && oldIE ? 4000 : 65000 : _ref$maxLength;
_classCallCheck(this, StyleSheet);
this.isSpeedy = speedy;
this.sheet = undefined;
this.tags = [];
this.maxLength = maxLength;
this.ctr = 0;
}
_createClass(StyleSheet, [{
key: "inject",
value: function inject() {
var _this = this;
if (this.injected) {
throw new Error('already injected stylesheet!');
}
if (isBrowser) {
this.tags[0] = makeStyleTag();
this.sheet = sheetForTag(this.tags[0]);
} else {
this.sheet = {
cssRules: [],
insertRule: function insertRule(rule) {
var serverRule = {
cssText: rule
};
_this.sheet.cssRules.push(serverRule);
return {
serverRule: serverRule,
appendRule: function appendRule(newCss) {
return serverRule.cssText += newCss;
}
};
}
};
}
this.injected = true;
}
}, {
key: "speedy",
value: function speedy(bool) {
if (this.ctr !== 0) {
throw new Error("cannot change speedy mode after inserting any rule to sheet. Either call speedy(".concat(bool, ") earlier in your app, or call flush() before speedy(").concat(bool, ")"));
}
this.isSpeedy = !!bool;
}
}, {
key: "_insert",
value: function _insert(rule) {
try {
this.sheet.insertRule(rule, this.sheet.cssRules.length);
} catch (e) {
if (isDev) {
console.warn('whoops, illegal rule inserted', rule);
}
}
}
}, {
key: "insert",
value: function insert(rule) {
var insertedRule;
if (isBrowser) {
if (this.isSpeedy && this.sheet.insertRule) {
this._insert(rule);
} else {
var textNode = document.createTextNode(rule);
last(this.tags).appendChild(textNode);
insertedRule = {
textNode: textNode,
appendRule: function appendRule(newCss) {
return textNode.appendData(newCss);
}
};
if (!this.isSpeedy) {
this.sheet = sheetForTag(last(this.tags));
}
}
} else {
insertedRule = this.sheet.insertRule(rule);
}
this.ctr++;
if (isBrowser && this.ctr % this.maxLength === 0) {
this.tags.push(makeStyleTag());
this.sheet = sheetForTag(last(this.tags));
}
return insertedRule;
}
}, {
key: "flush",
value: function flush() {
if (isBrowser) {
this.tags.forEach(function (tag) {
return tag.parentNode.removeChild(tag);
});
this.tags = [];
this.sheet = null;
this.ctr = 0;
} else {
this.sheet.cssRules = [];
}
this.injected = false;
}
}, {
key: "rules",
value: function rules() {
if (!isBrowser) {
return this.sheet.cssRules;
}
var arr = [];
this.tags.forEach(function (tag) {
return arr.splice.apply(arr, [arr.length, 0].concat(_toConsumableArray(Array.from(sheetForTag(tag).cssRules))));
});
return arr;
}
}]);
return StyleSheet;
}();
var StyleSheet$1 = function () {
function StyleSheet$1() {
_classCallCheck(this, StyleSheet$1);
this.globalStyleSheet = new StyleSheet({
speedy: false
});
this.componentStyleSheet = new StyleSheet({
speedy: false,
maxLength: 40
});
}
_createClass(StyleSheet$1, [{
key: "inject",
value: function inject() {
this.globalStyleSheet.inject();
this.componentStyleSheet.inject();
}
}, {
key: "flush",
value: function flush() {
if (this.globalStyleSheet.sheet) this.globalStyleSheet.flush();
if (this.componentStyleSheet.sheet) this.componentStyleSheet.flush();
}
}, {
key: "insert",
value: function insert(rule) {
var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
global: false
};
var sheet = opts.global ? this.globalStyleSheet : this.componentStyleSheet;
return sheet.insert(rule);
}
}, {
key: "rules",
value: function rules() {
return this.globalStyleSheet.rules().concat(this.componentStyleSheet.rules());
}
}, {
key: "injected",
get: function get() {
return this.globalStyleSheet.injected && this.componentStyleSheet.injected;
}
}]);
return StyleSheet$1;
}();
var styleSheet = new StyleSheet$1();
function unwrapExports (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var hash = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = doHash; // murmurhash2 via https://gist.github.com/raycmorgan/588423
function doHash(str, seed) {
var m = 0x5bd1e995;
var r = 24;
var h = seed ^ str.length;
var length = str.length;
var currentIndex = 0;
while (length >= 4) {
var k = UInt32(str, currentIndex);
k = Umul32(k, m);
k ^= k >>> r;
k = Umul32(k, m);
h = Umul32(h, m);
h ^= k;
currentIndex += 4;
length -= 4;
}
switch (length) {
case 3:
h ^= UInt16(str, currentIndex);
h ^= str.charCodeAt(currentIndex + 2) << 16;
h = Umul32(h, m);
break;
case 2:
h ^= UInt16(str, currentIndex);
h = Umul32(h, m);
break;
case 1:
h ^= str.charCodeAt(currentIndex);
h = Umul32(h, m);
break;
}
h ^= h >>> 13;
h = Umul32(h, m);
h ^= h >>> 15;
return h >>> 0;
}
function UInt32(str, pos) {
return str.charCodeAt(pos++) + (str.charCodeAt(pos++) << 8) + (str.charCodeAt(pos++) << 16) + (str.charCodeAt(pos) << 24);
}
function UInt16(str, pos) {
return str.charCodeAt(pos++) + (str.charCodeAt(pos++) << 8);
}
function Umul32(n, m) {
n = n | 0;
m = m | 0;
var nlo = n & 0xffff;
var nhi = n >>> 16;
var res = nlo * m + ((nhi * m & 0xffff) << 16) | 0;
return res;
}
});
var hashStr = unwrapExports(hash);
var replaceWhitespace = function replaceWhitespace(str) {
return str.replace(/\s|\\n/g, '');
};
var makeAnimation = function makeAnimation(name, css) {
return "\n@keyframes ".concat(name, " {\n ").concat(css, "\n}\n");
};
var keyframes = (function (css) {
var name = generateAlphabeticName(hashStr(replaceWhitespace(JSON.stringify(css))));
var animation = makeAnimation(name, css);
if (!styleSheet.injected) styleSheet.inject();
styleSheet.insert(animation);
return name;
});
var stylis = createCommonjsModule(function (module, exports) {
/*
* __ ___
* _____/ /___ __/ (_)____
* / ___/ __/ / / / / / ___/
* (__ ) /_/ /_/ / / (__ )
* /____/\__/\__, /_/_/____/
* /____/
*
* light - weight css preprocessor @licence MIT
*/
(function (factory) {
/* eslint-disable */
module['exports'] = factory(null) ;
})(
/** @param {*=} options */
function factory(options) {
/**
* Notes
*
* The ['<method name>'] pattern is used to support closure compiler
* the jsdoc signatures are also used to the same effect
*
* ----
*
* int + int + int === n4 [faster]
*
* vs
*
* int === n1 && int === n2 && int === n3
*
* ----
*
* switch (int) { case ints...} [faster]
*
* vs
*
* if (int == 1 && int === 2 ...)
*
* ----
*
* The (first*n1 + second*n2 + third*n3) format used in the property parser
* is a simple way to hash the sequence of characters
* taking into account the index they occur in
* since any number of 3 character sequences could produce duplicates.
*
* On the other hand sequences that are directly tied to the index of the character
* resolve a far more accurate measure, it's also faster
* to evaluate one condition in a switch statement
* than three in an if statement regardless of the added math.
*
* This allows the vendor prefixer to be both small and fast.
*/
var nullptn = /^\0+/g;
/* matches leading null characters */
var formatptn = /[\0\r\f]/g;
/* matches new line, null and formfeed characters */
var colonptn = /: */g;
/* splits animation rules */
var cursorptn = /zoo|gra/;
/* assert cursor varient */
var transformptn = /([,: ])(transform)/g;
/* vendor prefix transform, older webkit */
var animationptn = /,+\s*(?![^(]*[)])/g;
/* splits multiple shorthand notation animations */
var propertiesptn = / +\s*(?![^(]*[)])/g;
/* animation properties */
var elementptn = / *[\0] */g;
/* selector elements */
var selectorptn = /,\r+?/g;
/* splits selectors */
var andptn = /([\t\r\n ])*\f?&/g;
/* match & */
var escapeptn = /:global\(((?:[^\(\)\[\]]*|\[.*\]|\([^\(\)]*\))*)\)/g;
/* matches :global(.*) */
var invalidptn = /\W+/g;
/* removes invalid characters from keyframes */
var keyframeptn = /@(k\w+)\s*(\S*)\s*/;
/* matches @keyframes $1 */
var plcholdrptn = /::(place)/g;
/* match ::placeholder varient */
var readonlyptn = /:(read-only)/g;
/* match :read-only varient */
var beforeptn = /\s+(?=[{\];=:>])/g;
/* matches \s before ] ; = : */
var afterptn = /([[}=:>])\s+/g;
/* matches \s after characters [ } = : */
var tailptn = /(\{[^{]+?);(?=\})/g;
/* matches tail semi-colons ;} */
var whiteptn = /\s{2,}/g;
/* matches repeating whitespace */
var pseudoptn = /([^\(])(:+) */g;
/* pseudo element */
var writingptn = /[svh]\w+-[tblr]{2}/;
/* match *gradient property */
var supportsptn = /\(\s*(.*)\s*\)/g;
/* match supports (groups) */
var propertyptn = /([\s\S]*?);/g;
/* match properties leading semicolon */
var selfptn = /-self|flex-/g;
/* match flex- and -self in align-self: flex-*; */
var pseudofmt = /[^]*?(:[rp][el]a[\w-]+)[^]*/;
/* match tail whitspace */
var dimensionptn = /stretch|:\s*\w+\-(?:conte|avail)/;
/* match max/min/fit-content, fill-available */
var imgsrcptn = /([^-])(image-set\()/;
/* vendors */
var webkit = '-webkit-';
var moz = '-moz-';
var ms = '-ms-';
/* character codes */
var SEMICOLON = 59;
/* ; */
var CLOSEBRACES = 125;
/* } */
var OPENBRACES = 123;
/* { */
var OPENPARENTHESES = 40;
/* ( */
var CLOSEPARENTHESES = 41;
/* ) */
var OPENBRACKET = 91;
/* [ */
var CLOSEBRACKET = 93;
/* ] */
var NEWLINE = 10;
/* \n */
var CARRIAGE = 13;
/* \r */
var TAB = 9;
/* \t */
var AT = 64;
/* @ */
var SPACE = 32;
/* */
var AND = 38;
/* & */
var DASH = 45;
/* - */
var UNDERSCORE = 95;
/* _ */
var STAR = 42;
/* * */
var COMMA = 44;
/* , */
var COLON = 58;
/* : */
var SINGLEQUOTE = 39;
/* ' */
var DOUBLEQUOTE = 34;
/* " */
var FOWARDSLASH = 47;
/* / */
var GREATERTHAN = 62;
/* > */
var PLUS = 43;
/* + */
var TILDE = 126;
/* ~ */
var NULL = 0;
/* \0 */
var FORMFEED = 12;
/* \f */
var VERTICALTAB = 11;
/* \v */
/* special identifiers */
var KEYFRAME = 107;
/* k */
var MEDIA = 109;
/* m */
var SUPPORTS = 115;
/* s */
var PLACEHOLDER = 112;
/* p */
var READONLY = 111;
/* o */
var IMPORT = 105;
/* <at>i */
var CHARSET = 99;
/* <at>c */
var DOCUMENT = 100;
/* <at>d */
var PAGE = 112;
/* <at>p */
var column = 1;
/* current column */
var line = 1;
/* current line numebr */
var pattern = 0;
/* :pattern */
var cascade = 1;
/* #id h1 h2 vs h1#id h2#id */
var prefix = 1;
/* vendor prefix */
var escape = 1;
/* escape :global() pattern */
var compress = 0;
/* compress output */
var semicolon = 0;
/* no/semicolon option */
var preserve = 0;
/* preserve empty selectors */
/* empty reference */
var array = [];
/* plugins */
var plugins = [];
var plugged = 0;
var should = null;
/* plugin context */
var POSTS = -2;
var PREPS = -1;
var UNKWN = 0;
var PROPS = 1;
var BLCKS = 2;
var ATRUL = 3;
/* plugin newline context */
var unkwn = 0;
/* keyframe animation */
var keyed = 1;
var key = '';
/* selector namespace */
var nscopealt = '';
var nscope = '';
/**
* Compile
*
* @param {Array<string>} parent
* @param {Array<string>} current
* @param {string} body
* @param {number} id
* @param {number} depth
* @return {string}
*/
function compile(parent, current, body, id, depth) {
var bracket = 0;
/* brackets [] */
var comment = 0;
/* comments /* // or /* */
var parentheses = 0;
/* functions () */
var quote = 0;
/* quotes '', "" */
var first = 0;
/* first character code */
var second = 0;
/* second character code */
var code = 0;
/* current character code */
var tail = 0;
/* previous character code */
var trail = 0;
/* character before previous code */
var peak = 0;
/* previous non-whitespace code */
var counter = 0;
/* count sequence termination */
var context = 0;
/* track current context */
var atrule = 0;
/* track @at-rule context */
var pseudo = 0;
/* track pseudo token index */
var caret = 0;
/* current character index */
var format = 0;
/* control character formating context */
var insert = 0;
/* auto semicolon insertion */
var invert = 0;
/* inverted selector pattern */
var length = 0;
/* generic length address */
var eof = body.length;
/* end of file(length) */
var eol = eof - 1;
/* end of file(characters) */
var char = '';
/* current character */
var chars = '';
/* current buffer of characters */
var child = '';
/* next buffer of characters */
var out = '';
/* compiled body */
var children = '';
/* compiled children */
var flat = '';
/* compiled leafs */
var selector;
/* generic selector address */
var result;
/* generic address */
// ...build body
while (caret < eof) {
code = body.charCodeAt(caret); // eof varient
if (caret === eol) {
// last character + noop context, add synthetic padding for noop context to terminate
if (comment + quote + parentheses + bracket !== 0) {
if (comment !== 0) {
code = comment === FOWARDSLASH ? NEWLINE : FOWARDSLASH;
}
quote = parentheses = bracket = 0;
eof++;
eol++;
}
}
if (comment + quote + parentheses + bracket === 0) {
// eof varient
if (caret === eol) {
if (format > 0) {
chars = chars.replace(formatptn, '');
}
if (chars.trim().length > 0) {
switch (code) {
case SPACE:
case TAB:
case SEMICOLON:
case CARRIAGE:
case NEWLINE:
{
break;
}
default:
{
chars += body.charAt(caret);
}
}
code = SEMICOLON;
}
} // auto semicolon insertion
if (insert === 1) {
switch (code) {
// false flags
case OPENBRACES:
case CLOSEBRACES:
case SEMICOLON:
case DOUBLEQUOTE:
case SINGLEQUOTE:
case OPENPARENTHESES:
case CLOSEPARENTHESES:
case COMMA:
{
insert = 0;
}
// ignore
case TAB:
case CARRIAGE:
case NEWLINE:
case SPACE:
{
break;
}
// valid
default:
{
insert = 0;
length = caret;
first = code;
caret--;
code = SEMICOLON;
while (length < eof) {
switch (body.charCodeAt(length++)) {
case NEWLINE:
case CARRIAGE:
case SEMICOLON:
{
++caret;
code = first;
length = eof;
break;
}
case COLON:
{
if (format > 0) {
++caret;
code = first;
}
}
case OPENBRACES:
{
length = eof;
}
}
}
}
}
} // token varient
switch (code) {
case OPENBRACES:
{
chars = chars.trim();
first = chars.charCodeAt(0);
counter = 1;
length = ++caret;
while (caret < eof) {
switch (code = body.charCodeAt(caret)) {
case OPENBRACES:
{
counter++;
break;
}
case CLOSEBRACES:
{
counter--;
break;
}
case FOWARDSLASH:
{
switch (second = body.charCodeAt(caret + 1)) {
// /*, //
case STAR:
case FOWARDSLASH:
{
caret = delimited(second, caret, eol, body);
}
}
break;
}
// given "[" === 91 & "]" === 93 hence forth 91 + 1 + 1 === 93
case OPENBRACKET:
{
code++;
}
// given "(" === 40 & ")" === 41 hence forth 40 + 1 === 41
case OPENPARENTHESES:
{
code++;
}
// quote tail delimiter is identical to the head delimiter hence noop,
// fallthrough clauses have been shifted to the correct tail delimiter
case DOUBLEQUOTE:
case SINGLEQUOTE:
{
while (caret++ < eol) {
if (body.charCodeAt(caret) === code) {
break;
}
}
}
}
if (counter === 0) {
break;
}
caret++;
}
child = body.substring(length, caret);
if (first === NULL) {
first = (chars = chars.replace(nullptn, '').trim()).charCodeAt(0);
}
switch (first) {
// @at-rule
case AT:
{
if (format > 0) {
chars = chars.replace(formatptn, '');
}
second = chars.charCodeAt(1);
switch (second) {
case DOCUMENT:
case MEDIA:
case SUPPORTS:
case DASH:
{
selector = current;
break;
}
default:
{
selector = array;
}
}
child = compile(current, selector, child, second, depth + 1);
length = child.length; // preserve empty @at-rule
if (preserve > 0 && length === 0) {
length = chars.length;
} // execute plugins, @at-rule context
if (plugged > 0) {
selector = select(array, chars, invert);
result = proxy(ATRUL, child, selector, current, line, column, length, second, depth, id);
chars = selector.join('');
if (result !== void 0) {
if ((length = (child = result.trim()).length) === 0) {
second = 0;
child = '';
}
}
}
if (length > 0) {
switch (second) {
case SUPPORTS:
{
chars = chars.replace(supportsptn, supports);
}
case DOCUMENT:
case MEDIA:
case DASH:
{
child = chars + '{' + child + '}';
break;
}
case KEYFRAME:
{
chars = chars.replace(keyframeptn, '$1 $2' + (keyed > 0 ? key : ''));
child = chars + '{' + child + '}';
if (prefix === 1 || prefix === 2 && vendor('@' + child, 3)) {
child = '@' + webkit + child + '@' + child;
} else {
child = '@' + child;
}
break;
}
default:
{
child = chars + child;
if (id === PAGE) {
child = (out += child, '');
}
}
}
} else {
child = '';
}
break;
}
// selector
default:
{
child = compile(current, select(current, chars, invert), child, id, depth + 1);
}
}
children += child; // reset
context = 0;
insert = 0;
pseudo = 0;
format = 0;
invert = 0;
atrule = 0;
chars = '';
child = '';
code = body.charCodeAt(++caret);
break;
}
case CLOSEBRACES:
case SEMICOLON:
{
chars = (format > 0 ? chars.replace(formatptn, '') : chars).trim();
if ((length = chars.length) > 1) {
// monkey-patch missing colon
if (pseudo === 0) {
first = chars.charCodeAt(0); // first character is a letter or dash, buffer has a space character
if (first === DASH || first > 96 && first < 123) {
length = (chars = chars.replace(' ', ':')).length;
}
} // execute plugins, property context
if (plugged > 0) {
if ((result = proxy(PROPS, chars, current, parent, line, column, out.length, id, depth, id)) !== void 0) {
if ((length = (chars = result.trim()).length) === 0) {
chars = '\0\0';
}
}
}
first = chars.charCodeAt(0);
second = chars.charCodeAt(1);
switch (first) {
case NULL:
{
break;
}
case AT:
{
if (second === IMPORT || second === CHARSET) {
flat += chars + body.charAt(caret);
break;
}
}
default:
{
if (chars.charCodeAt(length - 1) === COLON) {
break;
}
out += property(chars, first, second, chars.charCodeAt(2));
}
}
} // reset
context = 0;
insert = 0;
pseudo = 0;
format = 0;
invert = 0;
chars = '';
code = body.charCodeAt(++caret);
break;
}
}
} // parse characters
switch (code) {
case CARRIAGE:
case NEWLINE:
{
// auto insert semicolon
if (comment + quote + parentheses + bracket + semicolon === 0) {
// valid non-whitespace characters that
// may precede a newline
switch (peak) {
case CLOSEPARENTHESES:
case SINGLEQUOTE:
case DOUBLEQUOTE:
case AT:
case TILDE:
case GREATERTHAN:
case STAR:
case PLUS:
case FOWARDSLASH:
case DASH:
case COLON:
case COMMA:
case SEMICOLON:
case OPENBRACES:
case CLOSEBRACES:
{
break;
}
default:
{
// current buffer has a colon
if (pseudo > 0) {
insert = 1;
}
}
}
} // terminate line comment
if (comment === FOWARDSLASH) {
comment = 0;
} else if (cascade + context === 0 && id !== KEYFRAME && chars.length > 0) {
format = 1;
chars += '\0';
} // execute plugins, newline context
if (plugged * unkwn > 0) {
proxy(UNKWN, chars, current, parent, line, column, out.length, id, depth, id);
} // next line, reset column position
column = 1;
line++;
break;
}
case SEMICOLON:
case CLOSEBRACES:
{
if (comment + quote + parentheses + bracket === 0) {
column++;
break;
}
}
default:
{
// increment column position
column++; // current character
char = body.charAt(caret); // remove comments, escape functions, strings, attributes and prepare selectors
switch (code) {
case TAB:
case SPACE:
{
if (quote + bracket + comment === 0) {
switch (tail) {
case COMMA:
case COLON:
case TAB:
case SPACE:
{
char = '';
break;
}
default:
{
if (code !== SPACE) {
char = ' ';
}
}
}
}
break;
}
// escape breaking control characters
case NULL:
{
char = '\\0';
break;
}
case FORMFEED:
{
char = '\\f';
break;
}
case VERTICALTAB:
{
char = '\\v';
break;
}
// &
case AND:
{
// inverted selector pattern i.e html &
if (quote + comment + bracket === 0 && cascade > 0) {
invert = 1;
format = 1;
char = '\f' + char;
}
break;
}
// ::p<l>aceholder, l
// :read-on<l>y, l
case 108:
{
if (quote + comment + bracket + pattern === 0 && pseudo > 0) {
switch (caret - pseudo) {
// ::placeholder
case 2:
{
if (tail === PLACEHOLDER && body.charCodeAt(caret - 3) === COLON) {
pattern = tail;
}
}
// :read-only
case 8:
{
if (trail === READONLY) {
pattern = trail;
}
}
}
}
break;
}
// :<pattern>
case COLON:
{
if (quote + comment + bracket === 0) {
pseudo = caret;
}
break;
}
// selectors
case COMMA:
{
if (comment + parentheses + quote + bracket === 0) {
format = 1;
char += '\r';
}
break;
}
// quotes
case DOUBLEQUOTE:
case SINGLEQUOTE:
{
if (comment === 0) {
quote = quote === code ? 0 : quote === 0 ? code : quote;
}
break;
}
// attributes
case OPENBRACKET:
{
if (quote + comment + parentheses === 0) {
bracket++;
}
break;
}
case CLOSEBRACKET:
{
if (quote + comment + parentheses === 0) {
bracket--;
}
break;
}
// functions
case CLOSEPARENTHESES:
{
if (quote + comment + bracket === 0) {
parentheses--;
}
break;
}
case OPENPARENTHESES:
{
if (quote + comment + bracket === 0) {
if (context === 0) {
switch (tail * 2 + trail * 3) {
// :matches
case 533:
{
break;
}
// :global, :not, :nth-child etc...
default:
{
counter = 0;
context = 1;
}
}
}
parentheses++;
}
break;
}
case AT:
{
if (comment + parentheses + quote + bracket + pseudo + atrule === 0) {
atrule = 1;
}
break;
}
// block/line comments
case STAR:
case FOWARDSLASH:
{
if (quote + bracket + parentheses > 0) {
break;
}
switch (comment) {
// initialize line/block comment context
case 0:
{
switch (code * 2 + body.charCodeAt(caret + 1) * 3) {
// //
case 235:
{
comment = FOWARDSLASH;
break;
}
// /*
case 220:
{
length = caret;
comment = STAR;
break;
}
}
break;
}
// end block comment context
case STAR:
{
if (code === FOWARDSLASH && tail === STAR && length + 2 !== caret) {
// /*<!> ... */, !
if (body.charCodeAt(length + 2) === 33) {
out += body.substring(length, caret + 1);
}
char = '';
comment = 0;
}
}
}
}
} // ignore comment blocks
if (comment === 0) {
// aggressive isolation mode, divide each individual selector
// including selectors in :not function but excluding selectors in :global function
if (cascade + quote + bracket + atrule === 0 && id !== KEYFRAME && code !== SEMICOLON) {
switch (code) {
case COMMA:
case TILDE:
case GREATERTHAN:
case PLUS:
case CLOSEPARENTHESES:
case OPENPARENTHESES:
{
if (context === 0) {
// outside of an isolated context i.e nth-child(<...>)
switch (tail) {
case TAB:
case SPACE:
case NEWLINE:
case CARRIAGE:
{
char = char + '\0';
break;
}
default:
{
char = '\0' + char + (code === COMMA ? '' : '\0');
}
}
format = 1;
} else {
// within an isolated context, sleep untill it's terminated
switch (code) {
case OPENPARENTHESES:
{
// :globa<l>(
if (pseudo + 7 === caret && tail === 108) {
pseudo = 0;
}
context = ++counter;
break;
}
case CLOSEPARENTHESES:
{
if ((context = --counter) === 0) {
format = 1;
char += '\0';
}
break;
}
}
}
break;
}
case TAB:
case SPACE:
{
switch (tail) {
case NULL:
case OPENBRACES:
case CLOSEBRACES:
case SEMICOLON:
case COMMA:
case FORMFEED:
case TAB:
case SPACE:
case NEWLINE:
case CARRIAGE:
{
break;
}
default:
{
// ignore in isolated contexts
if (context === 0) {
format = 1;
char += '\0';
}
}
}
}
}
} // concat buffer of characters
chars += char; // previous non-whitespace character code
if (code !== SPACE && code !== TAB) {
peak = code;
}
}
}
} // tail character codes
trail = tail;
tail = code; // visit every character
caret++;
}
length = out.length; // preserve empty selector
if (preserve > 0) {
if (length === 0 && children.length === 0 && current[0].length === 0 === false) {
if (id !== MEDIA || current.length === 1 && (cascade > 0 ? nscopealt : nscope) === current[0]) {
length = current.join(',').length + 2;
}
}
}
if (length > 0) {
// cascade isolation mode?
selector = cascade === 0 && id !== KEYFRAME ? isolate(current) : current; // execute plugins, block context
if (plugged > 0) {
result = proxy(BLCKS, out, selector, parent, line, column, length, id, depth, id);
if (result !== void 0 && (out = result).length === 0) {
return flat + out + children;
}
}
out = selector.join(',') + '{' + out + '}';
if (prefix * pattern !== 0) {
if (prefix === 2 && !vendor(out, 2)) pattern = 0;
switch (pattern) {
// ::read-only
case READONLY:
{
out = out.replace(readonlyptn, ':' + moz + '$1') + out;
break;
}
// ::placeholder
case PLACEHOLDER:
{
out = out.replace(plcholdrptn, '::' + webkit + 'input-$1') + out.replace(plcholdrptn, '::' + moz + '$1') + out.replace(plcholdrptn, ':' + ms + 'input-$1') + out;
break;
}
}
pattern = 0;
}
}
return flat + out + children;
}
/**
* Select
*
* @param {Array<string>} parent
* @param {string} current
* @param {number} invert
* @return {Array<string>}
*/
function select(parent, current, invert) {
var selectors = current.trim().split(selectorptn);
var out = selectors;
var length = selectors.length;
var l = parent.length;
switch (l) {
// 0-1 parent selectors
case 0:
case 1:
{
for (var i = 0, selector = l === 0 ? '' : parent[0] + ' '; i < length; ++i) {
out[i] = scope(selector, out[i], invert, l).trim();
}
break;
}
// >2 parent selectors, nested
default:
{
for (var i = 0, j = 0, out = []; i < length; ++i) {
for (var k = 0; k < l; ++k) {
out[j++] = scope(parent[k] + ' ', selectors[i], invert, l).trim();
}
}
}
}
return out;
}
/**
* Scope
*
* @param {string} parent
* @param {string} current
* @param {number} invert
* @param {number} level
* @return {string}
*/
function scope(parent, current, invert, level) {
var selector = current;
var code = selector.charCodeAt(0); // trim leading whitespace
if (code < 33) {
code = (selector = selector.trim()).charCodeAt(0);
}
switch (code) {
// &
case AND:
{
switch (cascade + level) {
case 0:
case 1:
{
if (parent.trim().length === 0) {
break;
}
}
default:
{
return selector.replace(andptn, '$1' + parent.trim());
}
}
break;
}
// :
case COLON:
{
switch (selector.charCodeAt(1)) {
// g in :global
case 103:
{
if (escape > 0 && cascade > 0) {
return selector.replace(escapeptn, '$1').replace(andptn, '$1' + nscope);
}
break;
}
default:
{
// :hover
return parent.trim() + selector.replace(andptn, '$1' + parent.trim());
}
}
}
default:
{
// html &
if (invert * cascade > 0 && selector.indexOf('\f') > 0) {
return selector.replace(andptn, (parent.charCodeAt(0) === COLON ? '' : '$1') + parent.trim());
}
}
}
return parent + selector;
}
/**
* Property
*
* @param {string} input
* @param {number} first
* @param {number} second
* @param {number} third
* @return {string}
*/
function property(input, first, second, third) {
var index = 0;
var out = input + ';';
var hash = first * 2 + second * 3 + third * 4;
var cache; // animation: a, n, i characters
if (hash === 944) {
return animation(out);
} else if (prefix === 0 || prefix === 2 && !vendor(out, 1)) {
return out;
} // vendor prefix
switch (hash) {
// text-decoration/text-size-adjust/text-shadow/text-align/text-transform: t, e, x
case 1015:
{
// text-shadow/text-align/text-transform, a
return out.charCodeAt(10) === 97 ? webkit + out + out : out;
}
// filter/fill f, i, l
case 951:
{
// filter, t
return out.charCodeAt(3) === 116 ? webkit + out + out : out;
}
// color/column, c, o, l
case 963:
{
// column, n
return out.charCodeAt(5) === 110 ? webkit + out + out : out;
}
// box-decoration-break, b, o, x
case 1009:
{
if (out.charCodeAt(4) !== 100) {
break;
}
}
// mask, m, a, s
// clip-path, c, l, i
case 969:
case 942:
{
return webkit + out + out;
}
// appearance: a, p, p
case 978:
{
return webkit + out + moz + out + out;
}
// hyphens: h, y, p
// user-select: u, s, e
case 1019:
case 983:
{
return webkit + out + moz + out + ms + out + out;
}
// background/backface-visibility, b, a, c
case 883:
{
// backface-visibility, -
if (out.charCodeAt(8) === DASH) {
return webkit + out + out;
} // image-set(...)
if (out.indexOf('image-set(', 11) > 0) {
return out.replace(imgsrcptn, '$1' + webkit + '$2') + out;
}
return out;
}
// flex: f, l, e
case 932:
{
if (out.charCodeAt(4) === DASH) {
switch (out.charCodeAt(5)) {
// flex-grow, g
case 103:
{
return webkit + 'box-' + out.replace('-grow', '') + webkit + out + ms + out.replace('grow', 'positive') + out;
}
// flex-shrink, s
case 115:
{
return webkit + out + ms + out.replace('shrink', 'negative') + out;
}
// flex-basis, b
case 98:
{
return webkit + out + ms + out.replace('basis', 'preferred-size') + out;
}
}
}
return webkit + out + ms + out + out;
}
// order: o, r, d
case 964:
{
return webkit + out + ms + 'flex' + '-' + out + out;
}
// justify-items/justify-content, j, u, s
case 1023:
{
// justify-content, c
if (out.charCodeAt(8) !== 99) {
break;
}
cache = out.substring(out.indexOf(':', 15)).replace('flex-', '').replace('space-between', 'justify');
return webkit + 'box-pack' + cache + webkit + out + ms + 'flex-pack' + cache + out;
}
// cursor, c, u, r
case 1005:
{
return cursorptn.test(out) ? out.replace(colonptn, ':' + webkit) + out.replace(colonptn, ':' + moz) + out : out;
}
// writing-mode, w, r, i
case 1000:
{
cache = out.substring(13).trim();
index = cache.indexOf('-') + 1;
switch (cache.charCodeAt(0) + cache.charCodeAt(index)) {
// vertical-lr
case 226:
{
cache = out.replace(writingptn, 'tb');
break;
}
// vertical-rl
case 232:
{
cache = out.replace(writingptn, 'tb-rl');
break;
}
// horizontal-tb
case 220:
{
cache = out.replace(writingptn, 'lr');
break;
}
default:
{
return out;
}
}
return webkit + out + ms + cache + out;
}
// position: sticky
case 1017:
{
if (out.indexOf('sticky', 9) === -1) {
return out;
}
}
// display(flex/inline-flex/inline-box): d, i, s
case 975:
{
index = (out = input).length - 10;
cache = (out.charCodeAt(index) === 33 ? out.substring(0, index) : out).substring(input.indexOf(':', 7) + 1).trim();
switch (hash = cache.charCodeAt(0) + (cache.charCodeAt(7) | 0)) {
// inline-
case 203:
{
// inline-box
if (cache.charCodeAt(8) < 111) {
break;
}
}
// inline-box/sticky
case 115:
{
out = out.replace(cache, webkit + cache) + ';' + out;
break;
}
// inline-flex
// flex
case 207:
case 102:
{
out = out.replace(cache, webkit + (hash > 102 ? 'inline-' : '') + 'box') + ';' + out.replace(cache, webkit + cache) + ';' + out.replace(cache, ms + cache + 'box') + ';' + out;
}
}
return out + ';';
}
// align-items, align-center, align-self: a, l, i, -
case 938:
{
if (out.charCodeAt(5) === DASH) {
switch (out.charCodeAt(6)) {
// align-items, i
case 105:
{
cache = out.replace('-items', '');
return webkit + out + webkit + 'box-' + cache + ms + 'flex-' + cache + out;
}
// align-self, s
case 115:
{
return webkit + out + ms + 'flex-item-' + out.replace(selfptn, '') + out;
}
// align-content
default:
{
return webkit + out + ms + 'flex-line-pack' + out.replace('align-content', '').replace(selfptn, '') + out;
}
}
}
break;
}
// min/max
case 973:
case 989:
{
// min-/max- height/width/block-size/inline-size
if (out.charCodeAt(3) !== DASH || out.charCodeAt(4) === 122) {
break;
}
}
// height/width: min-content / width: max-content
case 931:
case 953:
{
if (dimensionptn.test(input) === true) {
// stretch
if ((cache = input.substring(input.indexOf(':') + 1)).charCodeAt(0) === 115) return property(input.replace('stretch', 'fill-available'), first, second, third).replace(':fill-available', ':stretch');else return out.replace(cache, webkit + cache) + out.replace(cache, moz + cache.replace('fill-', '')) + out;
}
break;
}
// transform, transition: t, r, a
case 962:
{
out = webkit + out + (out.charCodeAt(5) === 102 ? ms + out : '') + out; // transitions
if (second + third === 211 && out.charCodeAt(13) === 105 && out.indexOf('transform', 10) > 0) {
return out.substring(0, out.indexOf(';', 27) + 1).replace(transformptn, '$1' + webkit + '$2') + out;
}
break;
}
}
return out;
}
/**
* Vendor
*
* @param {string} content
* @param {number} context
* @return {boolean}
*/
function vendor(content, context) {
var index = content.indexOf(context === 1 ? ':' : '{');
var key = content.substring(0, context !== 3 ? index : 10);
var value = content.substring(index + 1, content.length - 1);
return should(context !== 2 ? key : key.replace(pseudofmt, '$1'), value, context);
}
/**
* Supports
*
* @param {string} match
* @param {string} group
* @return {string}
*/
function supports(match, group) {
var out = property(group, group.charCodeAt(0), group.charCodeAt(1), group.charCodeAt(2));
return out !== group + ';' ? out.replace(propertyptn, ' or ($1)').substring(4) : '(' + group + ')';
}
/**
* Animation
*
* @param {string} input
* @return {string}
*/
function animation(input) {
var length = input.length;
var index = input.indexOf(':', 9) + 1;
var declare = input.substring(0, index).trim();
var out = input.substring(index, length - 1).trim();
switch (input.charCodeAt(9) * keyed) {
case 0:
{
break;
}
// animation-*, -
case DASH:
{
// animation-name, n
if (input.charCodeAt(10) !== 110) {
break;
}
}
// animation/animation-name
default:
{
// split in case of multiple animations
var list = out.split((out = '', animationptn));
for (var i = 0, index = 0, length = list.length; i < length; index = 0, ++i) {
var value = list[i];
var items = value.split(propertiesptn);
while (value = items[index]) {
var peak = value.charCodeAt(0);
if (keyed === 1 && ( // letters
peak > AT && peak < 90 || peak > 96 && peak < 123 || peak === UNDERSCORE || // dash but not in sequence i.e --
peak === DASH && value.charCodeAt(1) !== DASH)) {
// not a number/function
switch (isNaN(parseFloat(value)) + (value.indexOf('(') !== -1)) {
case 1:
{
switch (value) {
// not a valid reserved keyword
case 'infinite':
case 'alternate':
case 'backwards':
case 'running':
case 'normal':
case 'forwards':
case 'both':
case 'none':
case 'linear':
case 'ease':
case 'ease-in':
case 'ease-out':
case 'ease-in-out':
case 'paused':
case 'reverse':
case 'alternate-reverse':
case 'inherit':
case 'initial':
case 'unset':
case 'step-start':
case 'step-end':
{
break;
}
default:
{
value += key;
}
}
}
}
}
items[index++] = value;
}
out += (i === 0 ? '' : ',') + items.join(' ');
}
}
}
out = declare + out + ';';
if (prefix === 1 || prefix === 2 && vendor(out, 1)) return webkit + out + out;
return out;
}
/**
* Isolate
*
* @param {Array<string>} current
*/
function isolate(current) {
for (var i = 0, length = current.length, selector = Array(length), padding, element; i < length; ++i) {
// split individual elements in a selector i.e h1 h2 === [h1, h2]
var elements = current[i].split(elementptn);
var out = '';
for (var j = 0, size = 0, tail = 0, code = 0, l = elements.length; j < l; ++j) {
// empty element
if ((size = (element = elements[j]).length) === 0 && l > 1) {
continue;
}
tail = out.charCodeAt(out.length - 1);
code = element.charCodeAt(0);
padding = '';
if (j !== 0) {
// determine if we need padding
switch (tail) {
case STAR:
case TILDE:
case GREATERTHAN:
case PLUS:
case SPACE:
case OPENPARENTHESES:
{
break;
}
default:
{
padding = ' ';
}
}
}
switch (code) {
case AND:
{
element = padding + nscopealt;
}
case TILDE:
case GREATERTHAN:
case PLUS:
case SPACE:
case CLOSEPARENTHESES:
case OPENPARENTHESES:
{
break;
}
case OPENBRACKET:
{
element = padding + element + nscopealt;
break;
}
case COLON:
{
switch (element.charCodeAt(1) * 2 + element.charCodeAt(2) * 3) {
// :global
case 530:
{
if (escape > 0) {
element = padding + element.substring(8, size - 1);
break;
}
}
// :hover, :nth-child(), ...
default:
{
if (j < 1 || elements[j - 1].length < 1) {
element = padding + nscopealt + element;
}
}
}
break;
}
case COMMA:
{
padding = '';
}
default:
{
if (size > 1 && element.indexOf(':') > 0) {
element = padding + element.replace(pseudoptn, '$1' + nscopealt + '$2');
} else {
element = padding + element + nscopealt;
}
}
}
out += element;
}
selector[i] = out.replace(formatptn, '').trim();
}
return selector;
}
/**
* Proxy
*
* @param {number} context
* @param {string} content
* @param {Array<string>} selectors
* @param {Array<string>} parents
* @param {number} line
* @param {number} column
* @param {number} length
* @param {number} id
* @param {number} depth
* @param {number} at
* @return {(string|void|*)}
*/
function proxy(context, content, selectors, parents, line, column, length, id, depth, at) {
for (var i = 0, out = content, next; i < plugged; ++i) {
switch (next = plugins[i].call(stylis, context, out, selectors, parents, line, column, length, id, depth, at)) {
case void 0:
case false:
case true:
case null:
{
break;
}
default:
{
out = next;
}
}
}
if (out !== content) {
return out;
}
}
/**
* @param {number} code
* @param {number} index
* @param {number} length
* @param {string} body
* @return {number}
*/
function delimited(code, index, length, body) {
for (var i = index + 1; i < length; ++i) {
switch (body.charCodeAt(i)) {
// /*
case FOWARDSLASH:
{
if (code === STAR) {
if (body.charCodeAt(i - 1) === STAR && index + 2 !== i) {
return i + 1;
}
}
break;
}
// //
case NEWLINE:
{
if (code === FOWARDSLASH) {
return i + 1;
}
}
}
}
return i;
}
/**
* Minify
*
* @param {(string|*)} output
* @return {string}
*/
function minify(output) {
return output.replace(formatptn, '').replace(beforeptn, '').replace(afterptn, '$1').replace(tailptn, '$1').replace(whiteptn, ' ');
}
/**
* Use
*
* @param {(Array<function(...?)>|function(...?)|number|void)?} plugin
*/
function use(plugin) {
switch (plugin) {
case void 0:
case null:
{
plugged = plugins.length = 0;
break;
}
default:
{
if (typeof plugin === 'function') {
plugins[plugged++] = plugin;
} else if (typeof plugin === 'object') {
for (var i = 0, length = plugin.length; i < length; ++i) {
use(plugin[i]);
}
} else {
unkwn = !!plugin | 0;
}
}
}
return use;
}
/**
* Set
*
* @param {*} options
*/
function set(options) {
for (var name in options) {
var value = options[name];
switch (name) {
case 'keyframe':
keyed = value | 0;
break;
case 'global':
escape = value | 0;
break;
case 'cascade':
cascade = value | 0;
break;
case 'compress':
compress = value | 0;
break;
case 'semicolon':
semicolon = value | 0;
break;
case 'preserve':
preserve = value | 0;
break;
case 'prefix':
should = null;
if (!value) {
prefix = 0;
} else if (typeof value !== 'function') {
prefix = 1;
} else {
prefix = 2;
should = value;
}
}
}
return set;
}
/**
* Stylis
*
* @param {string} selector
* @param {string} input
* @return {*}
*/
function stylis(selector, input) {
if (this !== void 0 && this.constructor === stylis) {
return factory(selector);
} // setup
var ns = selector;
var code = ns.charCodeAt(0); // trim leading whitespace
if (code < 33) {
code = (ns = ns.trim()).charCodeAt(0);
} // keyframe/animation namespace
if (keyed > 0) {
key = ns.replace(invalidptn, code === OPENBRACKET ? '' : '-');
} // reset, used to assert if a plugin is moneky-patching the return value
code = 1; // cascade/isolate
if (cascade === 1) {
nscope = ns;
} else {
nscopealt = ns;
}
var selectors = [nscope];
var result; // execute plugins, pre-process context
if (plugged > 0) {
result = proxy(PREPS, input, selectors, selectors, line, column, 0, 0, 0, 0);
if (result !== void 0 && typeof result === 'string') {
input = result;
}
} // build
var output = compile(array, selectors, input, 0, 0); // execute plugins, post-process context
if (plugged > 0) {
result = proxy(POSTS, output, selectors, selectors, line, column, output.length, 0, 0, 0); // bypass minification
if (result !== void 0 && typeof (output = result) !== 'string') {
code = 0;
}
} // reset
key = '';
nscope = '';
nscopealt = '';
pattern = 0;
line = 1;
column = 1;
return compress * code === 0 ? output : minify(output);
}
stylis['use'] = use;
stylis['set'] = set;
if (options !== void 0) {
set(options);
}
return stylis;
});
});
var ComponentStyle = function () {
function ComponentStyle(rules, selector) {
_classCallCheck(this, ComponentStyle);
this.rules = rules;
this.selector = selector;
}
_createClass(ComponentStyle, [{
key: "generateAndInject",
value: function generateAndInject() {
if (!styleSheet.injected) styleSheet.inject();
var flatCSS = flatten(this.rules).join('');
var cssString = this.selector ? "".concat(this.selector, " { ").concat(flatCSS, " }") : flatCSS;
var css = stylis('', cssString, false, false);
styleSheet.insert(css, {
global: true
});
}
}]);
return ComponentStyle;
}();
var injectGlobal = function injectGlobal(strings) {
for (var _len = arguments.length, interpolations = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
interpolations[_key - 1] = arguments[_key];
}
var globalStyle = new ComponentStyle(css.apply(void 0, [strings].concat(interpolations)));
globalStyle.generateAndInject();
};
var ThemeProvider = {
name: 'ThemeProvider',
props: {
theme: Object
},
provide: function provide() {
var _this = this;
return {
$theme: function $theme() {
return _this.theme;
}
};
},
render: function render(createElement) {
return createElement('div', {}, this.$slots["default"]);
}
};
/**
* lodash 4.1.3 (Custom Build) <https://lodash.com/>
* Build: `lodash modularize exports="npm" -o ./`
* Copyright jQuery Foundation and other contributors <https://jquery.org/>
* Released under MIT license <https://lodash.com/license>
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
*/
/** Used for built-in method references. */
var objectProto$1 = Object.prototype;
/** Used to check objects for own properties. */
var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
/**
* Assigns `value` to `key` of `object` if the existing value is not equivalent
* using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
* for equality comparisons.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/
function assignValue(object, key, value) {
var objValue = object[key];
if (!(hasOwnProperty$1.call(object, key) && eq(objValue, value)) || value === undefined && !(key in object)) {
object[key] = value;
}
}
/**
* This base implementation of `_.zipObject` which assigns values using `assignFunc`.
*
* @private
* @param {Array} props The property identifiers.
* @param {Array} values The property values.
* @param {Function} assignFunc The function to assign values.
* @returns {Object} Returns the new object.
*/
function baseZipObject(props, values, assignFunc) {
var index = -1,
length = props.length,
valsLength = values.length,
result = {};
while (++index < length) {
var value = index < valsLength ? values[index] : undefined;
assignFunc(result, props[index], value);
}
return result;
}
/**
* This method is like `_.fromPairs` except that it accepts two arrays,
* one of property identifiers and one of corresponding values.
*
* @static
* @memberOf _
* @since 0.4.0
* @category Array
* @param {Array} [props=[]] The property identifiers.
* @param {Array} [values=[]] The property values.
* @returns {Object} Returns the new object.
* @example
*
* _.zipObject(['a', 'b'], [1, 2]);
* // => { 'a': 1, 'b': 2 }
*/
function zipObject(props, values) {
return baseZipObject(props || [], values || [], assignValue);
}
/**
* Performs a
* [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
* comparison between two values to determine if they are equivalent.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
* @example
*
* var object = { 'user': 'fred' };
* var other = { 'user': 'fred' };
*
* _.eq(object, object);
* // => true
*
* _.eq(object, other);
* // => false
*
* _.eq('a', 'a');
* // => true
*
* _.eq('a', Object('a'));
* // => false
*
* _.eq(NaN, NaN);
* // => true
*/
function eq(value, other) {
return value === other || value !== value && other !== other;
}
var lodash_zipobject = zipObject;
function normalizeProps() {
var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
if (Array.isArray(props)) {
return lodash_zipobject(props);
} else {
return props;
}
}
function isVueComponent(target) {
return target && (typeof target.render === 'function' || typeof target.template === 'string');
}
var _styledComponent = (function (ComponentStyle) {
var createStyledComponent = function createStyledComponent(target, rules, props, options) {
var _options$attrs = options.attrs,
_attrs = _options$attrs === void 0 ? [] : _options$attrs;
var componentStyle = new ComponentStyle(rules);
var currentProps = normalizeProps(props);
var prevProps = normalizeProps(target.props);
var StyledComponent = {
inject: {
$theme: {
"default": function _default() {
return function () {
return {};
};
}
}
},
props: _objectSpread2({
as: [String, Object],
value: null
}, currentProps, {}, prevProps),
data: function data() {
return {
localValue: this.value
};
},
render: function render(createElement) {
var _this = this;
var children = [];
for (var slot in this.$slots) {
if (slot === 'default') {
children.push(this.$slots[slot]);
} else {
children.push(createElement('template', {
slot: slot
}, this.$slots[slot]));
}
}
return createElement(isVueComponent(target) ? target : this.$props.as || target, {
"class": [this.generatedClassName],
props: this.$props,
domProps: _objectSpread2({}, this.attrs, {
value: this.localValue
}),
on: _objectSpread2({}, this.$listeners, {
input: function input(event) {
if (event && event.target) {
_this.localValue = event.target.value;
}
}
}),
scopedSlots: this.$scopedSlots
}, children);
},
methods: {
generateAndInjectStyles: function generateAndInjectStyles(componentProps) {
return componentStyle.generateAndInjectStyles(componentProps);
}
},
computed: {
generatedClassName: function generatedClassName() {
var context = this.context,
attrs = this.attrs;
var componentProps = _objectSpread2({}, context, {}, attrs);
return this.generateAndInjectStyles(componentProps);
},
theme: function theme() {
return this.$theme();
},
context: function context() {
return _objectSpread2({
theme: this.theme
}, this.$props);
},
attrs: function attrs() {
var resolvedAttrs = {};
var context = this.context;
_attrs.forEach(function (attrDef) {
var resolvedAttrDef = attrDef;
if (typeof resolvedAttrDef === 'function') {
resolvedAttrDef = resolvedAttrDef(context);
}
for (var key in resolvedAttrDef) {
context[key] = resolvedAttrs[key] = resolvedAttrDef[key];
}
});
return resolvedAttrs;
}
},
watch: {
value: function value(newValue) {
this.localValue = newValue;
},
localValue: function localValue() {
this.$emit('input', this.localValue);
}
},
extend: function extend(cssRules) {
for (var _len = arguments.length, interpolations = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
interpolations[_key - 1] = arguments[_key];
}
var extendedRules = css.apply(void 0, [cssRules].concat(interpolations));
return createStyledComponent(target, rules.concat(extendedRules), props, options);
},
withComponent: function withComponent(newTarget) {
return createStyledComponent(newTarget, rules, props, options);
}
};
return StyledComponent;
};
return createStyledComponent;
});
var _componentStyle = (function (nameGenerator) {
var inserted = {};
var ComponentStyle = function () {
function ComponentStyle(rules) {
_classCallCheck(this, ComponentStyle);
this.rules = rules;
stylis.set({
keyframe: false
});
if (!styleSheet.injected) styleSheet.inject();
this.insertedRule = styleSheet.insert('');
}
_createClass(ComponentStyle, [{
key: "generateAndInjectStyles",
value: function generateAndInjectStyles(executionContext) {
var flatCSS = flatten(this.rules, executionContext).join('').replace(/^\s*\/\/.*$/gm, '');
var hash = hashStr(flatCSS);
if (!inserted[hash]) {
var selector = nameGenerator(hash);
inserted[hash] = selector;
var css = stylis(".".concat(selector), flatCSS);
this.insertedRule.appendRule(css);
}
return inserted[hash];
}
}]);
return ComponentStyle;
}();
return ComponentStyle;
});
var domElements = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', 'circle', 'clipPath', 'defs', 'ellipse', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];
function isTag(target) {
if (typeof target === 'string') {
return domElements.indexOf(target) !== -1;
}
}
function isStyledComponent(target) {
return target && target.methods && typeof target.methods.generateAndInjectStyles === 'function';
}
function isValidElementType(target) {
return isStyledComponent(target) || isVueComponent(target) || isTag(target);
}
var _styled = (function (createStyledComponent) {
var styled = function styled(tagName) {
var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
if (!isValidElementType(tagName)) {
throw new Error(tagName + ' is not allowed for styled tag type.');
}
var templateFunction = function templateFunction(cssRules) {
for (var _len = arguments.length, interpolations = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
interpolations[_key - 1] = arguments[_key];
}
return createStyledComponent(tagName, css.apply(void 0, [cssRules].concat(interpolations)), props, options);
};
templateFunction.attrs = function (attrs) {
return styled(tagName, props, _objectSpread2({}, options, {
attrs: Array.prototype.concat(options.attrs, attrs).filter(Boolean)
}));
};
return templateFunction;
};
domElements.forEach(function (domElement) {
styled[domElement] = styled(domElement);
});
return styled;
});
var styled = _styled(_styledComponent(_componentStyle(generateAlphabeticName)));
/* harmony default export */ var vue_styled_components_es = (styled);
// CONCATENATED MODULE: ./src/components/common/Preview.js
var _templateObject;
var positionProps = {
isFixed: Boolean
};
/* harmony default export */ var Preview = (vue_styled_components_es('div', positionProps)(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n .sticky {\n width: 100%;\n z-index: 999;\n position: ", ";\n top: 0;\n left: 0;\n }\n"])), function (props) {
return props.isFixed ? "fixed" : "";
}));
// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js??ref--12-0!./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib!./node_modules/cache-loader/dist/cjs.js??ref--0-0!./node_modules/vue-loader/lib??vue-loader-options!./src/components/VueScrollFixedNavbar.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
/* harmony default export */ var VueScrollFixedNavbarvue_type_script_lang_js_ = ({
name: 'VueScrollFixedNavbar',
props: {
isFixed: {
type: Boolean,
default: true
}
},
components: {
Preview: Preview
},
created: function created() {
window.addEventListener('scroll', this.handleScroll);
},
destroyed: function destroyed() {
window.removeEventListener('scroll', this.handleScroll);
},
methods: {
handleScroll: function handleScroll() {
window.onscroll = function () {
myFunction();
};
var header = document.getElementById('myHeader');
var sticky = header.offsetTop;
function myFunction() {
if (window.pageYOffset > sticky) {
header.classList.add('sticky');
} else {
header.classList.remove('sticky');
}
}
}
}
});
// CONCATENATED MODULE: ./src/components/VueScrollFixedNavbar.vue?vue&type=script&lang=js&
/* harmony default export */ var components_VueScrollFixedNavbarvue_type_script_lang_js_ = (VueScrollFixedNavbarvue_type_script_lang_js_);
// CONCATENATED MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
/* globals __VUE_SSR_CONTEXT__ */
// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
// This module is a runtime utility for cleaner component module output and will
// be included in the final webpack user bundle.
function normalizeComponent (
scriptExports,
render,
staticRenderFns,
functionalTemplate,
injectStyles,
scopeId,
moduleIdentifier, /* server only */
shadowMode /* vue-cli only */
) {
// Vue.extend constructor export interop
var options = typeof scriptExports === 'function'
? scriptExports.options
: scriptExports
// render functions
if (render) {
options.render = render
options.staticRenderFns = staticRenderFns
options._compiled = true
}
// functional template
if (functionalTemplate) {
options.functional = true
}
// scopedId
if (scopeId) {
options._scopeId = 'data-v-' + scopeId
}
var hook
if (moduleIdentifier) { // server build
hook = function (context) {
// 2.3 injection
context =
context || // cached call
(this.$vnode && this.$vnode.ssrContext) || // stateful
(this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
// 2.2 with runInNewContext: true
if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
context = __VUE_SSR_CONTEXT__
}
// inject component styles
if (injectStyles) {
injectStyles.call(this, context)
}
// register component module identifier for async chunk inferrence
if (context && context._registeredComponents) {
context._registeredComponents.add(moduleIdentifier)
}
}
// used by ssr in case component is cached and beforeCreate
// never gets called
options._ssrRegister = hook
} else if (injectStyles) {
hook = shadowMode
? function () {
injectStyles.call(
this,
(options.functional ? this.parent : this).$root.$options.shadowRoot
)
}
: injectStyles
}
if (hook) {
if (options.functional) {
// for template-only hot-reload because in that case the render fn doesn't
// go through the normalizer
options._injectStyles = hook
// register for functional component in vue file
var originalRender = options.render
options.render = function renderWithStyleInjection (h, context) {
hook.call(context)
return originalRender(h, context)
}
} else {
// inject component registration as beforeCreate hook
var existing = options.beforeCreate
options.beforeCreate = existing
? [].concat(existing, hook)
: [hook]
}
}
return {
exports: scriptExports,
options: options
}
}
// CONCATENATED MODULE: ./src/components/VueScrollFixedNavbar.vue
/* normalize component */
var component = normalizeComponent(
components_VueScrollFixedNavbarvue_type_script_lang_js_,
render,
staticRenderFns,
false,
null,
null,
null
)
/* harmony default export */ var VueScrollFixedNavbar = __webpack_exports__["a"] = (component.exports);
/***/ }),
/***/ "2d00":
/***/ (function(module, exports, __webpack_require__) {
var global = __webpack_require__("da84");
var userAgent = __webpack_require__("342f");
var process = global.process;
var versions = process && process.versions;
var v8 = versions && versions.v8;
var match, version;
if (v8) {
match = v8.split('.');
version = match[0] < 4 ? 1 : match[0] + match[1];
} else if (userAgent) {
match = userAgent.match(/Edge\/(\d+)/);
if (!match || match[1] >= 74) {
match = userAgent.match(/Chrome\/(\d+)/);
if (match) version = match[1];
}
}
module.exports = version && +version;
/***/ }),
/***/ "342f":
/***/ (function(module, exports, __webpack_require__) {
var getBuiltIn = __webpack_require__("d066");
module.exports = getBuiltIn('navigator', 'userAgent') || '';
/***/ }),
/***/ "428f":
/***/ (function(module, exports, __webpack_require__) {
var global = __webpack_require__("da84");
module.exports = global;
/***/ }),
/***/ "44ad":
/***/ (function(module, exports, __webpack_require__) {
var fails = __webpack_require__("d039");
var classof = __webpack_require__("c6b6");
var split = ''.split;
// fallback for non-array-like ES3 and non-enumerable old V8 strings
module.exports = fails(function () {
// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
// eslint-disable-next-line no-prototype-builtins -- safe
return !Object('z').propertyIsEnumerable(0);
}) ? function (it) {
return classof(it) == 'String' ? split.call(it, '') : Object(it);
} : Object;
/***/ }),
/***/ "4930":
/***/ (function(module, exports, __webpack_require__) {
/* eslint-disable es/no-symbol -- required for testing */
var V8_VERSION = __webpack_require__("2d00");
var fails = __webpack_require__("d039");
// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
return !String(Symbol()) ||
// Chrome 38 Symbol has incorrect toString conversion
// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
!Symbol.sham && V8_VERSION && V8_VERSION < 41;
});
/***/ }),
/***/ "4d64":
/***/ (function(module, exports, __webpack_require__) {
var toIndexedObject = __webpack_require__("fc6a");
var toLength = __webpack_require__("50c4");
var toAbsoluteIndex = __webpack_require__("23cb");
// `Array.prototype.{ indexOf, includes }` methods implementation
var createMethod = function (IS_INCLUDES) {
return function ($this, el, fromIndex) {
var O = toIndexedObject($this);
var length = toLength(O.length);
var index = toAbsoluteIndex(fromIndex, length);
var value;
// Array#includes uses SameValueZero equality algorithm
// eslint-disable-next-line no-self-compare -- NaN check
if (IS_INCLUDES && el != el) while (length > index) {
value = O[index++];
// eslint-disable-next-line no-self-compare -- NaN check
if (value != value) return true;
// Array#indexOf ignores holes, Array#includes - not
} else for (;length > index; index++) {
if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
} return !IS_INCLUDES && -1;
};
};
module.exports = {
// `Array.prototype.includes` method
// https://tc39.es/ecma262/#sec-array.prototype.includes
includes: createMethod(true),
// `Array.prototype.indexOf` method
// https://tc39.es/ecma262/#sec-array.prototype.indexof
indexOf: createMethod(false)
};
/***/ }),
/***/ "50c4":
/***/ (function(module, exports, __webpack_require__) {
var toInteger = __webpack_require__("a691");
var min = Math.min;
// `ToLength` abstract operation
// https://tc39.es/ecma262/#sec-tolength
module.exports = function (argument) {
return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
};
/***/ }),
/***/ "5135":
/***/ (function(module, exports, __webpack_require__) {
var toObject = __webpack_require__("7b0b");
var hasOwnProperty = {}.hasOwnProperty;
module.exports = function hasOwn(it, key) {
return hasOwnProperty.call(toObject(it), key);
};
/***/ }),
/***/ "5692":
/***/ (function(module, exports, __webpack_require__) {
var IS_PURE = __webpack_require__("c430");
var store = __webpack_require__("c6cd");
(module.exports = function (key, value) {
return store[key] || (store[key] = value !== undefined ? value : {});
})('versions', []).push({
version: '3.12.1',
mode: IS_PURE ? 'pure' : 'global',
copyright: '© 2021 Denis Pushkarev (zloirock.ru)'
});
/***/ }),
/***/ "56ef":
/***/ (function(module, exports, __webpack_require__) {
var getBuiltIn = __webpack_require__("d066");
var getOwnPropertyNamesModule = __webpack_require__("241c");
var getOwnPropertySymbolsModule = __webpack_require__("7418");
var anObject = __webpack_require__("825a");
// all object keys, includes non-enumerable and symbols
module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
var keys = getOwnPropertyNamesModule.f(anObject(it));
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
};
/***/ }),
/***/ "5c6c":
/***/ (function(module, exports) {
module.exports = function (bitmap, value) {
return {
enumerable: !(bitmap & 1),
configurable: !(bitmap & 2),
writable: !(bitmap & 4),
value: value
};
};
/***/ }),
/***/ "60da":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var DESCRIPTORS = __webpack_require__("83ab");
var fails = __webpack_require__("d039");
var objectKeys = __webpack_require__("df75");
var getOwnPropertySymbolsModule = __webpack_require__("7418");
var propertyIsEnumerableModule = __webpack_require__("d1e7");
var toObject = __webpack_require__("7b0b");
var IndexedObject = __webpack_require__("44ad");
// eslint-disable-next-line es/no-object-assign -- safe
var $assign = Object.assign;
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
var defineProperty = Object.defineProperty;
// `Object.assign` method
// https://tc39.es/ecma262/#sec-object.assign
module.exports = !$assign || fails(function () {
// should have correct order of operations (Edge bug)
if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {
enumerable: true,
get: function () {
defineProperty(this, 'b', {
value: 3,
enumerable: false
});
}
}), { b: 2 })).b !== 1) return true;
// should work with symbols and should have deterministic property order (V8 bug)
var A = {};
var B = {};
// eslint-disable-next-line es/no-symbol -- safe
var symbol = Symbol();
var alphabet = 'abcdefghijklmnopqrst';
A[symbol] = 7;
alphabet.split('').forEach(function (chr) { B[chr] = chr; });
return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;
}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
var T = toObject(target);
var argumentsLength = arguments.length;
var index = 1;
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
var propertyIsEnumerable = propertyIsEnumerableModule.f;
while (argumentsLength > index) {
var S = IndexedObject(arguments[index++]);
var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);
var length = keys.length;
var j = 0;
var key;
while (length > j) {
key = keys[j++];
if (!DESCRIPTORS || propertyIsEnumerable.call(S, key)) T[key] = S[key];
}
} return T;
} : $assign;
/***/ }),
/***/ "69f3":
/***/ (function(module, exports, __webpack_require__) {
var NATIVE_WEAK_MAP = __webpack_require__("7f9a");
var global = __webpack_require__("da84");
var isObject = __webpack_require__("861d");
var createNonEnumerableProperty = __webpack_require__("9112");
var objectHas = __webpack_require__("5135");
var shared = __webpack_require__("c6cd");
var sharedKey = __webpack_require__("f772");
var hiddenKeys = __webpack_require__("d012");
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
var WeakMap = global.WeakMap;
var set, get, has;
var enforce = function (it) {
return has(it) ? get(it) : set(it, {});
};
var getterFor = function (TYPE) {
return function (it) {
var state;
if (!isObject(it) || (state = get(it)).type !== TYPE) {
throw TypeError('Incompatible receiver, ' + TYPE + ' required');
} return state;
};
};
if (NATIVE_WEAK_MAP || shared.state) {
var store = shared.state || (shared.state = new WeakMap());
var wmget = store.get;
var wmhas = store.has;
var wmset = store.set;
set = function (it, metadata) {
if (wmhas.call(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
metadata.facade = it;
wmset.call(store, it, metadata);
return metadata;
};
get = function (it) {
return wmget.call(store, it) || {};
};
has = function (it) {
return wmhas.call(store, it);
};
} else {
var STATE = sharedKey('state');
hiddenKeys[STATE] = true;
set = function (it, metadata) {
if (objectHas(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
metadata.facade = it;
createNonEnumerableProperty(it, STATE, metadata);
return metadata;
};
get = function (it) {
return objectHas(it, STATE) ? it[STATE] : {};
};
has = function (it) {
return objectHas(it, STATE);
};
}
module.exports = {
set: set,
get: get,
has: has,
enforce: enforce,
getterFor: getterFor
};
/***/ }),
/***/ "6eeb":
/***/ (function(module, exports, __webpack_require__) {
var global = __webpack_require__("da84");
var createNonEnumerableProperty = __webpack_require__("9112");
var has = __webpack_require__("5135");
var setGlobal = __webpack_require__("ce4e");
var inspectSource = __webpack_require__("8925");
var InternalStateModule = __webpack_require__("69f3");
var getInternalState = InternalStateModule.get;
var enforceInternalState = InternalStateModule.enforce;
var TEMPLATE = String(String).split('String');
(module.exports = function (O, key, value, options) {
var unsafe = options ? !!options.unsafe : false;
var simple = options ? !!options.enumerable : false;
var noTargetGet = options ? !!options.noTargetGet : false;
var state;
if (typeof value == 'function') {
if (typeof key == 'string' && !has(value, 'name')) {
createNonEnumerableProperty(value, 'name', key);
}
state = enforceInternalState(value);
if (!state.source) {
state.source = TEMPLATE.join(typeof key == 'string' ? key : '');
}
}
if (O === global) {
if (simple) O[key] = value;
else setGlobal(key, value);
return;
} else if (!unsafe) {
delete O[key];
} else if (!noTargetGet && O[key]) {
simple = true;
}
if (simple) O[key] = value;
else createNonEnumerableProperty(O, key, value);
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
})(Function.prototype, 'toString', function toString() {
return typeof this == 'function' && getInternalState(this).source || inspectSource(this);
});
/***/ }),
/***/ "7418":
/***/ (function(module, exports) {
// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
exports.f = Object.getOwnPropertySymbols;
/***/ }),
/***/ "7839":
/***/ (function(module, exports) {
// IE8- don't enum bug keys
module.exports = [
'constructor',
'hasOwnProperty',
'isPrototypeOf',
'propertyIsEnumerable',
'toLocaleString',
'toString',
'valueOf'
];
/***/ }),
/***/ "7b0b":
/***/ (function(module, exports, __webpack_require__) {
var requireObjectCoercible = __webpack_require__("1d80");
// `ToObject` abstract operation
// https://tc39.es/ecma262/#sec-toobject
module.exports = function (argument) {
return Object(requireObjectCoercible(argument));
};
/***/ }),
/***/ "7f9a":
/***/ (function(module, exports, __webpack_require__) {
var global = __webpack_require__("da84");
var inspectSource = __webpack_require__("8925");
var WeakMap = global.WeakMap;
module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));
/***/ }),
/***/ "825a":
/***/ (function(module, exports, __webpack_require__) {
var isObject = __webpack_require__("861d");
module.exports = function (it) {
if (!isObject(it)) {
throw TypeError(String(it) + ' is not an object');
} return it;
};
/***/ }),
/***/ "83ab":
/***/ (function(module, exports, __webpack_require__) {
var fails = __webpack_require__("d039");
// Detect IE8's incomplete defineProperty implementation
module.exports = !fails(function () {
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
});
/***/ }),
/***/ "8418":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var toPrimitive = __webpack_require__("c04e");
var definePropertyModule = __webpack_require__("9bf2");
var createPropertyDescriptor = __webpack_require__("5c6c");
module.exports = function (object, key, value) {
var propertyKey = toPrimitive(key);
if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
else object[propertyKey] = value;
};
/***/ }),
/***/ "861d":
/***/ (function(module, exports) {
module.exports = function (it) {
return typeof it === 'object' ? it !== null : typeof it === 'function';
};
/***/ }),
/***/ "8875":
/***/ (function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// addapted from the document.currentScript polyfill by Adam Miller
// MIT license
// source: https://github.com/amiller-gh/currentScript-polyfill
// added support for Firefox https://bugzilla.mozilla.org/show_bug.cgi?id=1620505
(function (root, factory) {
if (true) {
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
} else {}
}(typeof self !== 'undefined' ? self : this, function () {
function getCurrentScript () {
var descriptor = Object.getOwnPropertyDescriptor(document, 'currentScript')
// for chrome
if (!descriptor && 'currentScript' in document && document.currentScript) {
return document.currentScript
}
// for other browsers with native support for currentScript
if (descriptor && descriptor.get !== getCurrentScript && document.currentScript) {
return document.currentScript
}
// IE 8-10 support script readyState
// IE 11+ & Firefox support stack trace
try {
throw new Error();
}
catch (err) {
// Find the second match for the "at" string to get file src url from stack.
var ieStackRegExp = /.*at [^(]*\((.*):(.+):(.+)\)$/ig,
ffStackRegExp = /@([^@]*):(\d+):(\d+)\s*$/ig,
stackDetails = ieStackRegExp.exec(err.stack) || ffStackRegExp.exec(err.stack),
scriptLocation = (stackDetails && stackDetails[1]) || false,
line = (stackDetails && stackDetails[2]) || false,
currentLocation = document.location.href.replace(document.location.hash, ''),
pageSource,
inlineScriptSourceRegExp,
inlineScriptSource,
scripts = document.getElementsByTagName('script'); // Live NodeList collection
if (scriptLocation === currentLocation) {
pageSource = document.documentElement.outerHTML;
inlineScriptSourceRegExp = new RegExp('(?:[^\\n]+?\\n){0,' + (line - 2) + '}[^<]*<script>([\\d\\D]*?)<\\/script>[\\d\\D]*', 'i');
inlineScriptSource = pageSource.replace(inlineScriptSourceRegExp, '$1').trim();
}
for (var i = 0; i < scripts.length; i++) {
// If ready state is interactive, return the script tag
if (scripts[i].readyState === 'interactive') {
return scripts[i];
}
// If src matches, return the script tag
if (scripts[i].src === scriptLocation) {
return scripts[i];
}
// If inline source matches, return the script tag
if (
scriptLocation === currentLocation &&
scripts[i].innerHTML &&
scripts[i].innerHTML.trim() === inlineScriptSource
) {
return scripts[i];
}
}
// If no match, return null
return null;
}
};
return getCurrentScript
}));
/***/ }),
/***/ "8925":
/***/ (function(module, exports, __webpack_require__) {
var store = __webpack_require__("c6cd");
var functionToString = Function.toString;
// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper
if (typeof store.inspectSource != 'function') {
store.inspectSource = function (it) {
return functionToString.call(it);
};
}
module.exports = store.inspectSource;
/***/ }),
/***/ "90e3":
/***/ (function(module, exports) {
var id = 0;
var postfix = Math.random();
module.exports = function (key) {
return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
};
/***/ }),
/***/ "9112":
/***/ (function(module, exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__("83ab");
var definePropertyModule = __webpack_require__("9bf2");
var createPropertyDescriptor = __webpack_require__("5c6c");
module.exports = DESCRIPTORS ? function (object, key, value) {
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
} : function (object, key, value) {
object[key] = value;
return object;
};
/***/ }),
/***/ "94ca":
/***/ (function(module, exports, __webpack_require__) {
var fails = __webpack_require__("d039");
var replacement = /#|\.prototype\./;
var isForced = function (feature, detection) {
var value = data[normalize(feature)];
return value == POLYFILL ? true
: value == NATIVE ? false
: typeof detection == 'function' ? fails(detection)
: !!detection;
};
var normalize = isForced.normalize = function (string) {
return String(string).replace(replacement, '.').toLowerCase();
};
var data = isForced.data = {};
var NATIVE = isForced.NATIVE = 'N';
var POLYFILL = isForced.POLYFILL = 'P';
module.exports = isForced;
/***/ }),
/***/ "9bf2":
/***/ (function(module, exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__("83ab");
var IE8_DOM_DEFINE = __webpack_require__("0cfb");
var anObject = __webpack_require__("825a");
var toPrimitive = __webpack_require__("c04e");
// eslint-disable-next-line es/no-object-defineproperty -- safe
var $defineProperty = Object.defineProperty;
// `Object.defineProperty` method
// https://tc39.es/ecma262/#sec-object.defineproperty
exports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {
anObject(O);
P = toPrimitive(P, true);
anObject(Attributes);
if (IE8_DOM_DEFINE) try {
return $defineProperty(O, P, Attributes);
} catch (error) { /* empty */ }
if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
if ('value' in Attributes) O[P] = Attributes.value;
return O;
};
/***/ }),
/***/ "a691":
/***/ (function(module, exports) {
var ceil = Math.ceil;
var floor = Math.floor;
// `ToInteger` abstract operation
// https://tc39.es/ecma262/#sec-tointeger
module.exports = function (argument) {
return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
};
/***/ }),
/***/ "b622":
/***/ (function(module, exports, __webpack_require__) {
var global = __webpack_require__("da84");
var shared = __webpack_require__("5692");
var has = __webpack_require__("5135");
var uid = __webpack_require__("90e3");
var NATIVE_SYMBOL = __webpack_require__("4930");
var USE_SYMBOL_AS_UID = __webpack_require__("fdbf");
var WellKnownSymbolsStore = shared('wks');
var Symbol = global.Symbol;
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;
module.exports = function (name) {
if (!has(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
if (NATIVE_SYMBOL && has(Symbol, name)) {
WellKnownSymbolsStore[name] = Symbol[name];
} else {
WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);
}
} return WellKnownSymbolsStore[name];
};
/***/ }),
/***/ "b635":
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {/* harmony import */ var core_js_modules_es_object_assign_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("cca6");
/* harmony import */ var core_js_modules_es_object_assign_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es_object_assign_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _components_VueScrollFixedNavbar__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("298e");
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _components_VueScrollFixedNavbar__WEBPACK_IMPORTED_MODULE_1__["a"]; });
function registerComponents(Vue) {
Vue.component("VueScrollFixedNavbar", _components_VueScrollFixedNavbar__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"]);
}
var plugin = {
install: function install(Vue) {
var finalOptions = Object.assign({}, {
installComponents: true
});
if (finalOptions.installComponents) {
registerComponents(Vue);
} // Vue.component(component.name, component);
}
};
/* harmony default export */ __webpack_exports__["b"] = (plugin);
var GlobalVue = null;
if (typeof window !== 'undefined') {
GlobalVue = window.Vue;
} else if (typeof global !== 'undefined') {
GlobalVue = global.Vue;
}
if (GlobalVue) {
GlobalVue.use(plugin);
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("c8ba")))
/***/ }),
/***/ "bb2f":
/***/ (function(module, exports, __webpack_require__) {
var fails = __webpack_require__("d039");
module.exports = !fails(function () {
// eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing
return Object.isExtensible(Object.preventExtensions({}));
});
/***/ }),
/***/ "c04e":
/***/ (function(module, exports, __webpack_require__) {
var isObject = __webpack_require__("861d");
// `ToPrimitive` abstract operation
// https://tc39.es/ecma262/#sec-toprimitive
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
module.exports = function (input, PREFERRED_STRING) {
if (!isObject(input)) return input;
var fn, val;
if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;
if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
throw TypeError("Can't convert object to primitive value");
};
/***/ }),
/***/ "c430":
/***/ (function(module, exports) {
module.exports = false;
/***/ }),
/***/ "c6b6":
/***/ (function(module, exports) {
var toString = {}.toString;
module.exports = function (it) {
return toString.call(it).slice(8, -1);
};
/***/ }),
/***/ "c6cd":
/***/ (function(module, exports, __webpack_require__) {
var global = __webpack_require__("da84");
var setGlobal = __webpack_require__("ce4e");
var SHARED = '__core-js_shared__';
var store = global[SHARED] || setGlobal(SHARED, {});
module.exports = store;
/***/ }),
/***/ "c8ba":
/***/ (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 || new Function("return 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;
/***/ }),
/***/ "ca84":
/***/ (function(module, exports, __webpack_require__) {
var has = __webpack_require__("5135");
var toIndexedObject = __webpack_require__("fc6a");
var indexOf = __webpack_require__("4d64").indexOf;
var hiddenKeys = __webpack_require__("d012");
module.exports = function (object, names) {
var O = toIndexedObject(object);
var i = 0;
var result = [];
var key;
for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);
// Don't enum bug & hidden keys
while (names.length > i) if (has(O, key = names[i++])) {
~indexOf(result, key) || result.push(key);
}
return result;
};
/***/ }),
/***/ "cc12":
/***/ (function(module, exports, __webpack_require__) {
var global = __webpack_require__("da84");
var isObject = __webpack_require__("861d");
var document = global.document;
// typeof document.createElement is 'object' in old IE
var EXISTS = isObject(document) && isObject(document.createElement);
module.exports = function (it) {
return EXISTS ? document.createElement(it) : {};
};
/***/ }),
/***/ "cca6":
/***/ (function(module, exports, __webpack_require__) {
var $ = __webpack_require__("23e7");
var assign = __webpack_require__("60da");
// `Object.assign` method
// https://tc39.es/ecma262/#sec-object.assign
// eslint-disable-next-line es/no-object-assign -- required for testing
$({ target: 'Object', stat: true, forced: Object.assign !== assign }, {
assign: assign
});
/***/ }),
/***/ "ce4e":
/***/ (function(module, exports, __webpack_require__) {
var global = __webpack_require__("da84");
var createNonEnumerableProperty = __webpack_require__("9112");
module.exports = function (key, value) {
try {
createNonEnumerableProperty(global, key, value);
} catch (error) {
global[key] = value;
} return value;
};
/***/ }),
/***/ "d012":
/***/ (function(module, exports) {
module.exports = {};
/***/ }),
/***/ "d039":
/***/ (function(module, exports) {
module.exports = function (exec) {
try {
return !!exec();
} catch (error) {
return true;
}
};
/***/ }),
/***/ "d066":
/***/ (function(module, exports, __webpack_require__) {
var path = __webpack_require__("428f");
var global = __webpack_require__("da84");
var aFunction = function (variable) {
return typeof variable == 'function' ? variable : undefined;
};
module.exports = function (namespace, method) {
return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])
: path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];
};
/***/ }),
/***/ "d1e7":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var $propertyIsEnumerable = {}.propertyIsEnumerable;
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
// Nashorn ~ JDK8 bug
var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
// `Object.prototype.propertyIsEnumerable` method implementation
// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
var descriptor = getOwnPropertyDescriptor(this, V);
return !!descriptor && descriptor.enumerable;
} : $propertyIsEnumerable;
/***/ }),
/***/ "da84":
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global) {var check = function (it) {
return it && it.Math == Math && it;
};
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
module.exports =
// eslint-disable-next-line es/no-global-this -- safe
check(typeof globalThis == 'object' && globalThis) ||
check(typeof window == 'object' && window) ||
// eslint-disable-next-line no-restricted-globals -- safe
check(typeof self == 'object' && self) ||
check(typeof global == 'object' && global) ||
// eslint-disable-next-line no-new-func -- fallback
(function () { return this; })() || Function('return this')();
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("c8ba")))
/***/ }),
/***/ "dca8":
/***/ (function(module, exports, __webpack_require__) {
var $ = __webpack_require__("23e7");
var FREEZING = __webpack_require__("bb2f");
var fails = __webpack_require__("d039");
var isObject = __webpack_require__("861d");
var onFreeze = __webpack_require__("f183").onFreeze;
// eslint-disable-next-line es/no-object-freeze -- safe
var $freeze = Object.freeze;
var FAILS_ON_PRIMITIVES = fails(function () { $freeze(1); });
// `Object.freeze` method
// https://tc39.es/ecma262/#sec-object.freeze
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, {
freeze: function freeze(it) {
return $freeze && isObject(it) ? $freeze(onFreeze(it)) : it;
}
});
/***/ }),
/***/ "df75":
/***/ (function(module, exports, __webpack_require__) {
var internalObjectKeys = __webpack_require__("ca84");
var enumBugKeys = __webpack_require__("7839");
// `Object.keys` method
// https://tc39.es/ecma262/#sec-object.keys
// eslint-disable-next-line es/no-object-keys -- safe
module.exports = Object.keys || function keys(O) {
return internalObjectKeys(O, enumBugKeys);
};
/***/ }),
/***/ "e893":
/***/ (function(module, exports, __webpack_require__) {
var has = __webpack_require__("5135");
var ownKeys = __webpack_require__("56ef");
var getOwnPropertyDescriptorModule = __webpack_require__("06cf");
var definePropertyModule = __webpack_require__("9bf2");
module.exports = function (target, source) {
var keys = ownKeys(source);
var defineProperty = definePropertyModule.f;
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
}
};
/***/ }),
/***/ "e8b5":
/***/ (function(module, exports, __webpack_require__) {
var classof = __webpack_require__("c6b6");
// `IsArray` abstract operation
// https://tc39.es/ecma262/#sec-isarray
// eslint-disable-next-line es/no-array-isarray -- safe
module.exports = Array.isArray || function isArray(arg) {
return classof(arg) == 'Array';
};
/***/ }),
/***/ "f183":
/***/ (function(module, exports, __webpack_require__) {
var hiddenKeys = __webpack_require__("d012");
var isObject = __webpack_require__("861d");
var has = __webpack_require__("5135");
var defineProperty = __webpack_require__("9bf2").f;
var uid = __webpack_require__("90e3");
var FREEZING = __webpack_require__("bb2f");
var METADATA = uid('meta');
var id = 0;
// eslint-disable-next-line es/no-object-isextensible -- safe
var isExtensible = Object.isExtensible || function () {
return true;
};
var setMetadata = function (it) {
defineProperty(it, METADATA, { value: {
objectID: 'O' + ++id, // object ID
weakData: {} // weak collections IDs
} });
};
var fastKey = function (it, create) {
// return a primitive with prefix
if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
if (!has(it, METADATA)) {
// can't set metadata to uncaught frozen object
if (!isExtensible(it)) return 'F';
// not necessary to add metadata
if (!create) return 'E';
// add missing metadata
setMetadata(it);
// return object ID
} return it[METADATA].objectID;
};
var getWeakData = function (it, create) {
if (!has(it, METADATA)) {
// can't set metadata to uncaught frozen object
if (!isExtensible(it)) return true;
// not necessary to add metadata
if (!create) return false;
// add missing metadata
setMetadata(it);
// return the store of weak collections IDs
} return it[METADATA].weakData;
};
// add metadata on freeze-family methods calling
var onFreeze = function (it) {
if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it);
return it;
};
var meta = module.exports = {
REQUIRED: false,
fastKey: fastKey,
getWeakData: getWeakData,
onFreeze: onFreeze
};
hiddenKeys[METADATA] = true;
/***/ }),
/***/ "f772":
/***/ (function(module, exports, __webpack_require__) {
var shared = __webpack_require__("5692");
var uid = __webpack_require__("90e3");
var keys = shared('keys');
module.exports = function (key) {
return keys[key] || (keys[key] = uid(key));
};
/***/ }),
/***/ "fb15":
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, "VueScrollFixedNavbar", function() { return /* reexport */ src_0["a" /* VueScrollFixedNavbar */]; });
// CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/setPublicPath.js
// This file is imported into lib/wc client bundles.
if (typeof window !== 'undefined') {
var currentScript = window.document.currentScript
if (true) {
var getCurrentScript = __webpack_require__("8875")
currentScript = getCurrentScript()
// for backward compatibility, because previously we directly included the polyfill
if (!('currentScript' in document)) {
Object.defineProperty(document, 'currentScript', { get: getCurrentScript })
}
}
var src = currentScript && currentScript.src.match(/(.+\/)[^/]+\.js(\?.*)?$/)
if (src) {
__webpack_require__.p = src[1] // eslint-disable-line
}
}
// Indicate to webpack that this file can be concatenated
/* harmony default export */ var setPublicPath = (null);
// EXTERNAL MODULE: ./src/index.js
var src_0 = __webpack_require__("b635");
// CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/entry-lib.js
/* harmony default export */ var entry_lib = __webpack_exports__["default"] = (src_0["b" /* default */]);
/***/ }),
/***/ "fb6a":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__("23e7");
var isObject = __webpack_require__("861d");
var isArray = __webpack_require__("e8b5");
var toAbsoluteIndex = __webpack_require__("23cb");
var toLength = __webpack_require__("50c4");
var toIndexedObject = __webpack_require__("fc6a");
var createProperty = __webpack_require__("8418");
var wellKnownSymbol = __webpack_require__("b622");
var arrayMethodHasSpeciesSupport = __webpack_require__("1dde");
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');
var SPECIES = wellKnownSymbol('species');
var nativeSlice = [].slice;
var max = Math.max;
// `Array.prototype.slice` method
// https://tc39.es/ecma262/#sec-array.prototype.slice
// fallback for not array-like ES3 strings and DOM objects
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
slice: function slice(start, end) {
var O = toIndexedObject(this);
var length = toLength(O.length);
var k = toAbsoluteIndex(start, length);
var fin = toAbsoluteIndex(end === undefined ? length : end, length);
// inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
var Constructor, result, n;
if (isArray(O)) {
Constructor = O.constructor;
// cross-realm fallback
if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) {
Constructor = undefined;
} else if (isObject(Constructor)) {
Constructor = Constructor[SPECIES];
if (Constructor === null) Constructor = undefined;
}
if (Constructor === Array || Constructor === undefined) {
return nativeSlice.call(O, k, fin);
}
}
result = new (Constructor === undefined ? Array : Constructor)(max(fin - k, 0));
for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);
result.length = n;
return result;
}
});
/***/ }),
/***/ "fc6a":
/***/ (function(module, exports, __webpack_require__) {
// toObject with fallback for non-array-like ES3 strings
var IndexedObject = __webpack_require__("44ad");
var requireObjectCoercible = __webpack_require__("1d80");
module.exports = function (it) {
return IndexedObject(requireObjectCoercible(it));
};
/***/ }),
/***/ "fdbf":
/***/ (function(module, exports, __webpack_require__) {
/* eslint-disable es/no-symbol -- required for testing */
var NATIVE_SYMBOL = __webpack_require__("4930");
module.exports = NATIVE_SYMBOL
&& !Symbol.sham
&& typeof Symbol.iterator == 'symbol';
/***/ })
/******/ });
//# sourceMappingURL=vue-scroll-fixed-navbar.common.js.map