ai/term
ai/term
1
0
Fork 0
Code
8f24d82be3
term/js/bundle.js

5242 lines
206 KiB
JavaScript
Raw Normal View History

add
2024-03-23 11:25:41 +00:00
/******/ (function(modules) { // webpackBootstrap
/******/ var parentHotUpdateCallback = this["webpackHotUpdate"];
/******/ this["webpackHotUpdate"] =
/******/ function webpackHotUpdateCallback(chunkId, moreModules) { // eslint-disable-line no-unused-vars
/******/ hotAddUpdateChunk(chunkId, moreModules);
/******/ if(parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules);
/******/ }
/******/
/******/ function hotDownloadUpdateChunk(chunkId) { // eslint-disable-line no-unused-vars
/******/ var head = document.getElementsByTagName("head")[0];
/******/ var script = document.createElement("script");
/******/ script.type = "text/javascript";
/******/ script.charset = "utf-8";
/******/ script.src = __webpack_require__.p + "" + chunkId + "." + hotCurrentHash + ".hot-update.js";
/******/ head.appendChild(script);
/******/ }
/******/
/******/ function hotDownloadManifest(callback) { // eslint-disable-line no-unused-vars
/******/ if(typeof XMLHttpRequest === "undefined")
/******/ return callback(new Error("No browser support"));
/******/ try {
/******/ var request = new XMLHttpRequest();
/******/ var requestPath = __webpack_require__.p + "" + hotCurrentHash + ".hot-update.json";
/******/ request.open("GET", requestPath, true);
/******/ request.timeout = 10000;
/******/ request.send(null);
/******/ } catch(err) {
/******/ return callback(err);
/******/ }
/******/ request.onreadystatechange = function() {
/******/ if(request.readyState !== 4) return;
/******/ if(request.status === 0) {
/******/ // timeout
/******/ callback(new Error("Manifest request to " + requestPath + " timed out."));
/******/ } else if(request.status === 404) {
/******/ // no update available
/******/ callback();
/******/ } else if(request.status !== 200 && request.status !== 304) {
/******/ // other failure
/******/ callback(new Error("Manifest request to " + requestPath + " failed."));
/******/ } else {
/******/ // success
/******/ try {
/******/ var update = JSON.parse(request.responseText);
/******/ } catch(e) {
/******/ callback(e);
/******/ return;
/******/ }
/******/ callback(null, update);
/******/ }
/******/ };
/******/ }
/******/
/******/
/******/ // Copied from https://github.com/facebook/react/blob/bef45b0/src/shared/utils/canDefineProperty.js
/******/ var canDefineProperty = false;
/******/ try {
/******/ Object.defineProperty({}, "x", {
/******/ get: function() {}
/******/ });
/******/ canDefineProperty = true;
/******/ } catch(x) {
/******/ // IE will fail on defineProperty
/******/ }
/******/
/******/ var hotApplyOnUpdate = true;
/******/ var hotCurrentHash = "df5ff963eab1d8f408b8"; // eslint-disable-line no-unused-vars
/******/ var hotCurrentModuleData = {};
/******/ var hotCurrentParents = []; // eslint-disable-line no-unused-vars
/******/
/******/ function hotCreateRequire(moduleId) { // eslint-disable-line no-unused-vars
/******/ var me = installedModules[moduleId];
/******/ if(!me) return __webpack_require__;
/******/ var fn = function(request) {
/******/ if(me.hot.active) {
/******/ if(installedModules[request]) {
/******/ if(installedModules[request].parents.indexOf(moduleId) < 0)
/******/ installedModules[request].parents.push(moduleId);
/******/ if(me.children.indexOf(request) < 0)
/******/ me.children.push(request);
/******/ } else hotCurrentParents = [moduleId];
/******/ } else {
/******/ console.warn("[HMR] unexpected require(" + request + ") from disposed module " + moduleId);
/******/ hotCurrentParents = [];
/******/ }
/******/ return __webpack_require__(request);
/******/ };
/******/ for(var name in __webpack_require__) {
/******/ if(Object.prototype.hasOwnProperty.call(__webpack_require__, name)) {
/******/ if(canDefineProperty) {
/******/ Object.defineProperty(fn, name, (function(name) {
/******/ return {
/******/ configurable: true,
/******/ enumerable: true,
/******/ get: function() {
/******/ return __webpack_require__[name];
/******/ },
/******/ set: function(value) {
/******/ __webpack_require__[name] = value;
/******/ }
/******/ };
/******/ }(name)));
/******/ } else {
/******/ fn[name] = __webpack_require__[name];
/******/ }
/******/ }
/******/ }
/******/
/******/ function ensure(chunkId, callback) {
/******/ if(hotStatus === "ready")
/******/ hotSetStatus("prepare");
/******/ hotChunksLoading++;
/******/ __webpack_require__.e(chunkId, function() {
/******/ try {
/******/ callback.call(null, fn);
/******/ } finally {
/******/ finishChunkLoading();
/******/ }
/******/
/******/ function finishChunkLoading() {
/******/ hotChunksLoading--;
/******/ if(hotStatus === "prepare") {
/******/ if(!hotWaitingFilesMap[chunkId]) {
/******/ hotEnsureUpdateChunk(chunkId);
/******/ }
/******/ if(hotChunksLoading === 0 && hotWaitingFiles === 0) {
/******/ hotUpdateDownloaded();
/******/ }
/******/ }
/******/ }
/******/ });
/******/ }
/******/ if(canDefineProperty) {
/******/ Object.defineProperty(fn, "e", {
/******/ enumerable: true,
/******/ value: ensure
/******/ });
/******/ } else {
/******/ fn.e = ensure;
/******/ }
/******/ return fn;
/******/ }
/******/
/******/ function hotCreateModule(moduleId) { // eslint-disable-line no-unused-vars
/******/ var hot = {
/******/ // private stuff
/******/ _acceptedDependencies: {},
/******/ _declinedDependencies: {},
/******/ _selfAccepted: false,
/******/ _selfDeclined: false,
/******/ _disposeHandlers: [],
/******/
/******/ // Module API
/******/ active: true,
/******/ accept: function(dep, callback) {
/******/ if(typeof dep === "undefined")
/******/ hot._selfAccepted = true;
/******/ else if(typeof dep === "function")
/******/ hot._selfAccepted = dep;
/******/ else if(typeof dep === "object")
/******/ for(var i = 0; i < dep.length; i++)
/******/ hot._acceptedDependencies[dep[i]] = callback;
/******/ else
/******/ hot._acceptedDependencies[dep] = callback;
/******/ },
/******/ decline: function(dep) {
/******/ if(typeof dep === "undefined")
/******/ hot._selfDeclined = true;
/******/ else if(typeof dep === "number")
/******/ hot._declinedDependencies[dep] = true;
/******/ else
/******/ for(var i = 0; i < dep.length; i++)
/******/ hot._declinedDependencies[dep[i]] = true;
/******/ },
/******/ dispose: function(callback) {
/******/ hot._disposeHandlers.push(callback);
/******/ },
/******/ addDisposeHandler: function(callback) {
/******/ hot._disposeHandlers.push(callback);
/******/ },
/******/ removeDisposeHandler: function(callback) {
/******/ var idx = hot._disposeHandlers.indexOf(callback);
/******/ if(idx >= 0) hot._disposeHandlers.splice(idx, 1);
/******/ },
/******/
/******/ // Management API
/******/ check: hotCheck,
/******/ apply: hotApply,
/******/ status: function(l) {
/******/ if(!l) return hotStatus;
/******/ hotStatusHandlers.push(l);
/******/ },
/******/ addStatusHandler: function(l) {
/******/ hotStatusHandlers.push(l);
/******/ },
/******/ removeStatusHandler: function(l) {
/******/ var idx = hotStatusHandlers.indexOf(l);
/******/ if(idx >= 0) hotStatusHandlers.splice(idx, 1);
/******/ },
/******/
/******/ //inherit from previous dispose call
/******/ data: hotCurrentModuleData[moduleId]
/******/ };
/******/ return hot;
/******/ }
/******/
/******/ var hotStatusHandlers = [];
/******/ var hotStatus = "idle";
/******/
/******/ function hotSetStatus(newStatus) {
/******/ hotStatus = newStatus;
/******/ for(var i = 0; i < hotStatusHandlers.length; i++)
/******/ hotStatusHandlers[i].call(null, newStatus);
/******/ }
/******/
/******/ // while downloading
/******/ var hotWaitingFiles = 0;
/******/ var hotChunksLoading = 0;
/******/ var hotWaitingFilesMap = {};
/******/ var hotRequestedFilesMap = {};
/******/ var hotAvailibleFilesMap = {};
/******/ var hotCallback;
/******/
/******/ // The update info
/******/ var hotUpdate, hotUpdateNewHash;
/******/
/******/ function toModuleId(id) {
/******/ var isNumber = (+id) + "" === id;
/******/ return isNumber ? +id : id;
/******/ }
/******/
/******/ function hotCheck(apply, callback) {
/******/ if(hotStatus !== "idle") throw new Error("check() is only allowed in idle status");
/******/ if(typeof apply === "function") {
/******/ hotApplyOnUpdate = false;
/******/ callback = apply;
/******/ } else {
/******/ hotApplyOnUpdate = apply;
/******/ callback = callback || function(err) {
/******/ if(err) throw err;
/******/ };
/******/ }
/******/ hotSetStatus("check");
/******/ hotDownloadManifest(function(err, update) {
/******/ if(err) return callback(err);
/******/ if(!update) {
/******/ hotSetStatus("idle");
/******/ callback(null, null);
/******/ return;
/******/ }
/******/
/******/ hotRequestedFilesMap = {};
/******/ hotAvailibleFilesMap = {};
/******/ hotWaitingFilesMap = {};
/******/ for(var i = 0; i < update.c.length; i++)
/******/ hotAvailibleFilesMap[update.c[i]] = true;
/******/ hotUpdateNewHash = update.h;
/******/
/******/ hotSetStatus("prepare");
/******/ hotCallback = callback;
/******/ hotUpdate = {};
/******/ var chunkId = 0;
/******/ { // eslint-disable-line no-lone-blocks
/******/ /*globals chunkId */
/******/ hotEnsureUpdateChunk(chunkId);
/******/ }
/******/ if(hotStatus === "prepare" && hotChunksLoading === 0 && hotWaitingFiles === 0) {
/******/ hotUpdateDownloaded();
/******/ }
/******/ });
/******/ }
/******/
/******/ function hotAddUpdateChunk(chunkId, moreModules) { // eslint-disable-line no-unused-vars
/******/ if(!hotAvailibleFilesMap[chunkId] || !hotRequestedFilesMap[chunkId])
/******/ return;
/******/ hotRequestedFilesMap[chunkId] = false;
/******/ for(var moduleId in moreModules) {
/******/ if(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
/******/ hotUpdate[moduleId] = moreModules[moduleId];
/******/ }
/******/ }
/******/ if(--hotWaitingFiles === 0 && hotChunksLoading === 0) {
/******/ hotUpdateDownloaded();
/******/ }
/******/ }
/******/
/******/ function hotEnsureUpdateChunk(chunkId) {
/******/ if(!hotAvailibleFilesMap[chunkId]) {
/******/ hotWaitingFilesMap[chunkId] = true;
/******/ } else {
/******/ hotRequestedFilesMap[chunkId] = true;
/******/ hotWaitingFiles++;
/******/ hotDownloadUpdateChunk(chunkId);
/******/ }
/******/ }
/******/
/******/ function hotUpdateDownloaded() {
/******/ hotSetStatus("ready");
/******/ var callback = hotCallback;
/******/ hotCallback = null;
/******/ if(!callback) return;
/******/ if(hotApplyOnUpdate) {
/******/ hotApply(hotApplyOnUpdate, callback);
/******/ } else {
/******/ var outdatedModules = [];
/******/ for(var id in hotUpdate) {
/******/ if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
/******/ outdatedModules.push(toModuleId(id));
/******/ }
/******/ }
/******/ callback(null, outdatedModules);
/******/ }
/******/ }
/******/
/******/ function hotApply(options, callback) {
/******/ if(hotStatus !== "ready") throw new Error("apply() is only allowed in ready status");
/******/ if(typeof options === "function") {
/******/ callback = options;
/******/ options = {};
/******/ } else if(options && typeof options === "object") {
/******/ callback = callback || function(err) {
/******/ if(err) throw err;
/******/ };
/******/ } else {
/******/ options = {};
/******/ callback = callback || function(err) {
/******/ if(err) throw err;
/******/ };
/******/ }
/******/
/******/ function getAffectedStuff(module) {
/******/ var outdatedModules = [module];
/******/ var outdatedDependencies = {};
/******/
/******/ var queue = outdatedModules.slice();
/******/ while(queue.length > 0) {
/******/ var moduleId = queue.pop();
/******/ var module = installedModules[moduleId];
/******/ if(!module || module.hot._selfAccepted)
/******/ continue;
/******/ if(module.hot._selfDeclined) {
/******/ return new Error("Aborted because of self decline: " + moduleId);
/******/ }
/******/ if(moduleId === 0) {
/******/ return;
/******/ }
/******/ for(var i = 0; i < module.parents.length; i++) {
/******/ var parentId = module.parents[i];
/******/ var parent = installedModules[parentId];
/******/ if(parent.hot._declinedDependencies[moduleId]) {
/******/ return new Error("Aborted because of declined dependency: " + moduleId + " in " + parentId);
/******/ }
/******/ if(outdatedModules.indexOf(parentId) >= 0) continue;
/******/ if(parent.hot._acceptedDependencies[moduleId]) {
/******/ if(!outdatedDependencies[parentId])
/******/ outdatedDependencies[parentId] = [];
/******/ addAllToSet(outdatedDependencies[parentId], [moduleId]);
/******/ continue;
/******/ }
/******/ delete outdatedDependencies[parentId];
/******/ outdatedModules.push(parentId);
/******/ queue.push(parentId);
/******/ }
/******/ }
/******/
/******/ return [outdatedModules, outdatedDependencies];
/******/ }
/******/
/******/ function addAllToSet(a, b) {
/******/ for(var i = 0; i < b.length; i++) {
/******/ var item = b[i];
/******/ if(a.indexOf(item) < 0)
/******/ a.push(item);
/******/ }
/******/ }
/******/
/******/ // at begin all updates modules are outdated
/******/ // the "outdated" status can propagate to parents if they don't accept the children
/******/ var outdatedDependencies = {};
/******/ var outdatedModules = [];
/******/ var appliedUpdate = {};
/******/ for(var id in hotUpdate) {
/******/ if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
/******/ var moduleId = toModuleId(id);
/******/ var result = getAffectedStuff(moduleId);
/******/ if(!result) {
/******/ if(options.ignoreUnaccepted)
/******/ continue;
/******/ hotSetStatus("abort");
/******/ return callback(new Error("Aborted because " + moduleId + " is not accepted"));
/******/ }
/******/ if(result instanceof Error) {
/******/ hotSetStatus("abort");
/******/ return callback(result);
/******/ }
/******/ appliedUpdate[moduleId] = hotUpdate[moduleId];
/******/ addAllToSet(outdatedModules, result[0]);
/******/ for(var moduleId in result[1]) {
/******/ if(Object.prototype.hasOwnProperty.call(result[1], moduleId)) {
/******/ if(!outdatedDependencies[moduleId])
/******/ outdatedDependencies[moduleId] = [];
/******/ addAllToSet(outdatedDependencies[moduleId], result[1][moduleId]);
/******/ }
/******/ }
/******/ }
/******/ }
/******/
/******/ // Store self accepted outdated modules to require them later by the module system
/******/ var outdatedSelfAcceptedModules = [];
/******/ for(var i = 0; i < outdatedModules.length; i++) {
/******/ var moduleId = outdatedModules[i];
/******/ if(installedModules[moduleId] && installedModules[moduleId].hot._selfAccepted)
/******/ outdatedSelfAcceptedModules.push({
/******/ module: moduleId,
/******/ errorHandler: installedModules[moduleId].hot._selfAccepted
/******/ });
/******/ }
/******/
/******/ // Now in "dispose" phase
/******/ hotSetStatus("dispose");
/******/ var queue = outdatedModules.slice();
/******/ while(queue.length > 0) {
/******/ var moduleId = queue.pop();
/******/ var module = installedModules[moduleId];
/******/ if(!module) continue;
/******/
/******/ var data = {};
/******/
/******/ // Call dispose handlers
/******/ var disposeHandlers = module.hot._disposeHandlers;
/******/ for(var j = 0; j < disposeHandlers.length; j++) {
/******/ var cb = disposeHandlers[j];
/******/ cb(data);
/******/ }
/******/ hotCurrentModuleData[moduleId] = data;
/******/
/******/ // disable module (this disables requires from this module)
/******/ module.hot.active = false;
/******/
/******/ // remove module from cache
/******/ delete installedModules[moduleId];
/******/
/******/ // remove "parents" references from all children
/******/ for(var j = 0; j < module.children.length; j++) {
/******/ var child = installedModules[module.children[j]];
/******/ if(!child) continue;
/******/ var idx = child.parents.indexOf(moduleId);
/******/ if(idx >= 0) {
/******/ child.parents.splice(idx, 1);
/******/ }
/******/ }
/******/ }
/******/
/******/ // remove outdated dependency from module children
/******/ for(var moduleId in outdatedDependencies) {
/******/ if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
/******/ var module = installedModules[moduleId];
/******/ var moduleOutdatedDependencies = outdatedDependencies[moduleId];
/******/ for(var j = 0; j < moduleOutdatedDependencies.length; j++) {
/******/ var dependency = moduleOutdatedDependencies[j];
/******/ var idx = module.children.indexOf(dependency);
/******/ if(idx >= 0) module.children.splice(idx, 1);
/******/ }
/******/ }
/******/ }
/******/
/******/ // Not in "apply" phase
/******/ hotSetStatus("apply");
/******/
/******/ hotCurrentHash = hotUpdateNewHash;
/******/
/******/ // insert new code
/******/ for(var moduleId in appliedUpdate) {
/******/ if(Object.prototype.hasOwnProperty.call(appliedUpdate, moduleId)) {
/******/ modules[moduleId] = appliedUpdate[moduleId];
/******/ }
/******/ }
/******/
/******/ // call accept handlers
/******/ var error = null;
/******/ for(var moduleId in outdatedDependencies) {
/******/ if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
/******/ var module = installedModules[moduleId];
/******/ var moduleOutdatedDependencies = outdatedDependencies[moduleId];
/******/ var callbacks = [];
/******/ for(var i = 0; i < moduleOutdatedDependencies.length; i++) {
/******/ var dependency = moduleOutdatedDependencies[i];
/******/ var cb = module.hot._acceptedDependencies[dependency];
/******/ if(callbacks.indexOf(cb) >= 0) continue;
/******/ callbacks.push(cb);
/******/ }
/******/ for(var i = 0; i < callbacks.length; i++) {
/******/ var cb = callbacks[i];
/******/ try {
/******/ cb(outdatedDependencies);
/******/ } catch(err) {
/******/ if(!error)
/******/ error = err;
/******/ }
/******/ }
/******/ }
/******/ }
/******/
/******/ // Load self accepted modules
/******/ for(var i = 0; i < outdatedSelfAcceptedModules.length; i++) {
/******/ var item = outdatedSelfAcceptedModules[i];
/******/ var moduleId = item.module;
/******/ hotCurrentParents = [moduleId];
/******/ try {
/******/ __webpack_require__(moduleId);
/******/ } catch(err) {
/******/ if(typeof item.errorHandler === "function") {
/******/ try {
/******/ item.errorHandler(err);
/******/ } catch(err) {
/******/ if(!error)
/******/ error = err;
/******/ }
/******/ } else if(!error)
/******/ error = err;
/******/ }
/******/ }
/******/
/******/ // handle errors in accept handlers and self accepted module load
/******/ if(error) {
/******/ hotSetStatus("fail");
/******/ return callback(error);
/******/ }
/******/
/******/ hotSetStatus("idle");
/******/ callback(null, outdatedModules);
/******/ }
/******/ // 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] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false,
/******/ hot: hotCreateModule(moduleId),
/******/ parents: hotCurrentParents,
/******/ children: []
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, hotCreateRequire(moduleId));
/******/ // Flag the module as loaded
/******/ module.loaded = 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;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // __webpack_hash__
/******/ __webpack_require__.h = function() { return hotCurrentHash; };
/******/ // Load entry module and return exports
/******/ return hotCreateRequire(0)(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
var riot = __webpack_require__(1);
// Provide some settings
riot.settings.brackets = '{{ }}';
// Get application tag and mount it! Yeah baby!
__webpack_require__(3);
riot.mount('app');
// Router
__webpack_require__(33);
// SASS
__webpack_require__(52);
__webpack_require__(54);
__webpack_require__(56);
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_RESULT__;/* Riot v2.6.8, @license MIT */
;(function(window, undefined) {
'use strict';
var riot = { version: 'v2.6.8', settings: {} },
// be aware, internal usage
// ATTENTION: prefix the global dynamic variables with `__`
// counter to give a unique id to all the Tag instances
__uid = 0,
// tags instances cache
__virtualDom = [],
// tags implementation cache
__tagImpl = {},
/**
* Const
*/
GLOBAL_MIXIN = '__global_mixin',
// riot specific prefixes
RIOT_PREFIX = 'riot-',
RIOT_TAG = RIOT_PREFIX + 'tag',
RIOT_TAG_IS = 'data-is',
// for typeof == '' comparisons
T_STRING = 'string',
T_OBJECT = 'object',
T_UNDEF = 'undefined',
T_FUNCTION = 'function',
XLINK_NS = 'http://www.w3.org/1999/xlink',
XLINK_REGEX = /^xlink:(\w+)/,
// special native tags that cannot be treated like the others
SPECIAL_TAGS_REGEX = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?|opt(?:ion|group))$/,
RESERVED_WORDS_BLACKLIST = /^(?:_(?:item|id|parent)|update|root|(?:un)?mount|mixin|is(?:Mounted|Loop)|tags|parent|opts|trigger|o(?:n|ff|ne))$/,
// SVG tags list https://www.w3.org/TR/SVG/attindex.html#PresentationAttributes
SVG_TAGS_LIST = ['altGlyph', 'animate', 'animateColor', 'circle', 'clipPath', 'defs', 'ellipse', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feFlood', 'feGaussianBlur', 'feImage', 'feMerge', 'feMorphology', 'feOffset', 'feSpecularLighting', 'feTile', 'feTurbulence', 'filter', 'font', 'foreignObject', 'g', 'glyph', 'glyphRef', 'image', 'line', 'linearGradient', 'marker', 'mask', 'missing-glyph', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'switch', 'symbol', 'text', 'textPath', 'tref', 'tspan', 'use'],
// version# for IE 8-11, 0 for others
IE_VERSION = (window && window.document || {}).documentMode | 0,
// detect firefox to fix #1374
FIREFOX = window && !!window.InstallTrigger
/* istanbul ignore next */
riot.observable = function(el) {
/**
* Extend the original object or create a new empty one
* @type { Object }
*/
el = el || {}
/**
* Private variables
*/
var callbacks = {},
slice = Array.prototype.slice
/**
* Private Methods
*/
/**
* Helper function needed to get and loop all the events in a string
* @param { String } e - event string
* @param {Function} fn - callback
*/
function onEachEvent(e, fn) {
var es = e.split(' '), l = es.length, i = 0
for (; i < l; i++) {
var name = es[i]
if (name) fn(name, i)
}
}
/**
* Public Api
*/
// extend the el object adding the observable methods
Object.defineProperties(el, {
/**
* Listen to the given space separated list of `events` and
* execute the `callback` each time an event is triggered.
* @param { String } events - events ids
* @param { Function } fn - callback function
* @returns { Object } el
*/
on: {
value: function(events, fn) {
if (typeof fn != 'function') return el
onEachEvent(events, function(name, pos) {
(callbacks[name] = callbacks[name] || []).push(fn)
fn.typed = pos > 0
})
return el
},
enumerable: false,
writable: false,
configurable: false
},
/**
* Removes the given space separated list of `events` listeners
* @param { String } events - events ids
* @param { Function } fn - callback function
* @returns { Object } el
*/
off: {
value: function(events, fn) {
if (events == '*' && !fn) callbacks = {}
else {
onEachEvent(events, function(name, pos) {
if (fn) {
var arr = callbacks[name]
for (var i = 0, cb; cb = arr && arr[i]; ++i) {
if (cb == fn) arr.splice(i--, 1)
}
} else delete callbacks[name]
})
}
return el
},
enumerable: false,
writable: false,
configurable: false
},
/**
* Listen to the given space separated list of `events` and
* execute the `callback` at most once
* @param { String } events - events ids
* @param { Function } fn - callback function
* @returns { Object } el
*/
one: {
value: function(events, fn) {
function on() {
el.off(events, on)
fn.apply(el, arguments)
}
return el.on(events, on)
},
enumerable: false,
writable: false,
configurable: false
},
/**
* Execute all callback functions that listen to
* the given space separated list of `events`
* @param { String } events - events ids
* @returns { Object } el
*/
trigger: {
value: function(events) {
// getting the arguments
var arglen = arguments.length - 1,
args = new Array(arglen),
fns
for (var i = 0; i < arglen; i++) {
args[i] = arguments[i + 1] // skip first argument
}
onEachEvent(events, function(name, pos) {
fns = slice.call(callbacks[name] || [], 0)
for (var i = 0, fn; fn = fns[i]; ++i) {
if (fn.busy) continue
fn.busy = 1
fn.apply(el, fn.typed ? [name].concat(args) : args)
if (fns[i] !== fn) { i-- }
fn.busy = 0
}
if (callbacks['*'] && name != '*')
el.trigger.apply(el, ['*', name].concat(args))
})
return el
},
enumerable: false,
writable: false,
configurable: false
}
})
return el
}
/* istanbul ignore next */
;(function(riot) {
/**
* Simple client-side router
* @module riot-route
*/
var RE_ORIGIN = /^.+?\/\/+[^\/]+/,
EVENT_LISTENER = 'EventListener',
REMOVE_EVENT_LISTENER = 'remove' + EVENT_LISTENER,
ADD_EVENT_LISTENER = 'add' + EVENT_LISTENER,
HAS_ATTRIBUTE = 'hasAttribute',
REPLACE = 'replace',
POPSTATE = 'popstate',
HASHCHANGE = 'hashchange',
TRIGGER = 'trigger',
MAX_EMIT_STACK_LEVEL = 3,
win = typeof window != 'undefined' && window,
doc = typeof document != 'undefined' && document,
hist = win && history,
loc = win && (hist.location || win.location), // see html5-history-api
prot = Router.prototype, // to minify more
clickEvent = doc && doc.ontouchstart ? 'touchstart' : 'click',
started = false,
central = riot.observable(),
routeFound = false,
debouncedEmit,
base, current, parser, secondParser, emitStack = [], emitStackLevel = 0
/**
* Default parser. You can replace it via router.parser method.
* @param {string} path - current path (normalized)
* @returns {array} array
*/
function DEFAULT_PARSER(path) {
return path.split(/[/?#]/)
}
/**
* Default parser (second). You can replace it via router.parser method.
* @param {string} path - current path (normalized)
* @param {string} filter - filter string (normalized)
* @returns {array} array
*/
function DEFAULT_SECOND_PARSER(path, filter) {
var re = new RegExp('^' + filter[REPLACE](/\*/g, '([^/?#]+?)')[REPLACE](/\.\./, '.*') + '$'),
args = path.match(re)
if (args) return args.slice(1)
}
/**
* Simple/cheap debounce implementation
* @param {function} fn - callback
* @param {number} delay - delay in seconds
* @returns {function} debounced function
*/
function debounce(fn, delay) {
var t
return function () {
clearTimeout(t)
t = setTimeout(fn, delay)
}
}
/**
* Set the window listeners to trigger the routes
* @param {boolean} autoExec - see route.start
*/
function start(autoExec) {
debouncedEmit = debounce(emit, 1)
win[ADD_EVENT_LISTENER](POPSTATE, debouncedEmit)
win[ADD_EVENT_LISTENER](HASHCHANGE, debouncedEmit)
doc[ADD_EVENT_LISTENER](clickEvent, click)
if (autoExec) emit(true)
}
/**
* Router class
*/
function Router() {
this.$ = []
riot.observable(this) // make it observable
central.on('stop', this.s.bind(this))
central.on('emit', this.e.bind(this))
}
function normalize(path) {
return path[REPLACE](/^\/|\/$/, '')
}
function isString(str) {
return typeof str == 'string'
}
/**
* Get the part after domain name
* @param {string} href - fullpath
* @returns {string} path from root
*/
function getPathFromRoot(href) {
return (href || loc.href)[REPLACE](RE_ORIGIN, '')
}
/**
* Get the part after base
* @param {string} href - fullpath
* @returns {string} path from base
*/
function getPathFromBase(href) {
return base[0] == '#'
? (href || loc.href || '').split(base)[1] || ''
: (loc ? getPathFromRoot(href) : href || '')[REPLACE](base, '')
}
function emit(force) {
// the stack is needed for redirections
var isRoot = emitStackLevel == 0, first
if (MAX_EMIT_STACK_LEVEL <= emitStackLevel) return
emitStackLevel++
emitStack.push(function() {
var path = getPathFromBase()
if (force || path != current) {
central[TRIGGER]('emit', path)
current = path
}
})
if (isRoot) {
while (first = emitStack.shift()) first() // stack increses within this call
emitStackLevel = 0
}
}
function click(e) {
if (
e.which != 1 // not left click
|| e.metaKey || e.ctrlKey || e.shiftKey // or meta keys
|| e.defaultPrevented // or default prevented
) return
var el = e.target
while (el && el.nodeName != 'A') el = el.parentNode
if (
!el || el.nodeName != 'A' // not A tag
|| el[HAS_ATTRIBUTE]('download') // has download attr
|| !el[HAS_ATTRIBUTE]('href') // has no href attr
|| el.target && el.target != '_self' // another window or frame
|| el.href.indexOf(loc.href.match(RE_ORIGIN)[0]) == -1 // cross origin
) return
if (el.href != loc.href
&& (
el.href.split('#')[0] == loc.href.split('#')[0] // internal jump
|| base[0] != '#' && getPathFromRoot(el.href).indexOf(base) !== 0 // outside of base
|| base[0] == '#' && el.href.split(base)[0] != loc.href.split(base)[0] // outside of #base
|| !go(getPathFromBase(el.href), el.title || doc.title) // route not found
)) return
e.preventDefault()
}
/**
* Go to the path
* @param {string} path - destination path
* @param {string} title - page title
* @param {boolean} shouldReplace - use replaceState or pushState
* @returns {boolean} - route not found flag
*/
function go(path, title, shouldReplace) {
// Server-side usage: directly execute handlers for the path
if (!hist) return central[TRIGGER]('emit', getPathFromBase(path))
path = base + normalize(path)
title = title || doc.title
// browsers ignores the second parameter `title`
shouldReplace
? hist.replaceState(null, title, path)
: hist.pushState(null, title, path)
// so we need to set it manually
doc.title = title
routeFound = false
emit()
return routeFound
}
/**
* Go to path or set action
* a single string: go there
* two strings: go there with setting a title
* two strings and boolean: replace history with setting a title
* a single function: set an action on the default route
* a string/RegExp and a function: set an action on the route
* @param {(string|function)} first - path / action / filter
* @param {(string|RegExp|function)} second - title / action
* @param {boolean} third - replace flag
*/
prot.m = function(first, second, third) {
if (isString(first) && (!second || isString(second))) go(first, second, third || false)
else if (second) this.r(first, second)
else this.r('@', first)
}
/**
* Stop routing
*/
prot.s = function() {
this.off('*')
this.$ = []
}
/**
* Emit
* @param {string} path - path
*/
prot.e = function(path) {
this.$.concat('@').some(function(filter) {
var args = (filter == '@' ? parser : secondParser)(normalize(path), normalize(filter))
if (typeof args != 'undefined') {
this[TRIGGER].apply(null, [filter].concat(args))
return routeFound = true // exit from loop
}
}, this)
}
/**
* Register route
* @param {string} filter - filter for matching to url
* @param {function} action - action to register
*/
prot.r = function(filter, action) {
if (filter != '@') {
filter = '/' + normalize(filter)
this.$.push(filter)
}
this.on(filter, action)
}
var mainRouter = new Router()
var route = mainRouter.m.bind(mainRouter)
/**
* Create a sub router
* @returns {function} the method of a new Router object
*/
route.create = function() {
var newSubRouter = new Router()
// assign sub-router's main method
var router = newSubRouter.m.bind(newSubRouter)
// stop only this sub-router
router.stop = newSubRouter.s.bind(newSubRouter)
return router
}
/**
* Set the base of url
* @param {(str|RegExp)} arg - a new base or '#' or '#!'
*/
route.base = function(arg) {
base = arg || '#'
current = getPathFromBase() // recalculate current path
}
/** Exec routing right now **/
route.exec = function() {
emit(true)
}
/**
* Replace the default router to yours
* @param {function} fn - your parser function
* @param {function} fn2 - your secondParser function
*/
route.parser = function(fn, fn2) {
if (!fn && !fn2) {
// reset parser for testing...
parser = DEFAULT_PARSER
secondParser = DEFAULT_SECOND_PARSER
}
if (fn) parser = fn
if (fn2) secondParser = fn2
}
/**
* Helper function to get url query as an object
* @returns {object} parsed query
*/
route.query = function() {
var q = {}
var href = loc.href || current
href[REPLACE](/[?&](.+?)=([^&]*)/g, function(_, k, v) { q[k] = v })
return q
}
/** Stop routing **/
route.stop = function () {
if (started) {
if (win) {
win[REMOVE_EVENT_LISTENER](POPSTATE, debouncedEmit)
win[REMOVE_EVENT_LISTENER](HASHCHANGE, debouncedEmit)
doc[REMOVE_EVENT_LISTENER](clickEvent, click)
}
central[TRIGGER]('stop')
started = false
}
}
/**
* Start routing
* @param {boolean} autoExec - automatically exec after starting if true
*/
route.start = function (autoExec) {
if (!started) {
if (win) {
if (document.readyState == 'complete') start(autoExec)
// the timeout is needed to solve
// a weird safari bug https://github.com/riot/route/issues/33
else win[ADD_EVENT_LISTENER]('load', function() {
setTimeout(function() { start(autoExec) }, 1)
})
}
started = true
}
}
/** Prepare the router **/
route.base()
route.parser()
riot.route = route
})(riot)
/* istanbul ignore next */
/**
* The riot template engine
* @version v2.4.2
*/
/**
* riot.util.brackets
*
* - `brackets ` - Returns a string or regex based on its parameter
* - `brackets.set` - Change the current riot brackets
*
* @module
*/
var brackets = (function (UNDEF) {
var
REGLOB = 'g',
R_MLCOMMS = /\/\*[^*]*\*+(?:[^*\/][^*]*\*+)*\//g,
R_STRINGS = /"[^"\\]*(?:\\[\S\s][^"\\]*)*"|'[^'\\]*(?:\\[\S\s][^'\\]*)*'/g,
S_QBLOCKS = R_STRINGS.source + '|' +
/(?:\breturn\s+|(?:[$\w\)\]]|\+\+|--)\s*(\/)(?![*\/]))/.source + '|' +
/\/(?=[^*\/])[^[\/\\]*(?:(?:\[(?:\\.|[^\]\\]*)*\]|\\.)[^[\/\\]*)*?(\/)[gim]*/.source,
UNSUPPORTED = RegExp('[\\' + 'x00-\\x1F<>a-zA-Z0-9\'",;\\\\]'),
NEED_ESCAPE = /(?=[[\]()*+?.^$|])/g,
FINDBRACES = {
'(': RegExp('([()])|' + S_QBLOCKS, REGLOB),
'[': RegExp('([[\\]])|' + S_QBLOCKS, REGLOB),
'{': RegExp('([{}])|' + S_QBLOCKS, REGLOB)
},
DEFAULT = '{ }'
var _pairs = [
'{', '}',
'{', '}',
/{[^}]*}/,
/\\([{}])/g,
/\\({)|{/g,
RegExp('\\\\(})|([[({])|(})|' + S_QBLOCKS, REGLOB),
DEFAULT,
/^\s*{\^?\s*([$\w]+)(?:\s*,\s*(\S+))?\s+in\s+(\S.*)\s*}/,
/(^|[^\\]){=[\S\s]*?}/
]
var
cachedBrackets = UNDEF,
_regex,
_cache = [],
_settings
function _loopback (re) { return re }
function _rewrite (re, bp) {
if (!bp) bp = _cache
return new RegExp(
re.source.replace(/{/g, bp[2]).replace(/}/g, bp[3]), re.global ? REGLOB : ''
)
}
function _create (pair) {
if (pair === DEFAULT) return _pairs
var arr = pair.split(' ')
if (arr.length !== 2 || UNSUPPORTED.test(pair)) {
throw new Error('Unsupported brackets "' + pair + '"')
}
arr = arr.concat(pair.replace(NEED_ESCAPE, '\\').split(' '))
arr[4] = _rewrite(arr[1].length > 1 ? /{[\S\s]*?}/ : _pairs[4], arr)
arr[5] = _rewrite(pair.length > 3 ? /\\({|})/g : _pairs[5], arr)
arr[6] = _rewrite(_pairs[6], arr)
arr[7] = RegExp('\\\\(' + arr[3] + ')|([[({])|(' + arr[3] + ')|' + S_QBLOCKS, REGLOB)
arr[8] = pair
return arr
}
function _brackets (reOrIdx) {
return reOrIdx instanceof RegExp ? _regex(reOrIdx) : _cache[reOrIdx]
}
_brackets.split = function split (str, tmpl, _bp) {
// istanbul ignore next: _bp is for the compiler
if (!_bp) _bp = _cache
var
parts = [],
match,
isexpr,
start,
pos,
re = _bp[6]
isexpr = start = re.lastIndex = 0
while ((match = re.exec(str))) {
pos = match.index
if (isexpr) {
if (match[2]) {
re.lastIndex = skipBraces(str, match[2], re.lastIndex)
continue
}
if (!match[3]) {
continue
}
}
if (!match[1]) {
unescapeStr(str.slice(start, pos))
start = re.lastIndex
re = _bp[6 + (isexpr ^= 1)]
re.lastIndex = start
}
}
if (str && start < str.length) {
unescapeStr(str.slice(start))
}
return parts
function unescapeStr (s) {
if (tmpl || isexpr) {
parts.push(s && s.replace(_bp[5], '$1'))
} else {
parts.push(s)
}
}
function skipBraces (s, ch, ix) {
var
match,
recch = FINDBRACES[ch]
recch.lastIndex = ix
ix = 1
while ((match = recch.exec(s))) {
if (match[1] &&
!(match[1] === ch ? ++ix : --ix)) break
}
return ix ? s.length : recch.lastIndex
}
}
_brackets.hasExpr = function hasExpr (str) {
return _cache[4].test(str)
}
_brackets.loopKeys = function loopKeys (expr) {
var m = expr.match(_cache[9])
return m
? { key: m[1], pos: m[2], val: _cache[0] + m[3].trim() + _cache[1] }
: { val: expr.trim() }
}
_brackets.array = function array (pair) {
return pair ? _create(pair) : _cache
}
function _reset (pair) {
if ((pair || (pair = DEFAULT)) !== _cache[8]) {
_cache = _create(pair)
_regex = pair === DEFAULT ? _loopback : _rewrite
_cache[9] = _regex(_pairs[9])
}
cachedBrackets = pair
}
function _setSettings (o) {
var b
o = o || {}
b = o.brackets
Object.defineProperty(o, 'brackets', {
set: _reset,
get: function () { return cachedBrackets },
enumerable: true
})
_settings = o
_reset(b)
}
Object.defineProperty(_brackets, 'settings', {
set: _setSettings,
get: function () { return _settings }
})
/* istanbul ignore next: in the browser riot is always in the scope */
_brackets.settings = typeof riot !== 'undefined' && riot.settings || {}
_brackets.set = _reset
_brackets.R_STRINGS = R_STRINGS
_brackets.R_MLCOMMS = R_MLCOMMS
_brackets.S_QBLOCKS = S_QBLOCKS
return _brackets
})()
/**
* @module tmpl
*
* tmpl - Root function, returns the template value, render with data
* tmpl.hasExpr - Test the existence of a expression inside a string
* tmpl.loopKeys - Get the keys for an 'each' loop (used by `_each`)
*/
var tmpl = (function () {
var _cache = {}
function _tmpl (str, data) {
if (!str) return str
return (_cache[str] || (_cache[str] = _create(str))).call(data, _logErr)
}
_tmpl.haveRaw = brackets.hasRaw
_tmpl.hasExpr = brackets.hasExpr
_tmpl.loopKeys = brackets.loopKeys
// istanbul ignore next
_tmpl.clearCache = function () { _cache = {} }
_tmpl.errorHandler = null
function _logErr (err, ctx) {
if (_tmpl.errorHandler) {
err.riotData = {
tagName: ctx && ctx.root && ctx.root.tagName,
_riot_id: ctx && ctx._riot_id //eslint-disable-line camelcase
}
_tmpl.errorHandler(err)
}
}
function _create (str) {
var expr = _getTmpl(str)
if (expr.slice(0, 11) !== 'try{return ') expr = 'return ' + expr
return new Function('E', expr + ';') // eslint-disable-line no-new-func
}
var
CH_IDEXPR = String.fromCharCode(0x2057),
RE_CSNAME = /^(?:(-?[_A-Za-z\xA0-\xFF][-\w\xA0-\xFF]*)|\u2057(\d+)~):/,
RE_QBLOCK = RegExp(brackets.S_QBLOCKS, 'g'),
RE_DQUOTE = /\u2057/g,
RE_QBMARK = /\u2057(\d+)~/g
function _getTmpl (str) {
var
qstr = [],
expr,
parts = brackets.split(str.replace(RE_DQUOTE, '"'), 1)
if (parts.length > 2 || parts[0]) {
var i, j, list = []
for (i = j = 0; i < parts.length; ++i) {
expr = parts[i]
if (expr && (expr = i & 1
? _parseExpr(expr, 1, qstr)
: '"' + expr
.replace(/\\/g, '\\\\')
.replace(/\r\n?|\n/g, '\\n')
.replace(/"/g, '\\"') +
'"'
)) list[j++] = expr
}
expr = j < 2 ? list[0]
: '[' + list.join(',') + '].join("")'
} else {
expr = _parseExpr(parts[1], 0, qstr)
}
if (qstr[0]) {
expr = expr.replace(RE_QBMARK, function (_, pos) {
return qstr[pos]
.replace(/\r/g, '\\r')
.replace(/\n/g, '\\n')
})
}
return expr
}
var
RE_BREND = {
'(': /[()]/g,
'[': /[[\]]/g,
'{': /[{}]/g
}
function _parseExpr (expr, asText, qstr) {
expr = expr
.replace(RE_QBLOCK, function (s, div) {
return s.length > 2 && !div ? CH_IDEXPR + (qstr.push(s) - 1) + '~' : s
})
.replace(/\s+/g, ' ').trim()
.replace(/\ ?([[\({},?\.:])\ ?/g, '$1')
if (expr) {
var
list = [],
cnt = 0,
match
while (expr &&
(match = expr.match(RE_CSNAME)) &&
!match.index
) {
var
key,
jsb,
re = /,|([[{(])|$/g
expr = RegExp.rightContext
key = match[2] ? qstr[match[2]].slice(1, -1).trim().replace(/\s+/g, ' ') : match[1]
while (jsb = (match = re.exec(expr))[1]) skipBraces(jsb, re)
jsb = expr.slice(0, match.index)
expr = RegExp.rightContext
list[cnt++] = _wrapExpr(jsb, 1, key)
}
expr = !cnt ? _wrapExpr(expr, asText)
: cnt > 1 ? '[' + list.join(',') + '].join(" ").trim()' : list[0]
}
return expr
function skipBraces (ch, re) {
var
mm,
lv = 1,
ir = RE_BREND[ch]
ir.lastIndex = re.lastIndex
while (mm = ir.exec(expr)) {
if (mm[0] === ch) ++lv
else if (!--lv) break
}
re.lastIndex = lv ? expr.length : ir.lastIndex
}
}
// istanbul ignore next: not both
var // eslint-disable-next-line max-len
JS_CONTEXT = '"in this?this:' + (typeof window !== 'object' ? 'global' : 'window') + ').',
JS_VARNAME = /[,{][\$\w]+(?=:)|(^ *|[^$\w\.{])(?!(?:typeof|true|false|null|undefined|in|instanceof|is(?:Finite|NaN)|void|NaN|new|Date|RegExp|Math)(?![$\w]))([$_A-Za-z][$\w]*)/g,
JS_NOPROPS = /^(?=(\.[$\w]+))\1(?:[^.[(]|$)/
function _wrapExpr (expr, asText, key) {
var tb
expr = expr.replace(JS_VARNAME, function (match, p, mvar, pos, s) {
if (mvar) {
pos = tb ? 0 : pos + match.length
if (mvar !== 'this' && mvar !== 'global' && mvar !== 'window') {
match = p + '("' + mvar + JS_CONTEXT + mvar
if (pos) tb = (s = s[pos]) === '.' || s === '(' || s === '['
} else if (pos) {
tb = !JS_NOPROPS.test(s.slice(pos))
}
}
return match
})
if (tb) {
expr = 'try{return ' + expr + '}catch(e){E(e,this)}'
}
if (key) {
expr = (tb
? 'function(){' + expr + '}.call(this)' : '(' + expr + ')'
) + '?"' + key + '":""'
} else if (asText) {
expr = 'function(v){' + (tb
? expr.replace('return ', 'v=') : 'v=(' + expr + ')'
) + ';return v||v===0?v:""}.call(this)'
}
return expr
}
_tmpl.version = brackets.version = 'v2.4.2'
return _tmpl
})()
/*
lib/browser/tag/mkdom.js
Includes hacks needed for the Internet Explorer version 9 and below
See: http://kangax.github.io/compat-table/es5/#ie8
http://codeplanet.io/dropping-ie8/
*/
var mkdom = (function _mkdom() {
var
reHasYield = /<yield\b/i,
reYieldAll = /<yield\s*(?:\/>|>([\S\s]*?)<\/yield\s*>|>)/ig,
reYieldSrc = /<yield\s+to=['"]([^'">]*)['"]\s*>([\S\s]*?)<\/yield\s*>/ig,
reYieldDest = /<yield\s+from=['"]?([-\w]+)['"]?\s*(?:\/>|>([\S\s]*?)<\/yield\s*>)/ig
var
rootEls = { tr: 'tbody', th: 'tr', td: 'tr', col: 'colgroup' },
tblTags = IE_VERSION && IE_VERSION < 10
? SPECIAL_TAGS_REGEX : /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?)$/
/**
* Creates a DOM element to wrap the given content. Normally an `DIV`, but can be
* also a `TABLE`, `SELECT`, `TBODY`, `TR`, or `COLGROUP` element.
*
* @param { String } templ - The template coming from the custom tag definition
* @param { String } [html] - HTML content that comes from the DOM element where you
* will mount the tag, mostly the original tag in the page
* @param { Boolean } checkSvg - flag needed to know if we need to force the svg rendering in case of loop nodes
* @returns {HTMLElement} DOM element with _templ_ merged through `YIELD` with the _html_.
*/
function _mkdom(templ, html, checkSvg) {
var
match = templ && templ.match(/^\s*<([-\w]+)/),
tagName = match && match[1].toLowerCase(),
el = mkEl('div', checkSvg && isSVGTag(tagName))
// replace all the yield tags with the tag inner html
templ = replaceYield(templ, html)
/* istanbul ignore next */
if (tblTags.test(tagName))
el = specialTags(el, templ, tagName)
else
setInnerHTML(el, templ)
el.stub = true
return el
}
/*
Creates the root element for table or select child elements:
tr/th/td/thead/tfoot/tbody/caption/col/colgroup/option/optgroup
*/
function specialTags(el, templ, tagName) {
var
select = tagName[0] === 'o',
parent = select ? 'select>' : 'table>'
// trim() is important here, this ensures we don't have artifacts,
// so we can check if we have only one element inside the parent
el.innerHTML = '<' + parent + templ.trim() + '</' + parent
parent = el.firstChild
// returns the immediate parent if tr/th/td/col is the only element, if not
// returns the whole tree, as this can include additional elements
if (select) {
parent.selectedIndex = -1 // for IE9, compatible w/current riot behavior
} else {
// avoids insertion of cointainer inside container (ex: tbody inside tbody)
var tname = rootEls[tagName]
if (tname && parent.childElementCount === 1) parent = $(tname, parent)
}
return parent
}
/*
Replace the yield tag from any tag template with the innerHTML of the
original tag in the page
*/
function replaceYield(templ, html) {
// do nothing if no yield
if (!reHasYield.test(templ)) return templ
// be careful with #1343 - string on the source having `$1`
var src = {}
html = html && html.replace(reYieldSrc, function (_, ref, text) {
src[ref] = src[ref] || text // preserve first definition
return ''
}).trim()
return templ
.replace(reYieldDest, function (_, ref, def) { // yield with from - to attrs
return src[ref] || def || ''
})
.replace(reYieldAll, function (_, def) { // yield without any "from"
return html || def || ''
})
}
return _mkdom
})()
/**
* Convert the item looped into an object used to extend the child tag properties
* @param { Object } expr - object containing the keys used to extend the children tags
* @param { * } key - value to assign to the new object returned
* @param { * } val - value containing the position of the item in the array
* @returns { Object } - new object containing the values of the original item
*
* The variables 'key' and 'val' are arbitrary.
* They depend on the collection type looped (Array, Object)
* and on the expression used on the each tag
*
*/
function mkitem(expr, key, val) {
var item = {}
item[expr.key] = key
if (expr.pos) item[expr.pos] = val
return item
}
/**
* Unmount the redundant tags
* @param { Array } items - array containing the current items to loop
* @param { Array } tags - array containing all the children tags
*/
function unmountRedundant(items, tags) {
var i = tags.length,
j = items.length,
t
while (i > j) {
t = tags[--i]
tags.splice(i, 1)
t.unmount()
}
}
/**
* Move the nested custom tags in non custom loop tags
* @param { Object } child - non custom loop tag
* @param { Number } i - current position of the loop tag
*/
function moveNestedTags(child, i) {
Object.keys(child.tags).forEach(function(tagName) {
var tag = child.tags[tagName]
if (isArray(tag))
each(tag, function (t) {
moveChildTag(t, tagName, i)
})
else
moveChildTag(tag, tagName, i)
})
}
/**
* Adds the elements for a virtual tag
* @param { Tag } tag - the tag whose root's children will be inserted or appended
* @param { Node } src - the node that will do the inserting or appending
* @param { Tag } target - only if inserting, insert before this tag's first child
*/
function addVirtual(tag, src, target) {
var el = tag._root, sib
tag._virts = []
while (el) {
sib = el.nextSibling
if (target)
src.insertBefore(el, target._root)
else
src.appendChild(el)
tag._virts.push(el) // hold for unmounting
el = sib
}
}
/**
* Move virtual tag and all child nodes
* @param { Tag } tag - first child reference used to start move
* @param { Node } src - the node that will do the inserting
* @param { Tag } target - insert before this tag's first child
* @param { Number } len - how many child nodes to move
*/
function moveVirtual(tag, src, target, len) {
var el = tag._root, sib, i = 0
for (; i < len; i++) {
sib = el.nextSibling
src.insertBefore(el, target._root)
el = sib
}
}
/**
* Insert a new tag avoiding the insert for the conditional tags
* @param {Boolean} isVirtual [description]
* @param { Tag } prevTag - tag instance used as reference to prepend our new tag
* @param { Tag } newTag - new tag to be inserted
* @param { HTMLElement } root - loop parent node
* @param { Array } tags - array containing the current tags list
* @param { Function } virtualFn - callback needed to move or insert virtual DOM
* @param { Object } dom - DOM node we need to loop
*/
function insertTag(isVirtual, prevTag, newTag, root, tags, virtualFn, dom) {
if (isInStub(prevTag.root)) return
if (isVirtual) virtualFn(prevTag, root, newTag, dom.childNodes.length)
else root.insertBefore(prevTag.root, newTag.root) // #1374 some browsers reset selected here
}
/**
* Manage tags having the 'each'
* @param { Object } dom - DOM node we need to loop
* @param { Tag } parent - parent tag instance where the dom node is contained
* @param { String } expr - string contained in the 'each' attribute
*/
function _each(dom, parent, expr) {
// remove the each property from the original tag
remAttr(dom, 'each')
var mustReorder = typeof getAttr(dom, 'no-reorder') !== T_STRING || remAttr(dom, 'no-reorder'),
tagName = getTagName(dom),
impl = __tagImpl[tagName] || { tmpl: getOuterHTML(dom) },
useRoot = SPECIAL_TAGS_REGEX.test(tagName),
root = dom.parentNode,
ref = document.createTextNode(''),
child = getTag(dom),
isOption = tagName.toLowerCase() === 'option', // the option tags must be treated differently
tags = [],
oldItems = [],
hasKeys,
isVirtual = dom.tagName == 'VIRTUAL'
// parse the each expression
expr = tmpl.loopKeys(expr)
// insert a marked where the loop tags will be injected
root.insertBefore(ref, dom)
// clean template code
parent.one('before-mount', function () {
// remove the original DOM node
dom.parentNode.removeChild(dom)
if (root.stub) root = parent.root
}).on('update', function () {
// get the new items collection
var items = tmpl(expr.val, parent),
// create a fragment to hold the new DOM nodes to inject in the parent tag
frag = document.createDocumentFragment()
// object loop. any changes cause full redraw
if (!isArray(items)) {
hasKeys = items || false
items = hasKeys ?
Object.keys(items).map(function (key) {
return mkitem(expr, key, items[key])
}) : []
}
// loop all the new items
var i = 0,
itemsLength = items.length
for (; i < itemsLength; i++) {
// reorder only if the items are objects
var
item = items[i],
_mustReorder = mustReorder && typeof item == T_OBJECT && !hasKeys,
oldPos = oldItems.indexOf(item),
pos = ~oldPos && _mustReorder ? oldPos : i,
// does a tag exist in this position?
tag = tags[pos]
item = !hasKeys && expr.key ? mkitem(expr, item, i) : item
// new tag
if (
!_mustReorder && !tag // with no-reorder we just update the old tags
||
_mustReorder && !~oldPos || !tag // by default we always try to reorder the DOM elements
) {
tag = new Tag(impl, {
parent: parent,
isLoop: true,
hasImpl: !!__tagImpl[tagName],
root: useRoot ? root : dom.cloneNode(),
item: item
}, dom.innerHTML)
tag.mount()
if (isVirtual) tag._root = tag.root.firstChild // save reference for further moves or inserts
// this tag must be appended
if (i == tags.length || !tags[i]) { // fix 1581
if (isVirtual)
addVirtual(tag, frag)
else frag.appendChild(tag.root)
}
// this tag must be insert
else {
insertTag(isVirtual, tag, tags[i], root, tags, addVirtual, dom)
oldItems.splice(i, 0, item)
}
tags.splice(i, 0, tag)
pos = i // handled here so no move
} else tag.update(item, true)
// reorder the tag if it's not located in its previous position
if (
pos !== i && _mustReorder &&
tags[i] // fix 1581 unable to reproduce it in a test!
) {
// #closes 2040 PLEASE DON'T REMOVE IT!
// there are no tests for this feature
if (contains(items, oldItems[i]))
insertTag(isVirtual, tag, tags[i], root, tags, moveVirtual, dom)
// update the position attribute if it exists
if (expr.pos)
tag[expr.pos] = i
// move the old tag instance
tags.splice(i, 0, tags.splice(pos, 1)[0])
// move the old item
oldItems.splice(i, 0, oldItems.splice(pos, 1)[0])
// if the loop tags are not custom
// we need to move all their custom tags into the right position
if (!child && tag.tags) moveNestedTags(tag, i)
}
// cache the original item to use it in the events bound to this node
// and its children
tag._item = item
// cache the real parent tag internally
defineProperty(tag, '_parent', parent)
}
// remove the redundant tags
unmountRedundant(items, tags)
// insert the new nodes
root.insertBefore(frag, ref)
if (isOption) {
// #1374 FireFox bug in <option selected={expression}>
if (FIREFOX && !root.multiple) {
for (var n = 0; n < root.length; n++) {
if (root[n].__riot1374) {
root.selectedIndex = n // clear other options
delete root[n].__riot1374
break
}
}
}
}
// set the 'tags' property of the parent tag
// if child is 'undefined' it means that we don't need to set this property
// for example:
// we don't need store the `myTag.tags['div']` property if we are looping a div tag
// but we need to track the `myTag.tags['child']` property looping a custom child node named `child`
if (child) parent.tags[tagName] = tags
// clone the items array
oldItems = items.slice()
})
}
/**
* Object that will be used to inject and manage the css of every tag instance
*/
var styleManager = (function(_riot) {
if (!window) return { // skip injection on the server
add: function () {},
inject: function () {}
}
var styleNode = (function () {
// create a new style element with the correct type
var newNode = mkEl('style')
setAttr(newNode, 'type', 'text/css')
// replace any user node or insert the new one into the head
var userNode = $('style[type=riot]')
if (userNode) {
if (userNode.id) newNode.id = userNode.id
userNode.parentNode.replaceChild(newNode, userNode)
}
else document.getElementsByTagName('head')[0].appendChild(newNode)
return newNode
})()
// Create cache and shortcut to the correct property
var cssTextProp = styleNode.styleSheet,
stylesToInject = ''
// Expose the style node in a non-modificable property
Object.defineProperty(_riot, 'styleNode', {
value: styleNode,
writable: true
})
/**
* Public api
*/
return {
/**
* Save a tag style to be later injected into DOM
* @param { String } css [description]
*/
add: function(css) {
stylesToInject += css
},
/**
* Inject all previously saved tag styles into DOM
* innerHTML seems slow: http://jsperf.com/riot-insert-style
*/
inject: function() {
if (stylesToInject) {
if (cssTextProp) cssTextProp.cssText += stylesToInject
else styleNode.innerHTML += stylesToInject
stylesToInject = ''
}
}
}
})(riot)
function parseNamedElements(root, tag, childTags, forceParsingNamed) {
walk(root, function(dom) {
if (dom.nodeType == 1) {
dom.isLoop = dom.isLoop ||
(dom.parentNode && dom.parentNode.isLoop || getAttr(dom, 'each'))
? 1 : 0
// custom child tag
if (childTags) {
var child = getTag(dom)
if (child && !dom.isLoop)
childTags.push(initChildTag(child, {root: dom, parent: tag}, dom.innerHTML, tag))
}
if (!dom.isLoop || forceParsingNamed)
setNamed(dom, tag, [])
}
})
}
function parseExpressions(root, tag, expressions) {
function addExpr(dom, val, extra) {
if (tmpl.hasExpr(val)) {
expressions.push(extend({ dom: dom, expr: val }, extra))
}
}
walk(root, function(dom) {
var type = dom.nodeType,
attr
// text node
if (type == 3 && dom.parentNode.tagName != 'STYLE') addExpr(dom, dom.nodeValue)
if (type != 1) return
/* element */
// loop
attr = getAttr(dom, 'each')
if (attr) { _each(dom, tag, attr); return false }
// attribute expressions
each(dom.attributes, function(attr) {
var name = attr.name,
bool = name.split('__')[1]
addExpr(dom, attr.value, { attr: bool || name, bool: bool })
if (bool) { remAttr(dom, name); return false }
})
// skip custom tags
if (getTag(dom)) return false
})
}
function Tag(impl, conf, innerHTML) {
var self = riot.observable(this),
opts = inherit(conf.opts) || {},
parent = conf.parent,
isLoop = conf.isLoop,
hasImpl = conf.hasImpl,
item = cleanUpData(conf.item),
expressions = [],
childTags = [],
root = conf.root,
tagName = root.tagName.toLowerCase(),
attr = {},
propsInSyncWithParent = [],
dom
// only call unmount if we have a valid __tagImpl (has name property)
if (impl.name && root._tag) root._tag.unmount(true)
// not yet mounted
this.isMounted = false
root.isLoop = isLoop
// keep a reference to the tag just created
// so we will be able to mount this tag multiple times
root._tag = this
// create a unique id to this tag
// it could be handy to use it also to improve the virtual dom rendering speed
defineProperty(this, '_riot_id', ++__uid) // base 1 allows test !t._riot_id
extend(this, { parent: parent, root: root, opts: opts}, item)
// protect the "tags" property from being overridden
defineProperty(this, 'tags', {})
// grab attributes
each(root.attributes, function(el) {
var val = el.value
// remember attributes with expressions only
if (tmpl.hasExpr(val)) attr[el.name] = val
})
dom = mkdom(impl.tmpl, innerHTML, isLoop)
// options
function updateOpts() {
var ctx = hasImpl && isLoop ? self : parent || self
// update opts from current DOM attributes
each(root.attributes, function(el) {
if (el.name in attr) return
var val = el.value
opts[toCamel(el.name)] = tmpl.hasExpr(val) ? tmpl(val, ctx) : val
})
// recover those with expressions
each(Object.keys(attr), function(name) {
opts[toCamel(name)] = tmpl(attr[name], ctx)
})
}
function normalizeData(data) {
for (var key in item) {
if (typeof self[key] !== T_UNDEF && isWritable(self, key))
self[key] = data[key]
}
}
function inheritFrom(target) {
each(Object.keys(target), function(k) {
// some properties must be always in sync with the parent tag
var mustSync = !RESERVED_WORDS_BLACKLIST.test(k) && contains(propsInSyncWithParent, k)
if (typeof self[k] === T_UNDEF || mustSync) {
// track the property to keep in sync
// so we can keep it updated
if (!mustSync) propsInSyncWithParent.push(k)
self[k] = target[k]
}
})
}
/**
* Update the tag expressions and options
* @param { * } data - data we want to use to extend the tag properties
* @param { Boolean } isInherited - is this update coming from a parent tag?
* @returns { self }
*/
defineProperty(this, 'update', function(data, isInherited) {
// make sure the data passed will not override
// the component core methods
data = cleanUpData(data)
// inherit properties from the parent in loop
if (isLoop) {
inheritFrom(self.parent)
}
// normalize the tag properties in case an item object was initially passed
if (data && isObject(item)) {
normalizeData(data)
item = data
}
extend(self, data)
updateOpts()
self.trigger('update', data)
update(expressions, self)
// the updated event will be triggered
// once the DOM will be ready and all the re-flows are completed
// this is useful if you want to get the "real" root properties
// 4 ex: root.offsetWidth ...
if (isInherited && self.parent)
// closes #1599
self.parent.one('updated', function() { self.trigger('updated') })
else rAF(function() { self.trigger('updated') })
return this
})
defineProperty(this, 'mixin', function() {
each(arguments, function(mix) {
var instance,
props = [],
obj
mix = typeof mix === T_STRING ? riot.mixin(mix) : mix
// check if the mixin is a function
if (isFunction(mix)) {
// create the new mixin instance
instance = new mix()
} else instance = mix
var proto = Object.getPrototypeOf(instance)
// build multilevel prototype inheritance chain property list
do props = props.concat(Object.getOwnPropertyNames(obj || instance))
while (obj = Object.getPrototypeOf(obj || instance))
// loop the keys in the function prototype or the all object keys
each(props, function(key) {
// bind methods to self
// allow mixins to override other properties/parent mixins
if (key != 'init') {
// check for getters/setters
var descriptor = Object.getOwnPropertyDescriptor(instance, key) || Object.getOwnPropertyDescriptor(proto, key)
var hasGetterSetter = descriptor && (descriptor.get || descriptor.set)
// apply method only if it does not already exist on the instance
if (!self.hasOwnProperty(key) && hasGetterSetter) {
Object.defineProperty(self, key, descriptor)
} else {
self[key] = isFunction(instance[key]) ?
instance[key].bind(self) :
instance[key]
}
}
})
// init method will be called automatically
if (instance.init) instance.init.bind(self)()
})
return this
})
defineProperty(this, 'mount', function() {
updateOpts()
// add global mixins
var globalMixin = riot.mixin(GLOBAL_MIXIN)
if (globalMixin)
for (var i in globalMixin)
if (globalMixin.hasOwnProperty(i))
self.mixin(globalMixin[i])
// children in loop should inherit from true parent
if (self._parent && self._parent.root.isLoop) {
inheritFrom(self._parent)
}
// initialiation
if (impl.fn) impl.fn.call(self, opts)
// parse layout after init. fn may calculate args for nested custom tags
parseExpressions(dom, self, expressions)
// mount the child tags
toggle(true)
// update the root adding custom attributes coming from the compiler
// it fixes also #1087
if (impl.attrs)
walkAttributes(impl.attrs, function (k, v) { setAttr(root, k, v) })
if (impl.attrs || hasImpl)
parseExpressions(self.root, self, expressions)
if (!self.parent || isLoop) self.update(item)
// internal use only, fixes #403
self.trigger('before-mount')
if (isLoop && !hasImpl) {
// update the root attribute for the looped elements
root = dom.firstChild
} else {
while (dom.firstChild) root.appendChild(dom.firstChild)
if (root.stub) root = parent.root
}
defineProperty(self, 'root', root)
// parse the named dom nodes in the looped child
// adding them to the parent as well
if (isLoop)
parseNamedElements(self.root, self.parent, null, true)
// if it's not a child tag we can trigger its mount event
if (!self.parent || self.parent.isMounted) {
self.isMounted = true
self.trigger('mount')
}
// otherwise we need to wait that the parent event gets triggered
else self.parent.one('mount', function() {
// avoid to trigger the `mount` event for the tags
// not visible included in an if statement
if (!isInStub(self.root)) {
self.parent.isMounted = self.isMounted = true
self.trigger('mount')
}
})
})
defineProperty(this, 'unmount', function(keepRootTag) {
var el = root,
p = el.parentNode,
ptag,
tagIndex = __virtualDom.indexOf(self)
self.trigger('before-unmount')
// remove this tag instance from the global virtualDom variable
if (~tagIndex)
__virtualDom.splice(tagIndex, 1)
if (p) {
if (parent) {
ptag = getImmediateCustomParentTag(parent)
// remove this tag from the parent tags object
// if there are multiple nested tags with same name..
// remove this element form the array
if (isArray(ptag.tags[tagName]))
each(ptag.tags[tagName], function(tag, i) {
if (tag._riot_id == self._riot_id)
ptag.tags[tagName].splice(i, 1)
})
else
// otherwise just delete the tag instance
ptag.tags[tagName] = undefined
}
else
while (el.firstChild) el.removeChild(el.firstChild)
if (!keepRootTag)
p.removeChild(el)
else {
// the riot-tag and the data-is attributes aren't needed anymore, remove them
remAttr(p, RIOT_TAG_IS)
remAttr(p, RIOT_TAG) // this will be removed in riot 3.0.0
}
}
if (this._virts) {
each(this._virts, function(v) {
if (v.parentNode) v.parentNode.removeChild(v)
})
}
self.trigger('unmount')
toggle()
self.off('*')
self.isMounted = false
delete root._tag
})
// proxy function to bind updates
// dispatched from a parent tag
function onChildUpdate(data) { self.update(data, true) }
function toggle(isMount) {
// mount/unmount children
each(childTags, function(child) { child[isMount ? 'mount' : 'unmount']() })
// listen/unlisten parent (events flow one way from parent to children)
if (!parent) return
var evt = isMount ? 'on' : 'off'
// the loop tags will be always in sync with the parent automatically
if (isLoop)
parent[evt]('unmount', self.unmount)
else {
parent[evt]('update', onChildUpdate)[evt]('unmount', self.unmount)
}
}
// named elements available for fn
parseNamedElements(dom, this, childTags)
}
/**
* Attach an event to a DOM node
* @param { String } name - event name
* @param { Function } handler - event callback
* @param { Object } dom - dom node
* @param { Tag } tag - tag instance
*/
function setEventHandler(name, handler, dom, tag) {
dom[name] = function(e) {
var ptag = tag._parent,
item = tag._item,
el
if (!item)
while (ptag && !item) {
item = ptag._item
ptag = ptag._parent
}
// cross browser event fix
e = e || window.event
// override the event properties
if (isWritable(e, 'currentTarget')) e.currentTarget = dom
if (isWritable(e, 'target')) e.target = e.srcElement
if (isWritable(e, 'which')) e.which = e.charCode || e.keyCode
e.item = item
// prevent default behaviour (by default)
if (handler.call(tag, e) !== true && !/radio|check/.test(dom.type)) {
if (e.preventDefault) e.preventDefault()
e.returnValue = false
}
if (!e.preventUpdate) {
el = item ? getImmediateCustomParentTag(ptag) : tag
el.update()
}
}
}
/**
* Insert a DOM node replacing another one (used by if- attribute)
* @param { Object } root - parent node
* @param { Object } node - node replaced
* @param { Object } before - node added
*/
function insertTo(root, node, before) {
if (!root) return
root.insertBefore(before, node)
root.removeChild(node)
}
/**
* Update the expressions in a Tag instance
* @param { Array } expressions - expression that must be re evaluated
* @param { Tag } tag - tag instance
*/
function update(expressions, tag) {
each(expressions, function(expr, i) {
var dom = expr.dom,
attrName = expr.attr,
value = tmpl(expr.expr, tag),
parent = expr.parent || expr.dom.parentNode
if (expr.bool) {
value = !!value
} else if (value == null) {
value = ''
}
// #1638: regression of #1612, update the dom only if the value of the
// expression was changed
if (expr.value === value) {
return
}
expr.value = value
// textarea and text nodes has no attribute name
if (!attrName) {
// about #815 w/o replace: the browser converts the value to a string,
// the comparison by "==" does too, but not in the server
value += ''
// test for parent avoids error with invalid assignment to nodeValue
if (parent) {
// cache the parent node because somehow it will become null on IE
// on the next iteration
expr.parent = parent
if (parent.tagName === 'TEXTAREA') {
parent.value = value // #1113
if (!IE_VERSION) dom.nodeValue = value // #1625 IE throws here, nodeValue
} // will be available on 'updated'
else dom.nodeValue = value
}
return
}
// ~~#1612: look for changes in dom.value when updating the value~~
if (attrName === 'value') {
if (dom.value !== value) {
dom.value = value
setAttr(dom, attrName, value)
}
return
} else {
// remove original attribute
remAttr(dom, attrName)
}
// event handler
if (isFunction(value)) {
setEventHandler(attrName, value, dom, tag)
// if- conditional
} else if (attrName == 'if') {
var stub = expr.stub,
add = function() { insertTo(stub.parentNode, stub, dom) },
remove = function() { insertTo(dom.parentNode, dom, stub) }
// add to DOM
if (value) {
if (stub) {
add()
dom.inStub = false
// avoid to trigger the mount event if the tags is not visible yet
// maybe we can optimize this avoiding to mount the tag at all
if (!isInStub(dom)) {
walk(dom, function(el) {
if (el._tag && !el._tag.isMounted)
el._tag.isMounted = !!el._tag.trigger('mount')
})
}
}
// remove from DOM
} else {
stub = expr.stub = stub || document.createTextNode('')
// if the parentNode is defined we can easily replace the tag
if (dom.parentNode)
remove()
// otherwise we need to wait the updated event
else (tag.parent || tag).one('updated', remove)
dom.inStub = true
}
// show / hide
} else if (attrName === 'show') {
dom.style.display = value ? '' : 'none'
} else if (attrName === 'hide') {
dom.style.display = value ? 'none' : ''
} else if (expr.bool) {
dom[attrName] = value
if (value) setAttr(dom, attrName, attrName)
if (FIREFOX && attrName === 'selected' && dom.tagName === 'OPTION') {
dom.__riot1374 = value // #1374
}
} else if (value === 0 || value && typeof value !== T_OBJECT) {
// <img src="{ expr }">
if (startsWith(attrName, RIOT_PREFIX) && attrName != RIOT_TAG) {
attrName = attrName.slice(RIOT_PREFIX.length)
}
setAttr(dom, attrName, value)
}
})
}
/**
* Specialized function for looping an array-like collection with `each={}`
* @param { Array } els - collection of items
* @param {Function} fn - callback function
* @returns { Array } the array looped
*/
function each(els, fn) {
var len = els ? els.length : 0
for (var i = 0, el; i < len; i++) {
el = els[i]
// return false -> current item was removed by fn during the loop
if (el != null && fn(el, i) === false) i--
}
return els
}
/**
* Detect if the argument passed is a function
* @param { * } v - whatever you want to pass to this function
* @returns { Boolean } -
*/
function isFunction(v) {
return typeof v === T_FUNCTION || false // avoid IE problems
}
/**
* Get the outer html of any DOM node SVGs included
* @param { Object } el - DOM node to parse
* @returns { String } el.outerHTML
*/
function getOuterHTML(el) {
if (el.outerHTML) return el.outerHTML
// some browsers do not support outerHTML on the SVGs tags
else {
var container = mkEl('div')
container.appendChild(el.cloneNode(true))
return container.innerHTML
}
}
/**
* Set the inner html of any DOM node SVGs included
* @param { Object } container - DOM node where we will inject the new html
* @param { String } html - html to inject
*/
function setInnerHTML(container, html) {
if (typeof container.innerHTML != T_UNDEF) container.innerHTML = html
// some browsers do not support innerHTML on the SVGs tags
else {
var doc = new DOMParser().parseFromString(html, 'application/xml')
container.appendChild(
container.ownerDocument.importNode(doc.documentElement, true)
)
}
}
/**
* Checks wether a DOM node must be considered part of an svg document
* @param { String } name - tag name
* @returns { Boolean } -
*/
function isSVGTag(name) {
return ~SVG_TAGS_LIST.indexOf(name)
}
/**
* Detect if the argument passed is an object, exclude null.
* NOTE: Use isObject(x) && !isArray(x) to excludes arrays.
* @param { * } v - whatever you want to pass to this function
* @returns { Boolean } -
*/
function isObject(v) {
return v && typeof v === T_OBJECT // typeof null is 'object'
}
/**
* Remove any DOM attribute from a node
* @param { Object } dom - DOM node we want to update
* @param { String } name - name of the property we want to remove
*/
function remAttr(dom, name) {
dom.removeAttribute(name)
}
/**
* Convert a string containing dashes to camel case
* @param { String } string - input string
* @returns { String } my-string -> myString
*/
function toCamel(string) {
return string.replace(/-(\w)/g, function(_, c) {
return c.toUpperCase()
})
}
/**
* Get the value of any DOM attribute on a node
* @param { Object } dom - DOM node we want to parse
* @param { String } name - name of the attribute we want to get
* @returns { String | undefined } name of the node attribute whether it exists
*/
function getAttr(dom, name) {
return dom.getAttribute(name)
}
/**
* Set any DOM/SVG attribute
* @param { Object } dom - DOM node we want to update
* @param { String } name - name of the property we want to set
* @param { String } val - value of the property we want to set
*/
function setAttr(dom, name, val) {
var xlink = XLINK_REGEX.exec(name)
if (xlink && xlink[1])
dom.setAttributeNS(XLINK_NS, xlink[1], val)
else
dom.setAttribute(name, val)
}
/**
* Detect the tag implementation by a DOM node
* @param { Object } dom - DOM node we need to parse to get its tag implementation
* @returns { Object } it returns an object containing the implementation of a custom tag (template and boot function)
*/
function getTag(dom) {
return dom.tagName && __tagImpl[getAttr(dom, RIOT_TAG_IS) ||
getAttr(dom, RIOT_TAG) || dom.tagName.toLowerCase()]
}
/**
* Add a child tag to its parent into the `tags` object
* @param { Object } tag - child tag instance
* @param { String } tagName - key where the new tag will be stored
* @param { Object } parent - tag instance where the new child tag will be included
*/
function addChildTag(tag, tagName, parent) {
var cachedTag = parent.tags[tagName]
// if there are multiple children tags having the same name
if (cachedTag) {
// if the parent tags property is not yet an array
// create it adding the first cached tag
if (!isArray(cachedTag))
// don't add the same tag twice
if (cachedTag !== tag)
parent.tags[tagName] = [cachedTag]
// add the new nested tag to the array
if (!contains(parent.tags[tagName], tag))
parent.tags[tagName].push(tag)
} else {
parent.tags[tagName] = tag
}
}
/**
* Move the position of a custom tag in its parent tag
* @param { Object } tag - child tag instance
* @param { String } tagName - key where the tag was stored
* @param { Number } newPos - index where the new tag will be stored
*/
function moveChildTag(tag, tagName, newPos) {
var parent = tag.parent,
tags
// no parent no move
if (!parent) return
tags = parent.tags[tagName]
if (isArray(tags))
tags.splice(newPos, 0, tags.splice(tags.indexOf(tag), 1)[0])
else addChildTag(tag, tagName, parent)
}
/**
* Create a new child tag including it correctly into its parent
* @param { Object } child - child tag implementation
* @param { Object } opts - tag options containing the DOM node where the tag will be mounted
* @param { String } innerHTML - inner html of the child node
* @param { Object } parent - instance of the parent tag including the child custom tag
* @returns { Object } instance of the new child tag just created
*/
function initChildTag(child, opts, innerHTML, parent) {
var tag = new Tag(child, opts, innerHTML),
tagName = getTagName(opts.root),
ptag = getImmediateCustomParentTag(parent)
// fix for the parent attribute in the looped elements
tag.parent = ptag
// store the real parent tag
// in some cases this could be different from the custom parent tag
// for example in nested loops
tag._parent = parent
// add this tag to the custom parent tag
addChildTag(tag, tagName, ptag)
// and also to the real parent tag
if (ptag !== parent)
addChildTag(tag, tagName, parent)
// empty the child node once we got its template
// to avoid that its children get compiled multiple times
opts.root.innerHTML = ''
return tag
}
/**
* Loop backward all the parents tree to detect the first custom parent tag
* @param { Object } tag - a Tag instance
* @returns { Object } the instance of the first custom parent tag found
*/
function getImmediateCustomParentTag(tag) {
var ptag = tag
while (!getTag(ptag.root)) {
if (!ptag.parent) break
ptag = ptag.parent
}
return ptag
}
/**
* Helper function to set an immutable property
* @param { Object } el - object where the new property will be set
* @param { String } key - object key where the new property will be stored
* @param { * } value - value of the new property
* @param { Object } options - set the propery overriding the default options
* @returns { Object } - the initial object
*/
function defineProperty(el, key, value, options) {
Object.defineProperty(el, key, extend({
value: value,
enumerable: false,
writable: false,
configurable: true
}, options))
return el
}
/**
* Get the tag name of any DOM node
* @param { Object } dom - DOM node we want to parse
* @returns { String } name to identify this dom node in riot
*/
function getTagName(dom) {
var child = getTag(dom),
namedTag = getAttr(dom, 'name'),
tagName = namedTag && !tmpl.hasExpr(namedTag) ?
namedTag :
child ? child.name : dom.tagName.toLowerCase()
return tagName
}
/**
* Extend any object with other properties
* @param { Object } src - source object
* @returns { Object } the resulting extended object
*
* var obj = { foo: 'baz' }
* extend(obj, {bar: 'bar', foo: 'bar'})
* console.log(obj) => {bar: 'bar', foo: 'bar'}
*
*/
function extend(src) {
var obj, args = arguments
for (var i = 1; i < args.length; ++i) {
if (obj = args[i]) {
for (var key in obj) {
// check if this property of the source object could be overridden
if (isWritable(src, key))
src[key] = obj[key]
}
}
}
return src
}
/**
* Check whether an array contains an item
* @param { Array } arr - target array
* @param { * } item - item to test
* @returns { Boolean } Does 'arr' contain 'item'?
*/
function contains(arr, item) {
return ~arr.indexOf(item)
}
/**
* Check whether an object is a kind of array
* @param { * } a - anything
* @returns {Boolean} is 'a' an array?
*/
function isArray(a) { return Array.isArray(a) || a instanceof Array }
/**
* Detect whether a property of an object could be overridden
* @param { Object } obj - source object
* @param { String } key - object property
* @returns { Boolean } is this property writable?
*/
function isWritable(obj, key) {
var props = Object.getOwnPropertyDescriptor(obj, key)
return typeof obj[key] === T_UNDEF || props && props.writable
}
/**
* With this function we avoid that the internal Tag methods get overridden
* @param { Object } data - options we want to use to extend the tag instance
* @returns { Object } clean object without containing the riot internal reserved words
*/
function cleanUpData(data) {
if (!(data instanceof Tag) && !(data && typeof data.trigger == T_FUNCTION))
return data
var o = {}
for (var key in data) {
if (!RESERVED_WORDS_BLACKLIST.test(key)) o[key] = data[key]
}
return o
}
/**
* Walk down recursively all the children tags starting dom node
* @param { Object } dom - starting node where we will start the recursion
* @param { Function } fn - callback to transform the child node just found
*/
function walk(dom, fn) {
if (dom) {
// stop the recursion
if (fn(dom) === false) return
else {
dom = dom.firstChild
while (dom) {
walk(dom, fn)
dom = dom.nextSibling
}
}
}
}
/**
* Minimize risk: only zero or one _space_ between attr & value
* @param { String } html - html string we want to parse
* @param { Function } fn - callback function to apply on any attribute found
*/
function walkAttributes(html, fn) {
var m,
re = /([-\w]+) ?= ?(?:"([^"]*)|'([^']*)|({[^}]*}))/g
while (m = re.exec(html)) {
fn(m[1].toLowerCase(), m[2] || m[3] || m[4])
}
}
/**
* Check whether a DOM node is in stub mode, useful for the riot 'if' directive
* @param { Object } dom - DOM node we want to parse
* @returns { Boolean } -
*/
function isInStub(dom) {
while (dom) {
if (dom.inStub) return true
dom = dom.parentNode
}
return false
}
/**
* Create a generic DOM node
* @param { String } name - name of the DOM node we want to create
* @param { Boolean } isSvg - should we use a SVG as parent node?
* @returns { Object } DOM node just created
*/
function mkEl(name, isSvg) {
return isSvg ?
document.createElementNS('http://www.w3.org/2000/svg', 'svg') :
document.createElement(name)
}
/**
* Shorter and fast way to select multiple nodes in the DOM
* @param { String } selector - DOM selector
* @param { Object } ctx - DOM node where the targets of our search will is located
* @returns { Object } dom nodes found
*/
function $$(selector, ctx) {
return (ctx || document).querySelectorAll(selector)
}
/**
* Shorter and fast way to select a single node in the DOM
* @param { String } selector - unique dom selector
* @param { Object } ctx - DOM node where the target of our search will is located
* @returns { Object } dom node found
*/
function $(selector, ctx) {
return (ctx || document).querySelector(selector)
}
/**
* Simple object prototypal inheritance
* @param { Object } parent - parent object
* @returns { Object } child instance
*/
function inherit(parent) {
return Object.create(parent || null)
}
/**
* Get the name property needed to identify a DOM node in riot
* @param { Object } dom - DOM node we need to parse
* @returns { String | undefined } give us back a string to identify this dom node
*/
function getNamedKey(dom) {
return getAttr(dom, 'id') || getAttr(dom, 'name')
}
/**
* Set the named properties of a tag element
* @param { Object } dom - DOM node we need to parse
* @param { Object } parent - tag instance where the named dom element will be eventually added
* @param { Array } keys - list of all the tag instance properties
*/
function setNamed(dom, parent, keys) {
// get the key value we want to add to the tag instance
var key = getNamedKey(dom),
isArr,
// add the node detected to a tag instance using the named property
add = function(value) {
// avoid to override the tag properties already set
if (contains(keys, key)) return
// check whether this value is an array
isArr = isArray(value)
// if the key was never set
if (!value)
// set it once on the tag instance
parent[key] = dom
// if it was an array and not yet set
else if (!isArr || isArr && !contains(value, dom)) {
// add the dom node into the array
if (isArr)
value.push(dom)
else
parent[key] = [value, dom]
}
}
// skip the elements with no named properties
if (!key) return
// check whether this key has been already evaluated
if (tmpl.hasExpr(key))
// wait the first updated event only once
parent.one('mount', function() {
key = getNamedKey(dom)
add(parent[key])
})
else
add(parent[key])
}
/**
* Faster String startsWith alternative
* @param { String } src - source string
* @param { String } str - test string
* @returns { Boolean } -
*/
function startsWith(src, str) {
return src.slice(0, str.length) === str
}
/**
* requestAnimationFrame function
* Adapted from https://gist.github.com/paulirish/1579671, license MIT
*/
var rAF = (function (w) {
var raf = w.requestAnimationFrame ||
w.mozRequestAnimationFrame || w.webkitRequestAnimationFrame
if (!raf || /iP(ad|hone|od).*OS 6/.test(w.navigator.userAgent)) { // buggy iOS6
var lastTime = 0
raf = function (cb) {
var nowtime = Date.now(), timeout = Math.max(16 - (nowtime - lastTime), 0)
setTimeout(function () { cb(lastTime = nowtime + timeout) }, timeout)
}
}
return raf
})(window || {})
/**
* Mount a tag creating new Tag instance
* @param { Object } root - dom node where the tag will be mounted
* @param { String } tagName - name of the riot tag we want to mount
* @param { Object } opts - options to pass to the Tag instance
* @returns { Tag } a new Tag instance
*/
function mountTo(root, tagName, opts) {
var tag = __tagImpl[tagName],
// cache the inner HTML to fix #855
innerHTML = root._innerHTML = root._innerHTML || root.innerHTML
// clear the inner html
root.innerHTML = ''
if (tag && root) tag = new Tag(tag, { root: root, opts: opts }, innerHTML)
if (tag && tag.mount) {
tag.mount()
// add this tag to the virtualDom variable
if (!contains(__virtualDom, tag)) __virtualDom.push(tag)
}
return tag
}
/**
* Riot public api
*/
// share methods for other riot parts, e.g. compiler
riot.util = { brackets: brackets, tmpl: tmpl }
/**
* Create a mixin that could be globally shared across all the tags
*/
riot.mixin = (function() {
var mixins = {},
globals = mixins[GLOBAL_MIXIN] = {},
_id = 0
/**
* Create/Return a mixin by its name
* @param { String } name - mixin name (global mixin if object)
* @param { Object } mixin - mixin logic
* @param { Boolean } g - is global?
* @returns { Object } the mixin logic
*/
return function(name, mixin, g) {
// Unnamed global
if (isObject(name)) {
riot.mixin('__unnamed_'+_id++, name, true)
return
}
var store = g ? globals : mixins
// Getter
if (!mixin) {
if (typeof store[name] === T_UNDEF) {
throw new Error('Unregistered mixin: ' + name)
}
return store[name]
}
// Setter
if (isFunction(mixin)) {
extend(mixin.prototype, store[name] || {})
store[name] = mixin
}
else {
store[name] = extend(store[name] || {}, mixin)
}
}
})()
/**
* Create a new riot tag implementation
* @param { String } name - name/id of the new riot tag
* @param { String } html - tag template
* @param { String } css - custom tag css
* @param { String } attrs - root tag attributes
* @param { Function } fn - user function
* @returns { String } name/id of the tag just created
*/
riot.tag = function(name, html, css, attrs, fn) {
if (isFunction(attrs)) {
fn = attrs
if (/^[\w\-]+\s?=/.test(css)) {
attrs = css
css = ''
} else attrs = ''
}
if (css) {
if (isFunction(css)) fn = css
else styleManager.add(css)
}
name = name.toLowerCase()
__tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }
return name
}
/**
* Create a new riot tag implementation (for use by the compiler)
* @param { String } name - name/id of the new riot tag
* @param { String } html - tag template
* @param { String } css - custom tag css
* @param { String } attrs - root tag attributes
* @param { Function } fn - user function
* @returns { String } name/id of the tag just created
*/
riot.tag2 = function(name, html, css, attrs, fn) {
if (css) styleManager.add(css)
//if (bpair) riot.settings.brackets = bpair
__tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }
return name
}
/**
* Mount a tag using a specific tag implementation
* @param { String } selector - tag DOM selector
* @param { String } tagName - tag implementation name
* @param { Object } opts - tag logic
* @returns { Array } new tags instances
*/
riot.mount = function(selector, tagName, opts) {
var els,
allTags,
tags = []
// helper functions
function addRiotTags(arr) {
var list = ''
each(arr, function (e) {
if (!/[^-\w]/.test(e)) {
e = e.trim().toLowerCase()
list += ',[' + RIOT_TAG_IS + '="' + e + '"],[' + RIOT_TAG + '="' + e + '"]'
}
})
return list
}
function selectAllTags() {
var keys = Object.keys(__tagImpl)
return keys + addRiotTags(keys)
}
function pushTags(root) {
if (root.tagName) {
var riotTag = getAttr(root, RIOT_TAG_IS) || getAttr(root, RIOT_TAG)
// have tagName? force riot-tag to be the same
if (tagName && riotTag !== tagName) {
riotTag = tagName
setAttr(root, RIOT_TAG_IS, tagName)
setAttr(root, RIOT_TAG, tagName) // this will be removed in riot 3.0.0
}
var tag = mountTo(root, riotTag || root.tagName.toLowerCase(), opts)
if (tag) tags.push(tag)
} else if (root.length) {
each(root, pushTags) // assume nodeList
}
}
// ----- mount code -----
// inject styles into DOM
styleManager.inject()
if (isObject(tagName)) {
opts = tagName
tagName = 0
}
// crawl the DOM to find the tag
if (typeof selector === T_STRING) {
if (selector === '*')
// select all the tags registered
// and also the tags found with the riot-tag attribute set
selector = allTags = selectAllTags()
else
// or just the ones named like the selector
selector += addRiotTags(selector.split(/, */))
// make sure to pass always a selector
// to the querySelectorAll function
els = selector ? $$(selector) : []
}
else
// probably you have passed already a tag or a NodeList
els = selector
// select all the registered and mount them inside their root elements
if (tagName === '*') {
// get all custom tags
tagName = allTags || selectAllTags()
// if the root els it's just a single tag
if (els.tagName)
els = $$(tagName, els)
else {
// select all the children for all the different root elements
var nodeList = []
each(els, function (_el) {
nodeList.push($$(tagName, _el))
})
els = nodeList
}
// get rid of the tagName
tagName = 0
}
pushTags(els)
return tags
}
/**
* Update all the tags instances created
* @returns { Array } all the tags instances
*/
riot.update = function() {
return each(__virtualDom, function(tag) {
tag.update()
})
}
/**
* Export the Virtual DOM
*/
riot.vdom = __virtualDom
/**
* Export the Tag constructor
*/
riot.Tag = Tag
// support CommonJS, AMD & browser
/* istanbul ignore next */
if (typeof exports === T_OBJECT)
module.exports = riot
else if ("function" === T_FUNCTION && typeof __webpack_require__(2) !== T_UNDEF)
!(__WEBPACK_AMD_DEFINE_RESULT__ = function() { return riot }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))
else
window.riot = riot
})(typeof window != 'undefined' ? window : void 0);
/***/ }),
/* 2 */
/***/ (function(module, exports) {
/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {module.exports = __webpack_amd_options__;
/* WEBPACK VAR INJECTION */}.call(exports, {}))
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(4);
__webpack_require__(28);
riot.tag2('app', '<basic-layout if="{{isHome}}"></basic-layout> <home-layout if="{{!isHome}}"></home-layout>', '', '', function (opts) {
var _this = this;
this.isHome = !!window.location.hash.replace('#', '');
riot.route(function (collection, id, action) {
_this.update({ isHome: !!collection });
});
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(5);
__webpack_require__(9);
__webpack_require__(12);
__webpack_require__(16);
__webpack_require__(24);
__webpack_require__(27);
riot.tag2('basic-layout', '<material-navbar> <div class="row"> <div class="col col-lg-3 col-md-6 col-sm-11 col-xs-11"> <div class="logo"> <a href="#" title="$syui.terminal">{{parent.logoText}}</a> <a href="https://syui.gitlab.io/" riot> <div class="for-riot"></div> </a> </div> </div> <div class="col col-lg-9 col-md-6 col-sm-1 col-xs-1 gitcol"> </div> </div> </material-navbar> <div class="row content"> <div name="menu" class="col-lg-2 col-md-2 col-sm-12 col-xs-12 col left"> <riotmui-list name="riotmuiList" links="{{this.links}}"></riotmui-list> </div> <div class="col-lg-10 col-md-10 col-sm-12 col-xs-12 col right"> <div class="container"> <div class="row"> <div id="window"> <div id="toolbar"> <div class="top"> <div id="title"></div> <div id="title-left"> <a href="javascript:location.reload(true)"><i class="icon ion-plus-circled"></i></a> <i class="icon ion-minus-circled" id="mainTitleB"></i> <i class="icon ion-close-circled" id="mainTitleA"></i> </div> <div id="bubble"> <div class="shine"></div> <div class="glow"></div> </div> </div> </div> <div id="terminal"> </div> </div> </div> <div class="row"> </div> </div> </div> </div> <div class="overlay" onclick="{{close}}" name="overlay" if="{{opened}}"></div>', '', '', function (opts) {
var _this = this;
this.opened = false;
this.logoText = '$syui.terminal';
this.links = [];
this.route = window.location.hash.replace('#', '') || 'Home';
this.tags.riotmuiList.update({ selected: window.location.hash });
riot.route(function (collection, id, action) {
_this.update({ route: collection || 'Home' });
_this.tags.riotmuiList.update({ selected: '#' + collection });
});
this.tags.riotmuiList.on('onClick', function () {
_this.close();
});
this.mq = window.matchMedia('only screen and (min-width : 320px) and (max-width : 480px)');
this.mq.addListener(function () {
_this.checkOutMatches();
});
this.checkOutMatches = function () {
if (_this.mq.matches) {
_this.update({ logoText: '=' });
} else {
_this.update({ logoText: '=' });
}
};
this.checkOutMatches();
this.back = function () {
window.location.hash = "/#";
};
this.toggleMenu = function () {
!_this.opened ? _this.open() : _this.close();
};
this.open = function () {
_this.update({ opened: true });
_this.menu.style.left = '0px';
};
this.close = function () {
_this.update({ opened: false });
_this.menu.style.left = '-100%';
};
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(6);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(6, function() {
var newContent = __webpack_require__(6);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "home-layout {\n display: block;\n width: 100%;\n color: #070731;\n font-family: 'Open Sans';\n /** HEDAER **/\n /** CONTENT **/ }\n home-layout .row {\n margin: 0;\n padding: 0; }\n home-layout .row .col {\n margin: 0;\n padding: 0; }\n home-layout .icon-row {\n height: 67px; }\n home-layout material-navbar {\n height: 310px; }\n home-layout material-navbar.footer {\n height: 200px; }\n home-layout material-navbar.footer .nav-wrapper {\n display: flex;\n flex-direction: row;\n align-items: center;\n text-align: center; }\n home-layout material-navbar.footer .nav-wrapper material-button {\n left: 50%;\n margin-left: -70px; }\n home-layout material-navbar .row .col {\n display: flex;\n flex-direction: row;\n align-items: center; }\n home-layout material-navbar .row .col.logocol {\n flex-direction: column; }\n home-layout material-navbar .row .col .logo logo {\n display: block;\n width: 100%;\n height: 100%; }\n home-layout material-navbar .gitcol {\n flex-direction: column !important;\n align-items: flex-end !important; }\n home-layout material-navbar .gitcol .github {\n margin-right: 10px;\n margin-top: 12px; }\n home-layout material-navbar .logo {\n display: block;\n margin-left: 20px;\n font-size: 33px;\n font-weight: 100; }\n home-layout material-navbar .logo .menu {\n display: none; }\n home-layout material-navbar .logo a {\n display: inline-block;\n text-decoration: none; }\n home-layout material-navbar .logo .for-riot {\n display: inline-block;\n vertical-align: middle;\n margin-left: 5px;\n width: 92px;\n height: 37px;\n position: relative;\n bottom: 2px; }\n home-layout > .content .wrapper .center {\n max-width: 1100px;\n width: 100%;\n margin: 40px auto;\n text-align: center; }\n home-layout > .content .wrapper .center.p1 {\n margin: 40px auto 60px auto; }\n home-layout > .content .wrapper h1 {\n color: #61bdcc;\n font-size: 22px;\n font-weight: 100;\n margin: 0; }\n home-layout > .content .wrapper h3 {\n color: #61bdcc;\n font-size: 20px;\n font-weight: 100; }\n home-layout > .content .wrapper a {\n color: #61bdcc;\n font-weight: 100; }\n home-layout > .content .wrapper riotmui-code {\n margin: 10px 0; }\n home-layout > .content .wrapper ul {\n list-style: none; }\n home-layout > .content .wrapper .checkout {\n margin: 80px 0;\n border: 1px solid #61bdcc; }\n home-layout > .content .wrapper .line {\n display: flex;\n align-items: center;\n justify-content: center;\n background: #25313b; }\n\n@media (min-width: 768px) and (max-width: 1024px) {\n home-layout material-navbar {\n height: 300px; } }\n\n@media (min-width: 480px) and (max-width: 768px) {\n home-layout material-navbar {\n height: 200px; } }\n\n@media (min-width: 320px) and (max-width: 480px) {\n home-layout material-navbar {\n height: 200px; } }\n", ""]);
// exports
/***/ }),
/* 7 */
/***/ (function(module, exports) {
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
// css base code, injected by the css-loader
module.exports = function() {
var list = [];
// return the list of modules as css string
list.toString = function toString() {
var result = [];
for(var i = 0; i < this.length; i++) {
var item = this[i];
if(item[2]) {
result.push("@media " + item[2] + "{" + item[1] + "}");
} else {
result.push(item[1]);
}
}
return result.join("");
};
// import a list of modules into the list
list.i = function(modules, mediaQuery) {
if(typeof modules === "string")
modules = [[null, modules, ""]];
var alreadyImportedModules = {};
for(var i = 0; i < this.length; i++) {
var id = this[i][0];
if(typeof id === "number")
alreadyImportedModules[id] = true;
}
for(i = 0; i < modules.length; i++) {
var item = modules[i];
// skip already imported module
// this implementation is not 100% perfect for weird media query combinations
// when a module is imported multiple times with different media queries.
// I hope this will never occur (Hey this way we have smaller bundles)
if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
if(mediaQuery && !item[2]) {
item[2] = mediaQuery;
} else if(mediaQuery) {
item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
}
list.push(item);
}
}
};
return list;
};
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
var stylesInDom = {},
memoize = function(fn) {
var memo;
return function () {
if (typeof memo === "undefined") memo = fn.apply(this, arguments);
return memo;
};
},
isOldIE = memoize(function() {
return /msie [6-9]\b/.test(self.navigator.userAgent.toLowerCase());
}),
getHeadElement = memoize(function () {
return document.head || document.getElementsByTagName("head")[0];
}),
singletonElement = null,
singletonCounter = 0,
styleElementsInsertedAtTop = [];
module.exports = function(list, options) {
if(false) {
if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
}
options = options || {};
// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
// tags it will allow on a page
if (typeof options.singleton === "undefined") options.singleton = isOldIE();
// By default, add <style> tags to the bottom of <head>.
if (typeof options.insertAt === "undefined") options.insertAt = "bottom";
var styles = listToStyles(list);
addStylesToDom(styles, options);
return function update(newList) {
var mayRemove = [];
for(var i = 0; i < styles.length; i++) {
var item = styles[i];
var domStyle = stylesInDom[item.id];
domStyle.refs--;
mayRemove.push(domStyle);
}
if(newList) {
var newStyles = listToStyles(newList);
addStylesToDom(newStyles, options);
}
for(var i = 0; i < mayRemove.length; i++) {
var domStyle = mayRemove[i];
if(domStyle.refs === 0) {
for(var j = 0; j < domStyle.parts.length; j++)
domStyle.parts[j]();
delete stylesInDom[domStyle.id];
}
}
};
}
function addStylesToDom(styles, options) {
for(var i = 0; i < styles.length; i++) {
var item = styles[i];
var domStyle = stylesInDom[item.id];
if(domStyle) {
domStyle.refs++;
for(var j = 0; j < domStyle.parts.length; j++) {
domStyle.parts[j](item.parts[j]);
}
for(; j < item.parts.length; j++) {
domStyle.parts.push(addStyle(item.parts[j], options));
}
} else {
var parts = [];
for(var j = 0; j < item.parts.length; j++) {
parts.push(addStyle(item.parts[j], options));
}
stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
}
}
}
function listToStyles(list) {
var styles = [];
var newStyles = {};
for(var i = 0; i < list.length; i++) {
var item = list[i];
var id = item[0];
var css = item[1];
var media = item[2];
var sourceMap = item[3];
var part = {css: css, media: media, sourceMap: sourceMap};
if(!newStyles[id])
styles.push(newStyles[id] = {id: id, parts: [part]});
else
newStyles[id].parts.push(part);
}
return styles;
}
function insertStyleElement(options, styleElement) {
var head = getHeadElement();
var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
if (options.insertAt === "top") {
if(!lastStyleElementInsertedAtTop) {
head.insertBefore(styleElement, head.firstChild);
} else if(lastStyleElementInsertedAtTop.nextSibling) {
head.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
} else {
head.appendChild(styleElement);
}
styleElementsInsertedAtTop.push(styleElement);
} else if (options.insertAt === "bottom") {
head.appendChild(styleElement);
} else {
throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
}
}
function removeStyleElement(styleElement) {
styleElement.parentNode.removeChild(styleElement);
var idx = styleElementsInsertedAtTop.indexOf(styleElement);
if(idx >= 0) {
styleElementsInsertedAtTop.splice(idx, 1);
}
}
function createStyleElement(options) {
var styleElement = document.createElement("style");
styleElement.type = "text/css";
insertStyleElement(options, styleElement);
return styleElement;
}
function createLinkElement(options) {
var linkElement = document.createElement("link");
linkElement.rel = "stylesheet";
insertStyleElement(options, linkElement);
return linkElement;
}
function addStyle(obj, options) {
var styleElement, update, remove;
if (options.singleton) {
var styleIndex = singletonCounter++;
styleElement = singletonElement || (singletonElement = createStyleElement(options));
update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
} else if(obj.sourceMap &&
typeof URL === "function" &&
typeof URL.createObjectURL === "function" &&
typeof URL.revokeObjectURL === "function" &&
typeof Blob === "function" &&
typeof btoa === "function") {
styleElement = createLinkElement(options);
update = updateLink.bind(null, styleElement);
remove = function() {
removeStyleElement(styleElement);
if(styleElement.href)
URL.revokeObjectURL(styleElement.href);
};
} else {
styleElement = createStyleElement(options);
update = applyToTag.bind(null, styleElement);
remove = function() {
removeStyleElement(styleElement);
};
}
update(obj);
return function updateStyle(newObj) {
if(newObj) {
if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
return;
update(obj = newObj);
} else {
remove();
}
};
}
var replaceText = (function () {
var textStore = [];
return function (index, replacement) {
textStore[index] = replacement;
return textStore.filter(Boolean).join('\n');
};
})();
function applyToSingletonTag(styleElement, index, remove, obj) {
var css = remove ? "" : obj.css;
if (styleElement.styleSheet) {
styleElement.styleSheet.cssText = replaceText(index, css);
} else {
var cssNode = document.createTextNode(css);
var childNodes = styleElement.childNodes;
if (childNodes[index]) styleElement.removeChild(childNodes[index]);
if (childNodes.length) {
styleElement.insertBefore(cssNode, childNodes[index]);
} else {
styleElement.appendChild(cssNode);
}
}
}
function applyToTag(styleElement, obj) {
var css = obj.css;
var media = obj.media;
if(media) {
styleElement.setAttribute("media", media)
}
if(styleElement.styleSheet) {
styleElement.styleSheet.cssText = css;
} else {
while(styleElement.firstChild) {
styleElement.removeChild(styleElement.firstChild);
}
styleElement.appendChild(document.createTextNode(css));
}
}
function updateLink(linkElement, obj) {
var css = obj.css;
var sourceMap = obj.sourceMap;
if(sourceMap) {
// http://stackoverflow.com/a/26603875
css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
}
var blob = new Blob([css], { type: "text/css" });
var oldSrc = linkElement.href;
linkElement.href = URL.createObjectURL(blob);
if(oldSrc)
URL.revokeObjectURL(oldSrc);
}
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(10);
riot.tag2('material-navbar', '<div class="nav-wrapper"> <yield></yield> </div>', '', 'role="toolbar"', function (opts) {});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(11);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(11, function() {
var newContent = __webpack_require__(11);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "material-navbar {\n display: block;\n color: #fff;\n -webkit-box-shadow: 0 8px 17px 0 rgba(0, 0, 0, 0.12), 0 6px 20px 0 rgba(0, 0, 0, 0.14);\n -ms-box-shadow: 0 8px 17px 0 rgba(0, 0, 0, 0.12), 0 6px 20px 0 rgba(0, 0, 0, 0.14);\n -moz-box-shadow: 0 8px 17px 0 rgba(0, 0, 0, 0.12), 0 6px 20px 0 rgba(0, 0, 0, 0.14);\n -o-box-shadow: 0 8px 17px 0 rgba(0, 0, 0, 0.12), 0 6px 20px 0 rgba(0, 0, 0, 0.14);\n box-shadow: 0 8px 17px 0 rgba(0, 0, 0, 0.12), 0 6px 20px 0 rgba(0, 0, 0, 0.14);\n background-color: #25313b;\n width: 100%;\n height: 70px;\n line-height: 70px; }\n material-navbar:not(material-input) {\n line-height: 0px; }\n material-navbar a {\n color: #fff; }\n material-navbar .nav-wrapper {\n position: relative;\n height: 100%; }\n material-navbar .nav-wrapper .logo {\n line-height: 66px; }\n material-navbar[fixed] {\n position: relative;\n height: 70px;\n z-index: 998; }\n", ""]);
// exports
/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(13);
__webpack_require__(15);
riot.tag2('material-pane', '<material-navbar riot-style="height:{{opts[\'material-navbar-height\'] || \'60px\'}};line-height: {{opts[\'material-navbar-height\'] || \'60px\'}};background-color:{{opts[\'material-navbar-color\'] || \'#ccc\'}}"> <content select=".material-pane-left-bar"></content> <content select=".material-pane-title"></content> <content select=".material-pane-right-bar"></content> </material-navbar> <div class="content"> <content select=".material-pane-content"></content> <yield></yield> </div>', '', '', function (opts) {
this.mixin('content');
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(14);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(14, function() {
var newContent = __webpack_require__(14);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "material-pane {\n display: block; }\n material-pane material-navbar .nav-wrapper {\n display: flex;\n justify-content: space-between;\n flex-grow: 1;\n /** USE MaTRIAL-BUTTON INTO PANE**/ }\n material-pane material-navbar .nav-wrapper .material-pane-title {\n font-size: 26px;\n text-transform: uppercase;\n text-align: center; }\n material-pane material-navbar .nav-wrapper material-button {\n background: transparent; }\n material-pane .content .material-pane-content {\n padding: 10px;\n background: #f2f2f2; }\n", ""]);
// exports
/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
var Content = {
init: function init() {
var _this = this;
this.on('mount', function () {
[].forEach.call(_this.root.querySelectorAll('content'), function (node) {
var selector = node.getAttribute('select');
[].forEach.call(_this.root.querySelectorAll(selector), function (content) {
node.parentNode.insertBefore(content, node.nextSibling);
});
node.parentNode.removeChild(node);
});
});
}
};
riot.mixin('content', Content);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(17);
__webpack_require__(19);
__webpack_require__(20);
riot.tag2('material-button', '<material-waves onclick="{{click}}" onmousedown="{{launch}}" center="{{opts[\'waves-center\']}}" rounded="{{opts[\'rounded\']}}" opacity="{{opts[\'waves-opacity\']}}" color="{{opts[\'waves-color\']}}" duration="{{opts[\'waves-duration\']}}"></material-waves> <div class="content"><yield></yield></div>', '', '', function (opts) {
var _this = this;
this.dynamicAttributes = ['disabled'];
this.disabled = opts.disabled || false;
this.launch = function (e) {
if (!_this.disabled) _this.tags['material-waves'].trigger('launch', e);
};
this.click = function () {
if (opts.link) window.location.href = opts.link;
_this.trigger('click');
};
this.mixin('dynamicAttributes');
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(18);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(18, function() {
var newContent = __webpack_require__(18);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "material-button {\n margin: 20px;\n border: none;\n border-radius: 2px;\n display: inline-block;\n position: relative;\n height: 40px;\n line-height: 36px;\n background: #61bdcc;\n color: #fff;\n padding: 20px;\n cursor: pointer;\n text-transform: uppercase;\n vertical-align: middle;\n outline: 0;\n -webkit-tap-highlight-color: transparent;\n /** CONTENT **/\n /** Rounded **/\n /** Shady **/\n /**Disabled **/ }\n material-button:hover material-waves {\n background: rgba(255, 255, 255, 0.2);\n -webkit-transition: background .2s ease-in;\n -ms-transition: background .2s ease-in;\n -moz-transition: background .2s ease-in;\n -o-transition: background .2s ease-in;\n transition: background .2s ease-in; }\n material-button material-waves {\n background: rgba(255, 255, 255, 0);\n -webkit-transition: background .2s ease-in;\n -ms-transition: background .2s ease-in;\n -moz-transition: background .2s ease-in;\n -o-transition: background .2s ease-in;\n transition: background .2s ease-in; }\n material-button .content {\n width: 101%;\n height: 100%;\n display: block;\n text-align: center; }\n material-button .content .text, material-button .content i.material-icons, material-button .content i.icon, material-button .content a {\n display: inline-block;\n vertical-align: middle;\n font-size: 18px;\n color: #fff;\n line-height: 40px; }\n material-button .content .text.material-icons, material-button .content i.material-icons.material-icons, material-button .content i.icon.material-icons, material-button .content a.material-icons {\n font-size: 20px; }\n material-button .content .text svg, material-button .content i.material-icons svg, material-button .content i.icon svg, material-button .content a svg {\n fill: #fff;\n stroke: #fff; }\n material-button[rounded=\"true\"] {\n border-radius: 50%;\n width: 40px;\n padding: 0; }\n material-button[rounded=\"true\"] .content {\n width: 100%;\n height: 100%;\n display: flex;\n align-items: center;\n text-align: center; }\n material-button[rounded=\"true\"] .content i.material-icons, material-button[rounded=\"true\"] .content i.icon {\n display: inline-block;\n text-align: center;\n width: 100%;\n height: 100%;\n -webkit-user-select: none;\n -ms-user-select: none;\n -moz-user-select: none;\n -o-user-select: none;\n user-select: none; }\n material-button[shady=\"true\"] {\n -webkit-box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);\n -ms-box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);\n -moz-box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);\n -o-box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);\n box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);\n transition: box-shadow .2s; }\n material-button[shady=\"true\"]:hover {\n -webkit-box-shadow: 0 2px 7px 0 rgba(0, 0, 0, 0.14), 0 2px 12px 0 rgba(0, 0, 0, 0.12);\n -ms-box-shadow: 0 2px 7px 0 rgba(0, 0, 0, 0.14), 0 2px 12px 0 rgba(0, 0, 0, 0.12);\n -moz-box-shadow: 0 2px 7px 0 rgba(0, 0, 0, 0.14), 0 2px 12px 0 rgba(0, 0, 0, 0.12);\n -o-box-shadow: 0 2px 7px 0 rgba(0, 0, 0, 0.14), 0 2px 12px 0 rgba(0, 0, 0, 0.12);\n box-shadow: 0 2px 7px 0 rgba(0, 0, 0, 0.14), 0 2px 12px 0 rgba(0, 0, 0, 0.12);\n transition: box-shadow .2s; }\n material-button[disabled=\"true\"] {\n background: #ccc;\n color: #999999;\n cursor: default; }\n material-button[disabled=\"true\"] #content .text, material-button[disabled=\"true\"] #content i.material-icons, material-button[disabled=\"true\"] #content i.icon, material-button[disabled=\"true\"] #content a {\n color: #999999; }\n material-button[disabled=\"true\"] #content .text svg, material-button[disabled=\"true\"] #content i.material-icons svg, material
// exports
/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {/**
* The mixin ables to update root tag attributes
* if in this.dynamicAttributes array contains
* name of attribute, which equals variable into tag instance
* Example:
* <my-tag disabled="true"></my-tag>
* <my-tag>
* ....
* <script>
* this.disabled = true;
* this.dynamicAttributes = ['disabled'];
* setTimeout(function(){
* this.update({disabled:false});
* }.bind(this),1000);
* </script>
* </my-tag>
* In this example disabled attribute of my-tag
* will be changed after 1s and we will see following HTML
* <my-tag disabled="false"></my-tag>
*/
'use strict';
var DynamicAttributesMixin = {
init: function init() {
var _this = this;
this.on('update', function (updated) {
if (updated && _this.dynamicAttributes) {
_this.dynamicAttributes.forEach(function (key) {
if (updated[key] != undefined) {
_this.root.setAttribute(key, updated[key]);
}
});
}
});
}
};
riot.mixin('dynamicAttributes', DynamicAttributesMixin);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(21);
__webpack_require__(23);
riot.tag2('material-waves', '<div id="waves" name="waves"></div>', '', '', function (opts) {
var _this3 = this;
var _createClass = (function () {
function defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ('value' in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
}
}return function (Constructor, protoProps, staticProps) {
if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
};
})();
var _get = function get(_x, _x2, _x3) {
var _again = true;_function: while (_again) {
var object = _x,
property = _x2,
receiver = _x3;_again = false;if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
var parent = Object.getPrototypeOf(object);if (parent === null) {
return undefined;
} else {
_x = parent;_x2 = property;_x3 = receiver;_again = true;desc = parent = undefined;continue _function;
}
} else if ('value' in desc) {
return desc.value;
} else {
var getter = desc.get;if (getter === undefined) {
return undefined;
}return getter.call(receiver);
}
}
};
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError('Cannot call a class as a function');
}
}
function _inherits(subClass, superClass) {
if (typeof superClass !== 'function' && superClass !== null) {
throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass);
}subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
}
var Bound = riot.mixin('Bound');
var Wave = (function (_Bound) {
_inherits(Wave, _Bound);
function Wave(container, opts, e) {
_classCallCheck(this, Wave);
_get(Object.getPrototypeOf(Wave.prototype), 'constructor', this).call(this);
if (!container) console.error('You should to set container to the wave!');
this.container = container;
this.maxOpacity = opts.opacity || 0.6;
this.duration = opts.duration || 750;
this.color = opts.color || '#fff';
this.center = opts.center || false;
this.event = e;
this.containerBound = this.receiveBound();
this.maxScale = this.containerBound.size / 100 * 10;
this.created = Date.now();
this.start = {};
this.createNode();
this.waveIn();
}
_createClass(Wave, [{
key: 'createNode',
value: function createNode() {
this.wave = document.createElement('div');
this.wave.classList.add('wave');
this.container.appendChild(this.wave);
}
}, {
key: 'waveIn',
value: function waveIn() {
var _this = this;
if (this.center && !this.event) console.error('Setup at least mouse event... Or just set center attribute');
this.start.x = this.center ? this.containerBound.height / 2 : this.event.pageY - this.containerBound.offsetTop;
this.start.y = this.center ? this.containerBound.width / 2 : this.event.pageX - this.containerBound.offsetLeft;
var isIE = window.navigator.userAgent.indexOf('Trident') !== -1;
setTimeout(function () {
return _this.setStyles(_this.maxOpacity);
}, isIE ? 50 : 0);
}
}, {
key: 'waveOut',
value: function waveOut() {
var _this2 = this;
var delta = Date.now() - this.created;
var deltaX = Math.round(this.duration / 2) - delta;
var delay = deltaX > 0 ? deltaX : 0;
setTimeout(function () {
_this2.setStyles(0);
setTimeout(function () {
if (_this2.wave.parentNode === _this2.container) {
_this2.container.removeChild(_this2.wave);
}
}, _this2.duration);
}, delay);
}
}, {
key: 'setStyles',
value: function setStyles(opacity) {
this.wave.setAttribute('style', this.convertStyle({
'top': this.start.x + 'px',
'left': this.start.y + 'px',
'transform': 'scale(' + this.maxScale + ')',
'transition-duration': this.duration + 'ms',
'transition-timing-function': 'cubic-bezier(0.250, 0.460, 0.450, 0.940)',
'background': this.color,
'opacity': opacity
}));
}
}, {
key: 'convertStyle',
value: function convertStyle(o) {
var style = '';
Object.keys(o).forEach(function (key) {
if (o.hasOwnProperty(key)) {
style += key + ':' + o[key] + ';';
}
});
return style;
}
}]);
return Wave;
})(Bound);
this._waves = [];
this._events = [];
this.on('launch', function (e) {
_this3._waves.push(new Wave(_this3.waves, opts, e));
if (!_this3._events.length) {
_this3._events.push(e.target.addEventListener('mouseup', function () {
return _this3.trigger('hold');
}));
_this3._events.push(e.target.addEventListener('mouseleave', function () {
return _this3.trigger('hold');
}));
}
});
this.on('hold', function () {
if (_this3._waves[_this3._waves.length - 1]) _this3._waves[_this3._waves.length - 1].waveOut();
if (_this3._waves[_this3._waves.length - 1]) _this3._waves.slice(_this3._waves.length - 1, 1);
});
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(22);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(22, function() {
var newContent = __webpack_require__(22);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "material-waves {\n display: block;\n width: 100%;\n height: 100%;\n position: absolute;\n left: 0;\n top: 0;\n overflow: hidden; }\n material-waves #waves {\n display: block;\n width: 100%;\n height: 100%;\n position: relative;\n overflow: hidden;\n -webkit-user-select: none;\n -ms-user-select: none;\n -moz-user-select: none;\n -o-user-select: none;\n user-select: none;\n vertical-align: middle;\n -webkit-transform: rotate(0deg);\n z-index: 1; }\n material-waves #waves .wave {\n position: absolute;\n -webkit-border-radius: 50%;\n -ms-border-radius: 50%;\n -moz-border-radius: 50%;\n -o-border-radius: 50%;\n border-radius: 50%;\n width: 20px;\n height: 20px;\n margin-top: -10px;\n margin-left: -10px;\n z-index: 0;\n opacity: 0;\n -webkit-transform: scale(0);\n -ms-transform: scale(0);\n -moz-transform: scale(0);\n -o-transform: scale(0);\n transform: scale(0);\n -webkit-transition-property: transform,opacity;\n -ms-transition-property: transform,opacity;\n -moz-transition-property: transform,opacity;\n -o-transition-property: transform,opacity;\n transition-property: transform,opacity;\n pointer-events: none; }\n material-waves[rounded=\"true\"] {\n border-radius: 50%; }\n material-waves[rounded=\"true\"] #waves {\n border-radius: 50%; }\n", ""]);
// exports
/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {/**
* Bound class contain methods for
* receiving bounds of DOM element.
*/
'use strict';
var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
var Bound = (function () {
function Bound() {
_classCallCheck(this, Bound);
}
_createClass(Bound, [{
key: 'receiveBound',
/**
* Get Bounds
* @returns {*}
*/
value: function receiveBound() {
if (!this.container) console.error('Yor class must contain a container. It is DOM Element. Define please this.container property.');
var document,
window,
box,
doc = this.container && this.container.ownerDocument;
// Get document
document = doc.documentElement;
// Get container
if (typeof this.container.getBoundingClientRect !== typeof undefined) {
box = this.container.getBoundingClientRect();
}
window = this.getWindow(doc);
// Return BoundingRect with additional properties.
return this.mix(box, {
size: Math.max(box.width, box.height),
offsetTop: box.top + window.pageYOffset - document.clientTop,
offsetLeft: box.left + window.pageXOffset - document.clientLeft
});
}
/**
* Window or not?
* @param o - supposing object
* @returns {boolean}
*/
}, {
key: 'isWindow',
value: function isWindow(o) {
return o !== null && o === o.window;
}
/**
* Get window method
* @param e - supposing object
* @returns {*}
*/
}, {
key: 'getWindow',
value: function getWindow(o) {
return this.isWindow(o) ? o : o.nodeType === 9 && o.defaultView;
}
/**
* Simple mixin. Unfortunately, babel don't support Object.assign \ or mixin
* @param so
* @param to
* @returns {*}
*/
}, {
key: 'mix',
value: function mix(so, to) {
for (var key in so) {
// only copy if not already present
if (!(key in to)) {
to[key] = so[key];
}
}
return to;
}
}]);
return Bound;
})();
riot.mixin('Bound', Bound);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(25);
riot.tag2('riotmui-list', '<ul> <li each="{{item,key in items}}" class="{{selected:parent.selected==item.link}}"> <a if="{{item.link}}" onclick="{{onClick}}" href="{{item.link}}" onclick="{{parent.select}}" title="{{item.title}}">{{item.title}}</a> </li> </ul>', '', 'role="toolbar"', function (opts) {
var _this = this;
this.items = opts.links || [];
this.onClick = function (e) {
_this.trigger('onClick');
window.location.href = e.target.getAttribute('href');
};
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(26);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(26, function() {
var newContent = __webpack_require__(26);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "riotmui-list ul {\n list-style: none;\n margin: 0;\n padding: 0; }\n riotmui-list ul li {\n cursor: pointer;\n transition: background .2s; }\n riotmui-list ul li:hover {\n background: #fff;\n transition: all .2s; }\n riotmui-list ul li a {\n text-decoration: none;\n color: #070726;\n display: block;\n height: 100%;\n padding: 15px 0px 15px 20px;\n font-size: 20px; }\n riotmui-list ul li.selected {\n border-left: 4px solid #579ead; }\n riotmui-list ul li.selected a {\n color: #579ead; }\n", ""]);
// exports
/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {
!function(t,e){if(true)module.exports=e(__webpack_require__(1));else if("function"==typeof define&&define.amd)define(["riot"],e);else{var r=e("object"==typeof exports?require("riot"):t.riot);for(var n in r)("object"==typeof exports?exports:t)[n]=r[n]}}(this,function(t){return function(t){function e(n){if(r[n])return r[n].exports;var o=r[n]={exports:{},id:n,loaded:!1};return t[n].call(o.exports,o,o.exports,e),o.loaded=!0,o.exports}var r={};return e.m=t,e.c=r,e.p="",e(0)}([function(t,e,r){function n(t){return t&&"undefined"!=typeof Symbol&&t.constructor===Symbol?"symbol":typeof t}var o,i,u;!function(n,s){i=[t,r(1),r(2)],o=s,u="function"==typeof o?o.apply(e,i):o,!(void 0!==u&&(t.exports=u))}(this,function(t,e,r){function o(t,e){if(!t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!==("undefined"==typeof e?"undefined":n(e))&&"function"!=typeof e?t:e}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+("undefined"==typeof e?"undefined":n(e)));t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}var s=function(){function t(t,e){var r=[],n=!0,o=!1,i=void 0;try{for(var u,s=t[Symbol.iterator]();!(n=(u=s.next()).done)&&(r.push(u.value),!e||r.length!==e);n=!0);}catch(a){o=!0,i=a}finally{try{!n&&s["return"]&&s["return"]()}finally{if(o)throw i}}return r}return function(e,r){if(Array.isArray(e))return e;if(Symbol.iterator in Object(e))return t(e,r);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),a=function x(t,e,r){null===t&&(t=Function.prototype);var n=Object.getOwnPropertyDescriptor(t,e);if(void 0===n){var o=Object.getPrototypeOf(t);return null===o?void 0:x(o,e,r)}if("value"in n)return n.value;var i=n.get;return void 0===i?void 0:i.call(r)},c=function(){function t(t,e){for(var r=0;r<e.length;r++){var n=e[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(t,n.key,n)}}return function(e,r,n){return r&&t(e.prototype,r),n&&t(e,n),e}}(),h=console&&console.error||function(){},f=function(){function t(){u(this,t),e.router=this,e.observable(this),this.interceptors=[this.processRoute.bind(this)],this.handler=new v,this.current=new p("").response,this.process=this.process.bind(this)}return c(t,[{key:"route",value:function(t){this.handler=t}},{key:"routes",value:function(t){this.route((new v).routes(t))}},{key:"use",value:function(t){this.interceptors.push(t)}},{key:"process",value:function(){var t=Array.prototype.slice.call(arguments),e=t.join("/");"/"!==e[0]&&(e="/"+e);var r=new p(e);return this.rootContext||(this.rootContext=r),this.processRequest(r),r}},{key:"processRequest",value:function(t){return this.processInterceptors(t),this.processResponse(t)}},{key:"processResponse",value:function(t){if(this.isRedirect(t))return this.processRedirect(t);var e=(t.request,t.response);return e.redirectTo?void 0:(this.current=e,this.rootContext=null,this.trigger("route:updated",e),t)}},{key:"isRedirect",value:function(t){return!!t.response.redirectTo}},{key:"processRedirect",value:function(t){var e=t.response.redirectTo;this.rootContext.addRedirect(e),this.navigateTo(e)}},{key:"navigateTo",value:function(t){e.route(t)}},{key:"processInterceptors",value:function(t,e,r){var n=(e||[]).concat(this.interceptors).concat(r||[]),o=function i(){if(!t.stop){var e=n.shift(),r=t.request,o=t.response;if(e)return e(r,o,i,t)}return t};return o()}},{key:"processRoute",value:function(t,e,r,n){return this.handler.process(t,e,n),r()}},{key:"start",value:function(){e.route(this.process),e.route.start(),this.exec()}},{key:"exec",value:function(){e.route.exec(this.process)}}]),t}(),p=function(){function t(e){u(this,t),this.request="string"==typeof e?new k(e):e,this.response=new O(this.request),this.redirectStack=[]}return c(t,[{key:"addRedirect",va
//# sourceMappingURL=router.min.js.map
/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(29);
__webpack_require__(9);
__webpack_require__(12);
__webpack_require__(16);
__webpack_require__(24);
__webpack_require__(31);
__webpack_require__(32);
__webpack_require__(27);
riot.tag2('home-layout', '<div class="container"> <div class="row"> <div id="window"> <div id="toolbar"> <div class="top"> <div id="title"></div> <div id="title-left"> <a href="javascript:location.reload(true)"><i class="icon ion-plus-circled"></i></a> <i class="icon ion-minus-circled" id="mainTitleB"></i> <i class="icon ion-close-circled" id="mainTitleA"></i> </div> <div id="bubble"> <div class="shine"></div> <div class="glow"></div> </div> </div> </div> <div id="terminal"> </div> </div> </div> <div class="row"> </div> </div>', '', '', function (opts) {});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(30);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(30, function() {
var newContent = __webpack_require__(30);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
fix
2024-03-23 11:52:28 +00:00
exports.push([module.id, "home-layout {\n display: block;\n width: 100%;\n color: #070731;\n font-family: 'Open Sans';\n /** HEDAER **/\n /** CONTENT **/ }\n home-layout .row {\n margin: 0;\n padding: 0; }\n home-layout .row .col {\n margin: 0;\n padding: 0; }\n home-layout .icon-row {\n height: 67px; }\n home-layout material-navbar {\n height: 310px; }\n home-layout material-navbar.footer {\n height: 200px; }\n home-layout material-navbar.footer .nav-wrapper {\n display: flex;\n flex-direction: row;\n align-items: center;\n text-align: center; }\n home-layout material-navbar.footer .nav-wrapper material-button {\n left: 50%;\n margin-left: -70px; }\n home-layout material-navbar .row .col {\n display: flex;\n flex-direction: row;\n align-items: center; }\n home-layout material-navbar .row .col.logocol {\n flex-direction: column; }\n home-layout material-navbar .row .col .logo logo {\n display: block;\n width: 100%;\n height: 100%; }\n home-layout material-navbar .gitcol {\n flex-direction: column !important;\n align-items: flex-end !important; }\n home-layout material-navbar .gitcol .github {\n margin-right: 10px;\n margin-top: 12px; }\n home-layout material-navbar .logo {\n display: block;\n margin-left: 20px;\n font-size: 33px;\n font-weight: 100; }\n home-layout material-navbar .logo .menu {\n display: none; }\n home-layout material-navbar .logo a {\n display: inline-block;\n text-decoration: none; }\n home-layout material-navbar .logo .for-riot {\n display: inline-block;\n vertical-align: middle;\n margin-left: 5px;\n width: 92px;\n height: 37px;\n position: relative;\n bottom: 2px; }\n home-layout > .content .wrapper .center {\n max-width: 1100px;\n width: 100%;\n margin: 40px auto;\n text-align: center; }\n home-layout > .content .wrapper .center.p1 {\n margin: 40px auto 60px auto; }\n home-layout > .content .wrapper h1 {\n color: #61bdcc;\n font-size: 22px;\n font-weight: 100;\n margin: 0; }\n home-layout > .content .wrapper h3 {\n color: #61bdcc;\n font-size: 20px;\n font-weight: 100; }\n home-layout > .content .wrapper a {\n color: #61bdcc;\n font-weight: 100; }\n home-layout > .content .wrapper riotmui-code {\n margin: 10px 0; }\n home-layout > .content .wrapper ul {\n list-style: none; }\n home-layout > .content .wrapper .checkout {\n margin: 80px 0;\n border: 1px solid #61bdcc; }\n home-layout > .content .wrapper .line {\n display: flex;\n align-items: center;\n justify-content: center;\n background: #25313b; }\n\n@media (min-width: 768px) and (max-width: 1024px) {\n home-layout material-navbar {\n height: 300px; } }\n\n@media (min-width: 480px) and (max-width: 768px) {\n home-layout material-navbar {\n height: 200px; } }\n\n@media (min-width: 320px) and (max-width: 480px) {\n home-layout material-navbar {\n height: 200px; } }\n", ""]);
add
2024-03-23 11:25:41 +00:00
// exports
/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
riot.tag2('script', '', '', 'src="/bower_components/jquery.terminal/js/jquery.terminal.min.js"', function (opts) {});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 32 */
/***/ (function(module, exports) {
"use strict";
/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
var riot = __webpack_require__(1);
__webpack_require__(27);
// Page tags
//require('./components/pages/home.tag');
//require('./components/pages/404.tag');
__webpack_require__(34);
//require('./components/pages/checkbox.tag');
//require('./components/pages/combobox.tag');
//require('./components/pages/input.tag');
//require('./components/pages/dropdown.tag');
//require('./components/pages/dropdown-list.tag');
__webpack_require__(51);
//require('./components/pages/pane.tag');
//require('./components/pages/popup.tag');
//require('./components/pages/snackbar.tag');
//require('./components/pages/tabs.tag');
//require('./components/pages/textarea.tag');
var Route = riot.router.Route,
DefaultRoute = riot.router.DefaultRoute,
NotFoundRoute = riot.router.NotFoundRoute,
RedirectRoute = riot.router.RedirectRoute;
riot.router.routes([new DefaultRoute({ tag: 'home' }), new Route({ tag: 'buttons' })]);
//new Route({tag: 'checkbox'}),
//new Route({tag: 'combobox'}),
//new Route({tag: 'm-input'}),
//new Route({tag: 'dropdown'}),
//new Route({tag: 'dropdown-list'}),
//new Route({tag: 'navbar'}),
//new Route({tag: 'pane'}),
//new Route({tag: 'popup'}),
//new Route({tag: 'snackbar'}),
//new Route({tag: 'tabs'}),
//new Route({tag: 'm-textarea'}),
//new NotFoundRoute({tag:'not-found'})
riot.router.start();
/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(35);
__webpack_require__(41);
__webpack_require__(48);
__webpack_require__(38);
__webpack_require__(16);
riot.tag2('buttons', '<riotmui-desc> </riotmui-desc>', '', '', function (opts) {
this.example1 = '<material-button class="ui">\n <div class="text">BUTTON</div>\n </material-button>';
this.example2 = '<material-button class="ui" waves-center="true" rounded="true" waves-opacity="0.6" waves-duration="600" style="background:#f43137">\n <i class="material-icons">add</i>\n </material-button>';
this.example3 = '<material-button class="ui" waves-color="#000" shady="true" style="background:#ed7ff4; height: 50px; line-height: 46px">\n <div class="text">ICON</div>\n <i class="material-icons">create</i>\n </material-button>';
this.example4 = '<material-button class="ui" disabled="true">\n <div class="text">Disabled</div>\n </material-button>';
this.children = [{
title: '<div class="text">TEXT</div>',
type: 'tag',
'default': '',
desc: 'Adds text to the button.'
}, {
title: '<div class="icon"><svg>...</svg></div>',
type: 'tag',
'default': '',
desc: 'Adds icon to the button.'
}, {
title: ' <i class="material-icons"> create </i>',
type: 'tag',
'default': '',
desc: 'If you use google material icon set you can add it into material-button.'
}];
this.options = [{
title: 'rounded',
type: 'String ["true"|"false"]',
'default': 'false',
desc: 'If set "true" will make button rounded.'
}, {
title: 'shady',
type: 'String ["true"|"false"]',
'default': 'false',
desc: 'If set "true" will add to the button box-shadow property.'
}, {
title: 'disabled',
type: 'String ["true"|"false"]',
'default': 'false',
desc: 'If set "true" user won\'t be able to click on it. Also it will change button color.'
}, {
title: 'link',
type: 'String',
'default': '',
desc: 'If will be set link attribute then material button will behave it like a "a" tag.'
}, {
title: 'waves-center',
type: 'String ["true"|"false"]',
'default': 'false',
desc: 'If set "true" waves will start animation from center of button.'
}, {
title: 'waves-opacity',
type: 'Number [0<x<1]',
'default': '0.4',
desc: 'Using this option it\'s possible to setup wave opacity.'
}, {
title: 'waves-duration',
type: 'Number [ms]',
'default': '400',
desc: 'Speed of waves animation.'
}, {
title: 'waves-color',
type: 'color [RGB]',
'default': '#fff',
desc: 'Allows to setup waves\'s color.'
}];
this.styling = [{
title: '$material-button-height',
type: 'px',
'default': '40',
desc: 'Sets default height of button.'
}, {
title: '$material-button-background',
type: 'color',
'default': '#61bdcc',
desc: 'Sets default button background.'
}, {
title: '$material-button-disabled-background',
type: 'color',
'default': '#ccc',
desc: 'Sets disabled button background.'
}, {
title: '$material-button-color',
type: 'color',
'default': '#fff',
desc: 'Sets default button text color.'
}, {
title: '$material-button-padding',
type: 'rem',
'default': '0 2rem',
desc: 'Sets default button left&right offset.'
}, {
title: '$material-button-font-size',
type: 'px',
'default': '18',
desc: 'Sets default button text font size.'
}, {
title: '$material-button-icon-size',
type: 'px',
'default': '20',
desc: 'Sets default button icon font size. (For google material icon set)'
}];
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(36);
__webpack_require__(15);
__webpack_require__(38);
__webpack_require__(12);
__webpack_require__(16);
riot.tag2('riotmui-desc', '<div class="content"> <content select=".riotmui-desc-examples"></content> <content select=".riotmui-desc-description"></content> <yield></yield> </div>', '', 'role="toolbar"', function (opts) {
this.mixin('content');
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(37);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(37, function() {
var newContent = __webpack_require__(37);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "riotmui-desc > .content {\n padding: 0 20px; }\n riotmui-desc > .content > .title {\n padding: 50px 0 20px 0;\n font-size: 28px;\n color: #1c3b53; }\n riotmui-desc > .content > .title.first {\n padding: 20px 0; }\n riotmui-desc > .content material-card {\n margin-top: 20px;\n position: relative; }\n riotmui-desc > .content material-card:first-child {\n margin-top: 0; }\n riotmui-desc > .content material-card .title {\n padding: 10px 20px;\n font-size: 18px;\n color: #61bdcc;\n box-shadow: none; }\n riotmui-desc > .content material-card .material-card-content {\n padding: 10px 20px 20px 20px; }\n riotmui-desc > .content material-card .material-card-content .button-container {\n display: inline-block;\n position: relative; }\n riotmui-desc > .content material-card .material-card-content .button-container material-dropdown p {\n padding: 20px 51px; }\n riotmui-desc > .content .riotmui-desc-description p {\n display: block;\n padding: 5px 5px; }\n riotmui-desc > .content .riotmui-desc-description .description-title {\n padding: 30px 0px 15px 0;\n font-size: 20px;\n color: #61bdcc;\n box-shadow: none; }\n\n@media only screen and (min-width: 768px) and (max-width: 1024px) {\n riotmui-desc > .content {\n padding: 0 5px; }\n riotmui-desc > .content .col-flex {\n margin-top: 20px; }\n riotmui-desc > .content .col-flex:first-child {\n margin-top: 0px; } }\n\n@media only screen and (min-width: 320px) and (max-width: 480px) {\n riotmui-desc > .content {\n padding: 0 5px; }\n riotmui-desc > .content .col-flex {\n margin-top: 20px; }\n riotmui-desc > .content .col-flex:first-child {\n margin-top: 0px; } }\n\n@media only screen and (min-width: 480px) and (max-width: 768px) {\n riotmui-desc > .content .col-flex {\n margin-top: 20px; }\n riotmui-desc > .content .col-flex:first-child {\n margin-top: 0px; } }\n", ""]);
// exports
/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(39);
__webpack_require__(15);
riot.tag2('material-card', '<div class="title" if="{{titleExist}}"> <content select=".material-card-title"></content> </div> <yield></yield>', '', '', function (opts) {
var _this = this;
this.titleExist = false;
this.on('mount', function () {
_this.update({ titleExist: !!_this.root.querySelector('.material-card-title') });
});
this.mixin('content');
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 39 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(40);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(40, function() {
var newContent = __webpack_require__(40);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "material-card {\n display: block;\n background-color: #fff;\n margin: 0;\n overflow-y: auto;\n will-change: width, height;\n -webkit-box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);\n -ms-box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);\n -moz-box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);\n -o-box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);\n box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.16), 0 2px 10px 0 rgba(0, 0, 0, 0.12);\n transform: translateY(0px);\n opacity: 1;\n -webkit-transition: transform .2s ease-in,opacity .2s;\n -ms-transition: transform .2s ease-in,opacity .2s;\n -moz-transition: transform .2s ease-in,opacity .2s;\n -o-transition: transform .2s ease-in,opacity .2s;\n transition: transform .2s ease-in,opacity .2s; }\n material-card .title {\n padding: 20px 10px;\n font-size: 22px;\n color: #25313b;\n -webkit-box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.08), 0 2px 7px 0 rgba(0, 0, 0, 0.02);\n -ms-box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.08), 0 2px 7px 0 rgba(0, 0, 0, 0.02);\n -moz-box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.08), 0 2px 7px 0 rgba(0, 0, 0, 0.02);\n -o-box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.08), 0 2px 7px 0 rgba(0, 0, 0, 0.02);\n box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.08), 0 2px 7px 0 rgba(0, 0, 0, 0.02); }\n material-card .material-card-content {\n padding: 20px; }\n", ""]);
// exports
/***/ }),
/* 41 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(42);
__webpack_require__(44);
__webpack_require__(46);
__webpack_require__(47);
riot.tag2('riotmui-code', '<pre>\n <code data-language="html">\n {{opts.code}}\n </code>\n </pre>', '', '', function (opts) {
Rainbow.color();
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(43);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(43, function() {
var newContent = __webpack_require__(43);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 43 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "riotmui-code {\n display: block;\n background: #f5f5f5; }\n riotmui-code pre {\n margin: 0; }\n", ""]);
// exports
/***/ }),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(45);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(45, function() {
var newContent = __webpack_require__(45);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "/**\n * GitHub theme\n *\n * @author Craig Campbell\n * @version 1.0.4\n */\npre {\n word-wrap: break-word;\n padding: 6px 10px;\n line-height: 19px;\n overflow-wrap: inherit;\n overflow-x: scroll; }\n\ncode {\n padding: 0px 5px;\n font-size: 18px; }\n\npre code {\n border: 0px;\n padding: 0px;\n margin: 0px;\n -moz-border-radius: 0px;\n -webkit-border-radius: 0px;\n border-radius: 0px; }\n\npre, code {\n font-family: Consolas, 'Liberation Mono', Courier, monospace;\n color: #333;\n background: #f8f8f8;\n -moz-border-radius: 3px;\n -webkit-border-radius: 3px;\n border-radius: 3px; }\n\npre, pre code {\n font-size: 15px; }\n\npre .comment {\n color: #998; }\n\npre .support {\n color: #0086B3; }\n\npre .tag, pre .tag-name {\n color: navy; }\n\npre .keyword, pre .css-property, pre .vendor-prefix, pre .sass, pre .class, pre .id, pre .css-value, pre .entity.function, pre .storage.function {\n font-weight: bold; }\n\npre .css-property, pre .css-value, pre .vendor-prefix, pre .support.namespace {\n color: #333; }\n\npre .constant.numeric, pre .keyword.unit, pre .hex-color {\n font-weight: normal;\n color: #099; }\n\npre .entity.class {\n color: #458; }\n\npre .entity.id, pre .entity.function {\n color: #900; }\n\npre .attribute, pre .variable {\n color: teal; }\n\npre .string, pre .support.value {\n font-weight: normal;\n color: #d14; }\n\npre .regexp {\n color: #009926; }\n", ""]);
// exports
/***/ }),
/* 46 */
/***/ (function(module, exports) {
/* Rainbow v1.1.9 rainbowco.de */
"use strict";
window.Rainbow = (function () {
function q(a) {
var b,
c = a.getAttribute && a.getAttribute("data-language") || 0;if (!c) {
a = a.attributes;for (b = 0; b < a.length; ++b) if ("data-language" === a[b].nodeName) return a[b].nodeValue;
}return c;
}function B(a) {
var b = q(a) || q(a.parentNode);if (!b) {
var c = /\blang(?:uage)?-(\w+)/;(a = a.className.match(c) || a.parentNode.className.match(c)) && (b = a[1]);
}return b;
}function C(a, b) {
for (var c in e[d]) {
c = parseInt(c, 10);if (a == c && b == e[d][c] ? 0 : a <= c && b >= e[d][c]) delete e[d][c], delete j[d][c];if (a >= c && a < e[d][c] || b > c && b < e[d][c]) return !0;
}return !1;
}function r(a, b) {
return '<span class="' + a.replace(/\./g, " ") + (l ? " " + l : "") + '">' + b + "</span>";
}function s(a, b, c, h) {
var f = a.exec(c);if (f) {
++t;!b.name && "string" == typeof b.matches[0] && (b.name = b.matches[0], delete b.matches[0]);var k = f[0],
i = f.index,
u = f[0].length + i,
g = function g() {
function f() {
s(a, b, c, h);
}t % 100 > 0 ? f() : setTimeout(f, 0);
};if (C(i, u)) g();else {
var m = v(b.matches),
l = function l(a, c, h) {
if (a >= c.length) h(k);else {
var d = f[c[a]];if (d) {
var e = b.matches[c[a]],
i = e.language,
g = e.name && e.matches ? e.matches : e,
j = function j(b, d, e) {
var i;i = 0;var g;for (g = 1; g < c[a]; ++g) f[g] && (i = i + f[g].length);d = e ? r(e, d) : d;k = k.substr(0, i) + k.substr(i).replace(b, d);l(++a, c, h);
};i ? n(d, i, function (a) {
j(d, a);
}) : typeof e === "string" ? j(d, d, e) : w(d, g.length ? g : [g], function (a) {
j(d, a, e.matches ? e.name : 0);
});
} else l(++a, c, h);
}
};l(0, m, function (a) {
b.name && (a = r(b.name, a));if (!j[d]) {
j[d] = {};e[d] = {};
}j[d][i] = { replace: f[0], "with": a };e[d][i] = u;g();
});
}
} else h();
}function v(a) {
var b = [],
c;for (c in a) a.hasOwnProperty(c) && b.push(c);return b.sort(function (a, b) {
return b - a;
});
}function w(a, b, c) {
function h(b, k) {
k < b.length ? s(b[k].pattern, b[k], a, function () {
h(b, ++k);
}) : D(a, function (a) {
delete j[d];delete e[d];--d;c(a);
});
}++d;h(b, 0);
}function D(a, b) {
function c(a, b, h, e) {
if (h < b.length) {
++x;var g = b[h],
l = j[d][g],
a = a.substr(0, g) + a.substr(g).replace(l.replace, l["with"]),
g = function g() {
c(a, b, ++h, e);
};0 < x % 250 ? g() : setTimeout(g, 0);
} else e(a);
}var h = v(j[d]);c(a, h, 0, b);
}function n(a, b, c) {
var d = m[b] || [],
f = m[y] || [],
b = z[b] ? d : d.concat(f);w(a.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/&(?![\w\#]+;)/g, "&amp;"), b, c);
}function o(_x, _x2, _x3) {
var _again = true;
_function: while (_again) {
var a = _x,
b = _x2,
c = _x3;
_again = false;
if (b < a.length) {
var d = a[b],
f = B(d);if (!(-1 < (" " + d.className + " ").indexOf(" rainbow ")) && f) {
return f = f.toLowerCase(), d.className += d.className ? " rainbow" : "rainbow", n(d.innerHTML, f, function (k) {
d.innerHTML = k;j = {};e = {};p && p(d, f);setTimeout(function () {
o(a, ++b, c);
}, 0);
});
} else {
_x = a;
_x2 = ++b;
_x3 = c;
_again = true;
d = f = undefined;
continue _function;
}
}c && c();
}
}function A(a, b) {
var a = a && "function" == typeof a.getElementsByTagName ? a : document,
c = a.getElementsByTagName("pre"),
d = a.getElementsByTagName("code"),
f,
e = [];for (f = 0; f < d.length; ++f) e.push(d[f]);for (f = 0; f < c.length; ++f) c[f].getElementsByTagName("code").length || e.push(c[f]);o(e, 0, b);
}var j = {},
e = {},
m = {},
z = {},
d = 0,
y = 0,
t = 0,
x = 0,
l,
p;return { extend: function extend(a, b, c) {
1 == arguments.length && (b = a, a = y);z[a] = c;m[a] = b.concat(m[a] || []);
}, b: function b(a) {
p = a;
}, a: function a(_a) {
l = _a;
}, color: function color(a, b, c) {
if ("string" == typeof a) return n(a, b, c);if ("function" == typeof a) return A(0, a);A(a, b);
} };
})();document.addEventListener ? document.addEventListener("DOMContentLoaded", Rainbow.color, !1) : window.attachEvent("onload", Rainbow.color);
Rainbow.onHighlight = Rainbow.b;Rainbow.addClass = Rainbow.a;
/***/ }),
/* 47 */
/***/ (function(module, exports) {
/**
* HTML patterns
*
* @author Craig Campbell
* @version 1.0.9
*/
'use strict';
Rainbow.extend('html', [{
'name': 'source.php.embedded',
'matches': {
2: {
'language': 'php'
}
},
'pattern': /&lt;\?=?(?!xml)(php)?([\s\S]*?)(\?&gt;)/gm
}, {
'name': 'source.css.embedded',
'matches': {
1: {
'matches': {
1: 'support.tag.style',
2: [{
'name': 'entity.tag.style',
'pattern': /^style/g
}, {
'name': 'string',
'pattern': /('|")(.*?)(\1)/g
}, {
'name': 'entity.tag.style.attribute',
'pattern': /(\w+)/g
}],
3: 'support.tag.style'
},
'pattern': /(&lt;\/?)(style.*?)(&gt;)/g
},
2: {
'language': 'css'
},
3: 'support.tag.style',
4: 'entity.tag.style',
5: 'support.tag.style'
},
'pattern': /(&lt;style.*?&gt;)([\s\S]*?)(&lt;\/)(style)(&gt;)/gm
}, {
'name': 'source.js.embedded',
'matches': {
1: {
'matches': {
1: 'support.tag.script',
2: [{
'name': 'entity.tag.script',
'pattern': /^script/g
}, {
'name': 'string',
'pattern': /('|")(.*?)(\1)/g
}, {
'name': 'entity.tag.script.attribute',
'pattern': /(\w+)/g
}],
3: 'support.tag.script'
},
'pattern': /(&lt;\/?)(script.*?)(&gt;)/g
},
2: {
'language': 'javascript'
},
3: 'support.tag.script',
4: 'entity.tag.script',
5: 'support.tag.script'
},
'pattern': /(&lt;script(?! src).*?&gt;)([\s\S]*?)(&lt;\/)(script)(&gt;)/gm
}, {
'name': 'comment.html',
'pattern': /&lt;\!--[\S\s]*?--&gt;/g
}, {
'matches': {
1: 'support.tag.open',
2: 'support.tag.close'
},
'pattern': /(&lt;)|(\/?\??&gt;)/g
}, {
'name': 'support.tag',
'matches': {
1: 'support.tag',
2: 'support.tag.special',
3: 'support.tag-name'
},
'pattern': /(&lt;\??)(\/|\!?)(\w+)/g
}, {
'matches': {
1: 'support.attribute'
},
'pattern': /([a-z-]+)(?=\=)/gi
}, {
'matches': {
1: 'support.operator',
2: 'string.quote',
3: 'string.value',
4: 'string.quote'
},
'pattern': /(=)('|")(.*?)(\2)/g
}, {
'matches': {
1: 'support.operator',
2: 'support.value'
},
'pattern': /(=)([a-zA-Z\-0-9]*)\b/g
}, {
'matches': {
1: 'support.attribute'
},
'pattern': /\s(\w+)(?=\s|&gt;)(?![\s\S]*&lt;)/g
}], true);
/***/ }),
/* 48 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(49);
riot.tag2('riotmui-option', '<div class="option row" each="{{option,key in opts.data}}"> <div class="option-title col-lg-3 col-md-3 col-sm-6 col-xs-6">{{option.title}}</div> <div class="option-desc col-lg-9 col-md-9 col-sm-6 col-xs-6"> <p> <span class="type">{{option.type}}</span> <span class="default">{{option.default}}</span> </p> <p> {{option.desc}} </p> </div> </div>', '', '', function (opts) {});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(50);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(50, function() {
var newContent = __webpack_require__(50);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "riotmui-option .option {\n padding: 10px 0; }\n riotmui-option .option-title {\n font-weight: 700; }\n riotmui-option .option .type {\n color: #8d9899; }\n riotmui-option .option .default {\n color: #414546;\n margin-left: 20px; }\n", ""]);
// exports
/***/ }),
/* 51 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
__webpack_require__(35);
__webpack_require__(41);
__webpack_require__(48);
__webpack_require__(38);
__webpack_require__(9);
riot.tag2('navbar', '<riotmui-desc> <div class="riotmui-desc-examples row"> <div class="col-lg-6 col-md-12 col-sm-12 col-xs-12 col-flex"> <material-card> <div class="material-card-title">Default Navbar</div> <div class="material-card-content"> <material-navbar> <div class="logo"><a href="#">Logo</a></div> </material-navbar> </div> <riotmui-code style="margin-top: 46px" code="{{this.parent.parent.example1}}"></riotmui-code> </material-card> </div> <div class="col-lg-6 col-md-12 col-sm-12 col-xs-12 col-flex"> <material-card> <div class="material-card-title">Custom styling</div> <div class="material-card-content"> <material-navbar style="background: #ccc;"> <div class="logo"><a href="#">Logo</a></div> </material-navbar> </div> <riotmui-code style="margin-top: 46px" code="{{this.parent.parent.example2}}"></riotmui-code> </material-card> </div> </div> <div class="riotmui-desc-description"> <p> Material Navbar can be used like a header or some another ui element of your web page. </p> <div class="description-title" if="{{this.parent.children}}">Children</div> <riotmui-option data="{{this.parent.children}}"></riotmui-option> <div class="description-title" if="{{this.parent.options}}">Options</div> <riotmui-option data="{{this.parent.options}}"></riotmui-option> <div class="description-title" if="{{this.parent.methods}}">Methods,Listeners and Properties</div> <riotmui-option data="{{this.parent.methods}}"></riotmui-option> </div> </riotmui-desc>', '', '', function (opts) {
this.example1 = '<material-navbar>\n <div class="logo"><a href="#">Logo</a></div>\n </material-navbar>';
this.example2 = '<material-navbar style="background: #ccc;" >\n <div class="logo"><a href="#">Logo</a></div>\n </material-navbar>';
this.children = [{
title: '<div class="logo">Logo</div>',
type: 'tag',
'default': '',
desc: 'Adds logotype element to material navbar.'
}];
this.options = [{
title: 'fixed',
type: 'string ["true"|"false"]',
'default': 'false',
desc: 'If set "true" will make navbar stuck to current position.'
}];
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))
/***/ }),
/* 52 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(53);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(53, function() {
var newContent = __webpack_require__(53);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 53 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "html {\n font-family: sans-serif;\n /* 1 */\n -ms-text-size-adjust: 100%;\n /* 2 */\n -webkit-text-size-adjust: 100%;\n /* 2 */ }\n\n/**\n * Remove default margin.\n */\nbody {\n margin: 0; }\n\n/* HTML5 display definitions\n ========================================================================== */\n/**\n * Correct `block` display not defined for any HTML5 element in IE 8/9.\n * Correct `block` display not defined for `details` or `summary` in IE 10/11\n * and Firefox.\n * Correct `block` display not defined for `main` in IE 11.\n */\narticle,\naside,\ndetails,\nfigcaption,\nfigure,\nfooter,\nheader,\nhgroup,\nmain,\nmenu,\nnav,\nsection,\nsummary {\n display: block; }\n\n/**\n * 1. Correct `inline-block` display not defined in IE 8/9.\n * 2. Normalize vertical alignment of `progress` in Chrome, Firefox, and Opera.\n */\naudio,\ncanvas,\nprogress,\nvideo {\n display: inline-block;\n /* 1 */\n vertical-align: baseline;\n /* 2 */ }\n\n/**\n * Prevent modern browsers from displaying `audio` without controls.\n * Remove excess height in iOS 5 devices.\n */\naudio:not([controls]) {\n display: none;\n height: 0; }\n\n/**\n * Address `[hidden]` styling not present in IE 8/9/10.\n * Hide the `template` element in IE 8/9/11, Safari, and Firefox < 22.\n */\n[hidden],\ntemplate {\n display: none; }\n\n/* Links\n ========================================================================== */\n/**\n * Remove the gray background color from active links in IE 10.\n */\na {\n background-color: transparent; }\n\n/**\n * Improve readability when focused and also mouse hovered in all browsers.\n */\na:active,\na:hover {\n outline: 0; }\n\n/* Text-level semantics\n ========================================================================== */\n/**\n * Address styling not present in IE 8/9/10/11, Safari, and Chrome.\n */\nabbr[title] {\n border-bottom: 1px dotted; }\n\n/**\n * Address style set to `bolder` in Firefox 4+, Safari, and Chrome.\n */\nb,\nstrong {\n font-weight: bold; }\n\n/**\n * Address styling not present in Safari and Chrome.\n */\ndfn {\n font-style: italic; }\n\n/**\n * Address variable `h1` font-size and margin within `section` and `article`\n * contexts in Firefox 4+, Safari, and Chrome.\n */\nh1 {\n font-size: 2em;\n margin: 0.67em 0; }\n\n/**\n * Address styling not present in IE 8/9.\n */\nmark {\n background: #ff0;\n color: #000; }\n\n/**\n * Address inconsistent and variable font size in all browsers.\n */\nsmall {\n font-size: 80%; }\n\n/**\n * Prevent `sub` and `sup` affecting `line-height` in all browsers.\n */\nsub,\nsup {\n font-size: 75%;\n line-height: 0;\n position: relative;\n vertical-align: baseline; }\n\nsup {\n top: -0.5em; }\n\nsub {\n bottom: -0.25em; }\n\n/* Embedded content\n ========================================================================== */\n/**\n * Remove border when inside `a` element in IE 8/9/10.\n */\nimg {\n border: 0; }\n\n/**\n * Correct overflow not hidden in IE 9/10/11.\n */\nsvg:not(:root) {\n overflow: hidden; }\n\n/* Grouping content\n ========================================================================== */\n/**\n * Address margin not present in IE 8/9 and Safari.\n */\nfigure {\n margin: 1em 40px; }\n\n/**\n * Address differences between Firefox and other browsers.\n */\nhr {\n -moz-box-sizing: content-box;\n box-sizing: content-box;\n height: 0; }\n\n/**\n * Contain overflow in all browsers.\n */\npre {\n overflow: auto; }\n\n/**\n * Address odd `em`-unit font size rendering in all browsers.\n */\ncode,\nkbd,\npre,\nsamp {\n font-family: monospace, monospace;\n font-size: 1em; }\n\n/* Forms\n ========================================================================== */\n/**\n * Known limitation: by default, Chrome and Safari on OS X allow very limited\n * styling of `select`, unless a `border` property is set.\n */\n/**\n * 1. Correct color not being inherited.\n * Known issue: affects color of disabled elements.\n * 2. Correct font properties not being inherited.\n * 3. Address margins
// exports
/***/ }),
/* 54 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(55);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(55, function() {
var newContent = __webpack_require__(55);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 55 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "/**\n * Flex Grid -\n * Version: 0.2.1\n *\n * Simple grid built with flex box and sass.\n *\n * Matthew Simo - matthew.a.simo@gmail.com\n */\n/**\n * Grid setup\n *\n * The grid will calculate dimensions based on these two variables\n * $fg-columns will inform the grid loops how many columns there should be.\n * $fg-gutter will inform the grid loops how big eac column's gutters should be.\n */\n/**\n * Break point namespace object\n *\n * Set the default namespace object with these defaults with the\n * understanding that you can pass in whatever you might require for your site.\n *\n * $fg-breakpoints is a Sass list with nested lists inside. Each sub list defines two things.\n * 1. The namespace for that breakpoint. (Required) (i.e. xs, sm, md, lg)\n * 2. The min-width measurement for the breakpoint for that namespace. (i.e. 48em, 62em, 75em)\n *\n * Note: These should be in the proper order (at least till libsass handles map keys properly).\n *\n * Note: If the measurement is left out then it will be skipped when generating\n * the grid and applied to global styles.\n *\n */\n/**\n * Calculate column size percentage\n */\n/**\n * Spacing mixin to create uniform margin/padding\n */\n/**\n * Row wrapper class, flex box parent.\n */\n.row {\n box-sizing: border-box;\n display: flex;\n flex-direction: row;\n flex-wrap: wrap;\n margin-left: -0.5rem;\n margin-right: -0.5rem; }\n\n.col-xs, .col-sm, .col-md, .col-lg, .col-xs-1, .col-xs-2, .col-xs-3, .col-xs-4, .col-xs-5, .col-xs-6, .col-xs-7, .col-xs-8, .col-xs-9, .col-xs-10, .col-xs-11, .col-xs-12, .col-sm-1, .col-sm-2, .col-sm-3, .col-sm-4, .col-sm-5, .col-sm-6, .col-sm-7, .col-sm-8, .col-sm-9, .col-sm-10, .col-sm-11, .col-sm-12, .col-md-1, .col-md-2, .col-md-3, .col-md-4, .col-md-5, .col-md-6, .col-md-7, .col-md-8, .col-md-9, .col-md-10, .col-md-11, .col-md-12, .col-lg-1, .col-lg-2, .col-lg-3, .col-lg-4, .col-lg-5, .col-lg-6, .col-lg-7, .col-lg-8, .col-lg-9, .col-lg-10, .col-lg-11, .col-lg-12 {\n box-sizing: border-box;\n display: flex;\n flex-direction: column;\n flex-grow: 0;\n flex-shrink: 0;\n padding-left: 0.5rem;\n padding-right: 0.5rem; }\n\n.col-xs, .col-sm, .col-md, .col-lg {\n flex-grow: 1;\n flex-basis: 0;\n max-width: 100%; }\n\n/**\n * Generate a set of grid column classes using a namespace\n *\n * .col-[namespace] for intelligent column division\n * .col-[namespace]-[number] for a column that covers a specific number of columns (e.g. 1-12 by default)\n * .off-[namespace]-[number] for pushing a col a specific number of columns (e.g. 1-11 by default)\n */\n/**\n * Build the grid in two steps, to help minimize file size\n * Step 1, for each namespace, create the grid-base\n * Step 2, for each namespace, wrap the col width/offset measurements in their breakpoint media query\n */\n.off-xs-1 {\n margin-left: 8.33333%; }\n\n.off-xs-2 {\n margin-left: 16.66667%; }\n\n.off-xs-3 {\n margin-left: 25%; }\n\n.off-xs-4 {\n margin-left: 33.33333%; }\n\n.off-xs-5 {\n margin-left: 41.66667%; }\n\n.off-xs-6 {\n margin-left: 50%; }\n\n.off-xs-7 {\n margin-left: 58.33333%; }\n\n.off-xs-8 {\n margin-left: 66.66667%; }\n\n.off-xs-9 {\n margin-left: 75%; }\n\n.off-xs-10 {\n margin-left: 83.33333%; }\n\n.off-xs-11 {\n margin-left: 91.66667%; }\n\n@media only screen and (min-width: 768px) {\n .off-sm-1 {\n margin-left: 8.33333%; }\n .off-sm-2 {\n margin-left: 16.66667%; }\n .off-sm-3 {\n margin-left: 25%; }\n .off-sm-4 {\n margin-left: 33.33333%; }\n .off-sm-5 {\n margin-left: 41.66667%; }\n .off-sm-6 {\n margin-left: 50%; }\n .off-sm-7 {\n margin-left: 58.33333%; }\n .off-sm-8 {\n margin-left: 66.66667%; }\n .off-sm-9 {\n margin-left: 75%; }\n .off-sm-10 {\n margin-left: 83.33333%; }\n .off-sm-11 {\n margin-left: 91.66667%; } }\n\n@media only screen and (min-width: 992px) {\n .off-md-1 {\n margin-left: 8.33333%; }\n .off-md-2 {\n margin-left: 16.66667%; }\n .off-md-3 {\n margin-left: 25%; }\n .off-md-4 {\n margin-left: 33.33333%; }\n .off-md-5 {\n margin-left: 41.66
// exports
/***/ }),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(57);
if(typeof content === 'string') content = [[module.id, content, '']];
// add the styles to the DOM
var update = __webpack_require__(8)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(true) {
// When the styles change, update the <style> tags
if(!content.locals) {
module.hot.accept(57, function() {
var newContent = __webpack_require__(57);
if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
update(newContent);
});
}
// When the module is disposed, remove the <style> tags
module.hot.dispose(function() { update(); });
}
/***/ }),
/* 57 */
/***/ (function(module, exports, __webpack_require__) {
exports = module.exports = __webpack_require__(7)();
// imports
// module
exports.push([module.id, "/*\n\nOriginal style from softwaremaniacs.org (c) Ivan Sagalaev <Maniac@SoftwareManiacs.Org>\n\n*/\n.hljs {\n display: block;\n overflow-x: auto;\n padding: 0.5em;\n background: #f0f0f0;\n -webkit-text-size-adjust: none; }\n\n.hljs,\n.hljs-subst,\n.hljs-tag .hljs-title,\n.nginx .hljs-title {\n color: black; }\n\n.hljs-string,\n.hljs-title,\n.hljs-constant,\n.hljs-parent,\n.hljs-tag .hljs-value,\n.hljs-rule .hljs-value,\n.hljs-preprocessor,\n.hljs-pragma,\n.hljs-name,\n.haml .hljs-symbol,\n.ruby .hljs-symbol,\n.ruby .hljs-symbol .hljs-string,\n.hljs-template_tag,\n.django .hljs-variable,\n.smalltalk .hljs-class,\n.hljs-addition,\n.hljs-flow,\n.hljs-stream,\n.bash .hljs-variable,\n.pf .hljs-variable,\n.apache .hljs-tag,\n.apache .hljs-cbracket,\n.tex .hljs-command,\n.tex .hljs-special,\n.erlang_repl .hljs-function_or_atom,\n.asciidoc .hljs-header,\n.markdown .hljs-header,\n.coffeescript .hljs-attribute,\n.tp .hljs-variable {\n color: #800; }\n\n.smartquote,\n.hljs-comment,\n.hljs-annotation,\n.diff .hljs-header,\n.hljs-chunk,\n.asciidoc .hljs-blockquote,\n.markdown .hljs-blockquote {\n color: #888; }\n\n.hljs-number,\n.hljs-date,\n.hljs-regexp,\n.hljs-literal,\n.hljs-hexcolor,\n.smalltalk .hljs-symbol,\n.smalltalk .hljs-char,\n.go .hljs-constant,\n.hljs-change,\n.lasso .hljs-variable,\n.makefile .hljs-variable,\n.asciidoc .hljs-bullet,\n.markdown .hljs-bullet,\n.asciidoc .hljs-link_url,\n.markdown .hljs-link_url {\n color: #080; }\n\n.hljs-label,\n.ruby .hljs-string,\n.hljs-decorator,\n.hljs-filter .hljs-argument,\n.hljs-localvars,\n.hljs-array,\n.hljs-attr_selector,\n.hljs-important,\n.hljs-pseudo,\n.hljs-pi,\n.haml .hljs-bullet,\n.hljs-doctype,\n.hljs-deletion,\n.hljs-envvar,\n.hljs-shebang,\n.apache .hljs-sqbracket,\n.nginx .hljs-built_in,\n.tex .hljs-formula,\n.erlang_repl .hljs-reserved,\n.hljs-prompt,\n.asciidoc .hljs-link_label,\n.markdown .hljs-link_label,\n.vhdl .hljs-attribute,\n.clojure .hljs-attribute,\n.asciidoc .hljs-attribute,\n.lasso .hljs-attribute,\n.coffeescript .hljs-property,\n.hljs-phony {\n color: #88f; }\n\n.hljs-keyword,\n.hljs-id,\n.hljs-title,\n.hljs-built_in,\n.css .hljs-tag,\n.hljs-doctag,\n.smalltalk .hljs-class,\n.hljs-winutils,\n.bash .hljs-variable,\n.pf .hljs-variable,\n.apache .hljs-tag,\n.hljs-type,\n.hljs-typename,\n.tex .hljs-command,\n.asciidoc .hljs-strong,\n.markdown .hljs-strong,\n.hljs-request,\n.hljs-status,\n.tp .hljs-data,\n.tp .hljs-io {\n font-weight: bold; }\n\n.asciidoc .hljs-emphasis,\n.markdown .hljs-emphasis,\n.tp .hljs-units {\n font-style: italic; }\n\n.nginx .hljs-built_in {\n font-weight: normal; }\n\n.coffeescript .javascript,\n.javascript .xml,\n.lasso .markup,\n.tex .hljs-formula,\n.xml .javascript,\n.xml .vbscript,\n.xml .css,\n.xml .hljs-cdata {\n opacity: 0.5; }\n", ""]);
// exports
/***/ })
/******/ ]);
Copy Permalink