text: /******/ (function(modules) { // webpackBootstrap
  /******/ 	function hotDisposeChunk(chunkId) {
  /******/ 		delete installedChunks[chunkId];
  /******/ 	}
  /******/ 	var parentHotUpdateCallback = window["webpackHotUpdate"];
  /******/ 	window["webpackHotUpdate"] = // eslint-disable-next-line no-unused-vars
  /******/ 	function webpackHotUpdateCallback(chunkId, moreModules) {
  /******/ 		hotAddUpdateChunk(chunkId, moreModules);
  /******/ 		if (parentHotUpdateCallback) parentHotUpdateCallback(chunkId, moreModules);
  /******/ 	} ;
  /******/
  /******/ 	// eslint-disable-next-line no-unused-vars
  /******/ 	function hotDownloadUpdateChunk(chunkId) {
  /******/ 		var script = document.createElement("script");
  /******/ 		script.charset = "utf-8";
  /******/ 		script.src = __webpack_require__.p + "" + chunkId + "." + hotCurrentHash + ".hot-update.js";
  /******/ 		if (null) script.crossOrigin = null;
  /******/ 		document.head.appendChild(script);
  /******/ 	}
  /******/
  /******/ 	// eslint-disable-next-line no-unused-vars
  /******/ 	function hotDownloadManifest(requestTimeout) {
  /******/ 		requestTimeout = requestTimeout || 10000;
  /******/ 		return new Promise(function(resolve, reject) {
  /******/ 			if (typeof XMLHttpRequest === "undefined") {
  /******/ 				return reject(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 = requestTimeout;
  /******/ 				request.send(null);
  /******/ 			} catch (err) {
  /******/ 				return reject(err);
  /******/ 			}
  /******/ 			request.onreadystatechange = function() {
  /******/ 				if (request.readyState !== 4) return;
  /******/ 				if (request.status === 0) {
  /******/ 					// timeout
  /******/ 					reject(
  /******/ 						new Error("Manifest request to " + requestPath + " timed out.")
  /******/ 					);
  /******/ 				} else if (request.status === 404) {
  /******/ 					// no update available
  /******/ 					resolve();
  /******/ 				} else if (request.status !== 200 && request.status !== 304) {
  /******/ 					// other failure
  /******/ 					reject(new Error("Manifest request to " + requestPath + " failed."));
  /******/ 				} else {
  /******/ 					// success
  /******/ 					try {
  /******/ 						var update = JSON.parse(request.responseText);
  /******/ 					} catch (e) {
  /******/ 						reject(e);
  /******/ 						return;
  /******/ 					}
  /******/ 					resolve(update);
  /******/ 				}
  /******/ 			};
  /******/ 		});
  /******/ 	}
  /******/
  /******/ 	var hotApplyOnUpdate = true;
  /******/ 	// eslint-disable-next-line no-unused-vars
  /******/ 	var hotCurrentHash = "d4819140aaf77f8bd649";
  /******/ 	var hotRequestTimeout = 10000;
  /******/ 	var hotCurrentModuleData = {};
  /******/ 	var hotCurrentChildModule;
  /******/ 	// eslint-disable-next-line no-unused-vars
  /******/ 	var hotCurrentParents = [];
  /******/ 	// eslint-disable-next-line no-unused-vars
  /******/ 	var hotCurrentParentsTemp = [];
  /******/
  /******/ 	// eslint-disable-next-line no-unused-vars
  /******/ 	function hotCreateRequire(moduleId) {
  /******/ 		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) === -1) {
  /******/ 						installedModules[request].parents.push(moduleId);
  /******/ 					}
  /******/ 				} else {
  /******/ 					hotCurrentParents = [moduleId];
  /******/ 					hotCurrentChildModule = request;
  /******/ 				}
  /******/ 				if (me.children.indexOf(request) === -1) {
  /******/ 					me.children.push(request);
  /******/ 				}
  /******/ 			} else {
  /******/ 				console.warn(
  /******/ 					"[HMR] unexpected require(" +
  /******/ 						request +
  /******/ 						") from disposed module " +
  /******/ 						moduleId
  /******/ 				);
  /******/ 				hotCurrentParents = [];
  /******/ 			}
  /******/ 			return __webpack_require__(request);
  /******/ 		};
  /******/ 		var ObjectFactory = function ObjectFactory(name) {
  /******/ 			return {
  /******/ 				configurable: true,
  /******/ 				enumerable: true,
  /******/ 				get: function() {
  /******/ 					return __webpack_require__[name];
  /******/ 				},
  /******/ 				set: function(value) {
  /******/ 					__webpack_require__[name] = value;
  /******/ 				}
  /******/ 			};
  /******/ 		};
  /******/ 		for (var name in __webpack_require__) {
  /******/ 			if (
  /******/ 				Object.prototype.hasOwnProperty.call(__webpack_require__, name) &&
  /******/ 				name !== "e" &&
  /******/ 				name !== "t"
  /******/ 			) {
  /******/ 				Object.defineProperty(fn, name, ObjectFactory(name));
  /******/ 			}
  /******/ 		}
  /******/ 		fn.e = function(chunkId) {
  /******/ 			if (hotStatus === "ready") hotSetStatus("prepare");
  /******/ 			hotChunksLoading++;
  /******/ 			return __webpack_require__.e(chunkId).then(finishChunkLoading, function(err) {
  /******/ 				finishChunkLoading();
  /******/ 				throw err;
  /******/ 			});
  /******/
  /******/ 			function finishChunkLoading() {
  /******/ 				hotChunksLoading--;
  /******/ 				if (hotStatus === "prepare") {
  /******/ 					if (!hotWaitingFilesMap[chunkId]) {
  /******/ 						hotEnsureUpdateChunk(chunkId);
  /******/ 					}
  /******/ 					if (hotChunksLoading === 0 && hotWaitingFiles === 0) {
  /******/ 						hotUpdateDownloaded();
  /******/ 					}
  /******/ 				}
  /******/ 			}
  /******/ 		};
  /******/ 		fn.t = function(value, mode) {
  /******/ 			if (mode & 1) value = fn(value);
  /******/ 			return __webpack_require__.t(value, mode & ~1);
  /******/ 		};
  /******/ 		return fn;
  /******/ 	}
  /******/
  /******/ 	// eslint-disable-next-line no-unused-vars
  /******/ 	function hotCreateModule(moduleId) {
  /******/ 		var hot = {
  /******/ 			// private stuff
  /******/ 			_acceptedDependencies: {},
  /******/ 			_declinedDependencies: {},
  /******/ 			_selfAccepted: false,
  /******/ 			_selfDeclined: false,
  /******/ 			_selfInvalidated: false,
  /******/ 			_disposeHandlers: [],
  /******/ 			_main: hotCurrentChildModule !== moduleId,
  /******/
  /******/ 			// Module API
  /******/ 			active: true,
  /******/ 			accept: function(dep, callback) {
  /******/ 				if (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 || function() {};
  /******/ 				else hot._acceptedDependencies[dep] = callback || function() {};
  /******/ 			},
  /******/ 			decline: function(dep) {
  /******/ 				if (dep === undefined) hot._selfDeclined = true;
  /******/ 				else if (typeof dep === "object")
  /******/ 					for (var i = 0; i < dep.length; i++)
  /******/ 						hot._declinedDependencies[dep[i]] = true;
  /******/ 				else hot._declinedDependencies[dep] = 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);
  /******/ 			},
  /******/ 			invalidate: function() {
  /******/ 				this._selfInvalidated = true;
  /******/ 				switch (hotStatus) {
  /******/ 					case "idle":
  /******/ 						hotUpdate = {};
  /******/ 						hotUpdate[moduleId] = modules[moduleId];
  /******/ 						hotSetStatus("ready");
  /******/ 						break;
  /******/ 					case "ready":
  /******/ 						hotApplyInvalidatedModule(moduleId);
  /******/ 						break;
  /******/ 					case "prepare":
  /******/ 					case "check":
  /******/ 					case "dispose":
  /******/ 					case "apply":
  /******/ 						(hotQueuedInvalidatedModules =
  /******/ 							hotQueuedInvalidatedModules || []).push(moduleId);
  /******/ 						break;
  /******/ 					default:
  /******/ 						// ignore requests in error states
  /******/ 						break;
  /******/ 				}
  /******/ 			},
  /******/
  /******/ 			// 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]
  /******/ 		};
  /******/ 		hotCurrentChildModule = undefined;
  /******/ 		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 hotAvailableFilesMap = {};
  /******/ 	var hotDeferred;
  /******/
  /******/ 	// The update info
  /******/ 	var hotUpdate, hotUpdateNewHash, hotQueuedInvalidatedModules;
  /******/
  /******/ 	function toModuleId(id) {
  /******/ 		var isNumber = +id + "" === id;
  /******/ 		return isNumber ? +id : id;
  /******/ 	}
  /******/
  /******/ 	function hotCheck(apply) {
  /******/ 		if (hotStatus !== "idle") {
  /******/ 			throw new Error("check() is only allowed in idle status");
  /******/ 		}
  /******/ 		hotApplyOnUpdate = apply;
  /******/ 		hotSetStatus("check");
  /******/ 		return hotDownloadManifest(hotRequestTimeout).then(function(update) {
  /******/ 			if (!update) {
  /******/ 				hotSetStatus(hotApplyInvalidatedModules() ? "ready" : "idle");
  /******/ 				return null;
  /******/ 			}
  /******/ 			hotRequestedFilesMap = {};
  /******/ 			hotWaitingFilesMap = {};
  /******/ 			hotAvailableFilesMap = update.c;
  /******/ 			hotUpdateNewHash = update.h;
  /******/
  /******/ 			hotSetStatus("prepare");
  /******/ 			var promise = new Promise(function(resolve, reject) {
  /******/ 				hotDeferred = {
  /******/ 					resolve: resolve,
  /******/ 					reject: reject
  /******/ 				};
  /******/ 			});
  /******/ 			hotUpdate = {};
  /******/ 			var chunkId = "cms";
  /******/ 			// eslint-disable-next-line no-lone-blocks
  /******/ 			{
  /******/ 				hotEnsureUpdateChunk(chunkId);
  /******/ 			}
  /******/ 			if (
  /******/ 				hotStatus === "prepare" &&
  /******/ 				hotChunksLoading === 0 &&
  /******/ 				hotWaitingFiles === 0
  /******/ 			) {
  /******/ 				hotUpdateDownloaded();
  /******/ 			}
  /******/ 			return promise;
  /******/ 		});
  /******/ 	}
  /******/
  /******/ 	// eslint-disable-next-line no-unused-vars
  /******/ 	function hotAddUpdateChunk(chunkId, moreModules) {
  /******/ 		if (!hotAvailableFilesMap[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 (!hotAvailableFilesMap[chunkId]) {
  /******/ 			hotWaitingFilesMap[chunkId] = true;
  /******/ 		} else {
  /******/ 			hotRequestedFilesMap[chunkId] = true;
  /******/ 			hotWaitingFiles++;
  /******/ 			hotDownloadUpdateChunk(chunkId);
  /******/ 		}
  /******/ 	}
  /******/
  /******/ 	function hotUpdateDownloaded() {
  /******/ 		hotSetStatus("ready");
  /******/ 		var deferred = hotDeferred;
  /******/ 		hotDeferred = null;
  /******/ 		if (!deferred) return;
  /******/ 		if (hotApplyOnUpdate) {
  /******/ 			// Wrap deferred object in Promise to mark it as a well-handled Promise to
  /******/ 			// avoid triggering uncaught exception warning in Chrome.
  /******/ 			// See https://bugs.chromium.org/p/chromium/issues/detail?id=465666
  /******/ 			Promise.resolve()
  /******/ 				.then(function() {
  /******/ 					return hotApply(hotApplyOnUpdate);
  /******/ 				})
  /******/ 				.then(
  /******/ 					function(result) {
  /******/ 						deferred.resolve(result);
  /******/ 					},
  /******/ 					function(err) {
  /******/ 						deferred.reject(err);
  /******/ 					}
  /******/ 				);
  /******/ 		} else {
  /******/ 			var outdatedModules = [];
  /******/ 			for (var id in hotUpdate) {
  /******/ 				if (Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
  /******/ 					outdatedModules.push(toModuleId(id));
  /******/ 				}
  /******/ 			}
  /******/ 			deferred.resolve(outdatedModules);
  /******/ 		}
  /******/ 	}
  /******/
  /******/ 	function hotApply(options) {
  /******/ 		if (hotStatus !== "ready")
  /******/ 			throw new Error("apply() is only allowed in ready status");
  /******/ 		options = options || {};
  /******/ 		return hotApplyInternal(options);
  /******/ 	}
  /******/
  /******/ 	function hotApplyInternal(options) {
  /******/ 		hotApplyInvalidatedModules();
  /******/
  /******/ 		var cb;
  /******/ 		var i;
  /******/ 		var j;
  /******/ 		var module;
  /******/ 		var moduleId;
  /******/
  /******/ 		function getAffectedStuff(updateModuleId) {
  /******/ 			var outdatedModules = [updateModuleId];
  /******/ 			var outdatedDependencies = {};
  /******/
  /******/ 			var queue = outdatedModules.map(function(id) {
  /******/ 				return {
  /******/ 					chain: [id],
  /******/ 					id: id
  /******/ 				};
  /******/ 			});
  /******/ 			while (queue.length > 0) {
  /******/ 				var queueItem = queue.pop();
  /******/ 				var moduleId = queueItem.id;
  /******/ 				var chain = queueItem.chain;
  /******/ 				module = installedModules[moduleId];
  /******/ 				if (
  /******/ 					!module ||
  /******/ 					(module.hot._selfAccepted && !module.hot._selfInvalidated)
  /******/ 				)
  /******/ 					continue;
  /******/ 				if (module.hot._selfDeclined) {
  /******/ 					return {
  /******/ 						type: "self-declined",
  /******/ 						chain: chain,
  /******/ 						moduleId: moduleId
  /******/ 					};
  /******/ 				}
  /******/ 				if (module.hot._main) {
  /******/ 					return {
  /******/ 						type: "unaccepted",
  /******/ 						chain: chain,
  /******/ 						moduleId: moduleId
  /******/ 					};
  /******/ 				}
  /******/ 				for (var i = 0; i < module.parents.length; i++) {
  /******/ 					var parentId = module.parents[i];
  /******/ 					var parent = installedModules[parentId];
  /******/ 					if (!parent) continue;
  /******/ 					if (parent.hot._declinedDependencies[moduleId]) {
  /******/ 						return {
  /******/ 							type: "declined",
  /******/ 							chain: chain.concat([parentId]),
  /******/ 							moduleId: moduleId,
  /******/ 							parentId: parentId
  /******/ 						};
  /******/ 					}
  /******/ 					if (outdatedModules.indexOf(parentId) !== -1) continue;
  /******/ 					if (parent.hot._acceptedDependencies[moduleId]) {
  /******/ 						if (!outdatedDependencies[parentId])
  /******/ 							outdatedDependencies[parentId] = [];
  /******/ 						addAllToSet(outdatedDependencies[parentId], [moduleId]);
  /******/ 						continue;
  /******/ 					}
  /******/ 					delete outdatedDependencies[parentId];
  /******/ 					outdatedModules.push(parentId);
  /******/ 					queue.push({
  /******/ 						chain: chain.concat([parentId]),
  /******/ 						id: parentId
  /******/ 					});
  /******/ 				}
  /******/ 			}
  /******/
  /******/ 			return {
  /******/ 				type: "accepted",
  /******/ 				moduleId: updateModuleId,
  /******/ 				outdatedModules: outdatedModules,
  /******/ 				outdatedDependencies: outdatedDependencies
  /******/ 			};
  /******/ 		}
  /******/
  /******/ 		function addAllToSet(a, b) {
  /******/ 			for (var i = 0; i < b.length; i++) {
  /******/ 				var item = b[i];
  /******/ 				if (a.indexOf(item) === -1) 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 = {};
  /******/
  /******/ 		var warnUnexpectedRequire = function warnUnexpectedRequire() {
  /******/ 			console.warn(
  /******/ 				"[HMR] unexpected require(" + result.moduleId + ") to disposed module"
  /******/ 			);
  /******/ 		};
  /******/
  /******/ 		for (var id in hotUpdate) {
  /******/ 			if (Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
  /******/ 				moduleId = toModuleId(id);
  /******/ 				/** @type {TODO} */
  /******/ 				var result;
  /******/ 				if (hotUpdate[id]) {
  /******/ 					result = getAffectedStuff(moduleId);
  /******/ 				} else {
  /******/ 					result = {
  /******/ 						type: "disposed",
  /******/ 						moduleId: id
  /******/ 					};
  /******/ 				}
  /******/ 				/** @type {Error|false} */
  /******/ 				var abortError = false;
  /******/ 				var doApply = false;
  /******/ 				var doDispose = false;
  /******/ 				var chainInfo = "";
  /******/ 				if (result.chain) {
  /******/ 					chainInfo = "\nUpdate propagation: " + result.chain.join(" -> ");
  /******/ 				}
  /******/ 				switch (result.type) {
  /******/ 					case "self-declined":
  /******/ 						if (options.onDeclined) options.onDeclined(result);
  /******/ 						if (!options.ignoreDeclined)
  /******/ 							abortError = new Error(
  /******/ 								"Aborted because of self decline: " +
  /******/ 									result.moduleId +
  /******/ 									chainInfo
  /******/ 							);
  /******/ 						break;
  /******/ 					case "declined":
  /******/ 						if (options.onDeclined) options.onDeclined(result);
  /******/ 						if (!options.ignoreDeclined)
  /******/ 							abortError = new Error(
  /******/ 								"Aborted because of declined dependency: " +
  /******/ 									result.moduleId +
  /******/ 									" in " +
  /******/ 									result.parentId +
  /******/ 									chainInfo
  /******/ 							);
  /******/ 						break;
  /******/ 					case "unaccepted":
  /******/ 						if (options.onUnaccepted) options.onUnaccepted(result);
  /******/ 						if (!options.ignoreUnaccepted)
  /******/ 							abortError = new Error(
  /******/ 								"Aborted because " + moduleId + " is not accepted" + chainInfo
  /******/ 							);
  /******/ 						break;
  /******/ 					case "accepted":
  /******/ 						if (options.onAccepted) options.onAccepted(result);
  /******/ 						doApply = true;
  /******/ 						break;
  /******/ 					case "disposed":
  /******/ 						if (options.onDisposed) options.onDisposed(result);
  /******/ 						doDispose = true;
  /******/ 						break;
  /******/ 					default:
  /******/ 						throw new Error("Unexception type " + result.type);
  /******/ 				}
  /******/ 				if (abortError) {
  /******/ 					hotSetStatus("abort");
  /******/ 					return Promise.reject(abortError);
  /******/ 				}
  /******/ 				if (doApply) {
  /******/ 					appliedUpdate[moduleId] = hotUpdate[moduleId];
  /******/ 					addAllToSet(outdatedModules, result.outdatedModules);
  /******/ 					for (moduleId in result.outdatedDependencies) {
  /******/ 						if (
  /******/ 							Object.prototype.hasOwnProperty.call(
  /******/ 								result.outdatedDependencies,
  /******/ 								moduleId
  /******/ 							)
  /******/ 						) {
  /******/ 							if (!outdatedDependencies[moduleId])
  /******/ 								outdatedDependencies[moduleId] = [];
  /******/ 							addAllToSet(
  /******/ 								outdatedDependencies[moduleId],
  /******/ 								result.outdatedDependencies[moduleId]
  /******/ 							);
  /******/ 						}
  /******/ 					}
  /******/ 				}
  /******/ 				if (doDispose) {
  /******/ 					addAllToSet(outdatedModules, [result.moduleId]);
  /******/ 					appliedUpdate[moduleId] = warnUnexpectedRequire;
  /******/ 				}
  /******/ 			}
  /******/ 		}
  /******/
  /******/ 		// Store self accepted outdated modules to require them later by the module system
  /******/ 		var outdatedSelfAcceptedModules = [];
  /******/ 		for (i = 0; i < outdatedModules.length; i++) {
  /******/ 			moduleId = outdatedModules[i];
  /******/ 			if (
  /******/ 				installedModules[moduleId] &&
  /******/ 				installedModules[moduleId].hot._selfAccepted &&
  /******/ 				// removed self-accepted modules should not be required
  /******/ 				appliedUpdate[moduleId] !== warnUnexpectedRequire &&
  /******/ 				// when called invalidate self-accepting is not possible
  /******/ 				!installedModules[moduleId].hot._selfInvalidated
  /******/ 			) {
  /******/ 				outdatedSelfAcceptedModules.push({
  /******/ 					module: moduleId,
  /******/ 					parents: installedModules[moduleId].parents.slice(),
  /******/ 					errorHandler: installedModules[moduleId].hot._selfAccepted
  /******/ 				});
  /******/ 			}
  /******/ 		}
  /******/
  /******/ 		// Now in "dispose" phase
  /******/ 		hotSetStatus("dispose");
  /******/ 		Object.keys(hotAvailableFilesMap).forEach(function(chunkId) {
  /******/ 			if (hotAvailableFilesMap[chunkId] === false) {
  /******/ 				hotDisposeChunk(chunkId);
  /******/ 			}
  /******/ 		});
  /******/
  /******/ 		var idx;
  /******/ 		var queue = outdatedModules.slice();
  /******/ 		while (queue.length > 0) {
  /******/ 			moduleId = queue.pop();
  /******/ 			module = installedModules[moduleId];
  /******/ 			if (!module) continue;
  /******/
  /******/ 			var data = {};
  /******/
  /******/ 			// Call dispose handlers
  /******/ 			var disposeHandlers = module.hot._disposeHandlers;
  /******/ 			for (j = 0; j < disposeHandlers.length; j++) {
  /******/ 				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];
  /******/
  /******/ 			// when disposing there is no need to call dispose handler
  /******/ 			delete outdatedDependencies[moduleId];
  /******/
  /******/ 			// remove "parents" references from all children
  /******/ 			for (j = 0; j < module.children.length; j++) {
  /******/ 				var child = installedModules[module.children[j]];
  /******/ 				if (!child) continue;
  /******/ 				idx = child.parents.indexOf(moduleId);
  /******/ 				if (idx >= 0) {
  /******/ 					child.parents.splice(idx, 1);
  /******/ 				}
  /******/ 			}
  /******/ 		}
  /******/
  /******/ 		// remove outdated dependency from module children
  /******/ 		var dependency;
  /******/ 		var moduleOutdatedDependencies;
  /******/ 		for (moduleId in outdatedDependencies) {
  /******/ 			if (
  /******/ 				Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)
  /******/ 			) {
  /******/ 				module = installedModules[moduleId];
  /******/ 				if (module) {
  /******/ 					moduleOutdatedDependencies = outdatedDependencies[moduleId];
  /******/ 					for (j = 0; j < moduleOutdatedDependencies.length; j++) {
  /******/ 						dependency = moduleOutdatedDependencies[j];
  /******/ 						idx = module.children.indexOf(dependency);
  /******/ 						if (idx >= 0) module.children.splice(idx, 1);
  /******/ 					}
  /******/ 				}
  /******/ 			}
  /******/ 		}
  /******/
  /******/ 		// Now in "apply" phase
  /******/ 		hotSetStatus("apply");
  /******/
  /******/ 		if (hotUpdateNewHash !== undefined) {
  /******/ 			hotCurrentHash = hotUpdateNewHash;
  /******/ 			hotUpdateNewHash = undefined;
  /******/ 		}
  /******/ 		hotUpdate = undefined;
  /******/
  /******/ 		// insert new code
  /******/ 		for (moduleId in appliedUpdate) {
  /******/ 			if (Object.prototype.hasOwnProperty.call(appliedUpdate, moduleId)) {
  /******/ 				modules[moduleId] = appliedUpdate[moduleId];
  /******/ 			}
  /******/ 		}
  /******/
  /******/ 		// call accept handlers
  /******/ 		var error = null;
  /******/ 		for (moduleId in outdatedDependencies) {
  /******/ 			if (
  /******/ 				Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)
  /******/ 			) {
  /******/ 				module = installedModules[moduleId];
  /******/ 				if (module) {
  /******/ 					moduleOutdatedDependencies = outdatedDependencies[moduleId];
  /******/ 					var callbacks = [];
  /******/ 					for (i = 0; i < moduleOutdatedDependencies.length; i++) {
  /******/ 						dependency = moduleOutdatedDependencies[i];
  /******/ 						cb = module.hot._acceptedDependencies[dependency];
  /******/ 						if (cb) {
  /******/ 							if (callbacks.indexOf(cb) !== -1) continue;
  /******/ 							callbacks.push(cb);
  /******/ 						}
  /******/ 					}
  /******/ 					for (i = 0; i < callbacks.length; i++) {
  /******/ 						cb = callbacks[i];
  /******/ 						try {
  /******/ 							cb(moduleOutdatedDependencies);
  /******/ 						} catch (err) {
  /******/ 							if (options.onErrored) {
  /******/ 								options.onErrored({
  /******/ 									type: "accept-errored",
  /******/ 									moduleId: moduleId,
  /******/ 									dependencyId: moduleOutdatedDependencies[i],
  /******/ 									error: err
  /******/ 								});
  /******/ 							}
  /******/ 							if (!options.ignoreErrored) {
  /******/ 								if (!error) error = err;
  /******/ 							}
  /******/ 						}
  /******/ 					}
  /******/ 				}
  /******/ 			}
  /******/ 		}
  /******/
  /******/ 		// Load self accepted modules
  /******/ 		for (i = 0; i < outdatedSelfAcceptedModules.length; i++) {
  /******/ 			var item = outdatedSelfAcceptedModules[i];
  /******/ 			moduleId = item.module;
  /******/ 			hotCurrentParents = item.parents;
  /******/ 			hotCurrentChildModule = moduleId;
  /******/ 			try {
  /******/ 				__webpack_require__(moduleId);
  /******/ 			} catch (err) {
  /******/ 				if (typeof item.errorHandler === "function") {
  /******/ 					try {
  /******/ 						item.errorHandler(err);
  /******/ 					} catch (err2) {
  /******/ 						if (options.onErrored) {
  /******/ 							options.onErrored({
  /******/ 								type: "self-accept-error-handler-errored",
  /******/ 								moduleId: moduleId,
  /******/ 								error: err2,
  /******/ 								originalError: err
  /******/ 							});
  /******/ 						}
  /******/ 						if (!options.ignoreErrored) {
  /******/ 							if (!error) error = err2;
  /******/ 						}
  /******/ 						if (!error) error = err;
  /******/ 					}
  /******/ 				} else {
  /******/ 					if (options.onErrored) {
  /******/ 						options.onErrored({
  /******/ 							type: "self-accept-errored",
  /******/ 							moduleId: moduleId,
  /******/ 							error: err
  /******/ 						});
  /******/ 					}
  /******/ 					if (!options.ignoreErrored) {
  /******/ 						if (!error) error = err;
  /******/ 					}
  /******/ 				}
  /******/ 			}
  /******/ 		}
  /******/
  /******/ 		// handle errors in accept handlers and self accepted module load
  /******/ 		if (error) {
  /******/ 			hotSetStatus("fail");
  /******/ 			return Promise.reject(error);
  /******/ 		}
  /******/
  /******/ 		if (hotQueuedInvalidatedModules) {
  /******/ 			return hotApplyInternal(options).then(function(list) {
  /******/ 				outdatedModules.forEach(function(moduleId) {
  /******/ 					if (list.indexOf(moduleId) < 0) list.push(moduleId);
  /******/ 				});
  /******/ 				return list;
  /******/ 			});
  /******/ 		}
  /******/
  /******/ 		hotSetStatus("idle");
  /******/ 		return new Promise(function(resolve) {
  /******/ 			resolve(outdatedModules);
  /******/ 		});
  /******/ 	}
  /******/
  /******/ 	function hotApplyInvalidatedModules() {
  /******/ 		if (hotQueuedInvalidatedModules) {
  /******/ 			if (!hotUpdate) hotUpdate = {};
  /******/ 			hotQueuedInvalidatedModules.forEach(hotApplyInvalidatedModule);
  /******/ 			hotQueuedInvalidatedModules = undefined;
  /******/ 			return true;
  /******/ 		}
  /******/ 	}
  /******/
  /******/ 	function hotApplyInvalidatedModule(moduleId) {
  /******/ 		if (!Object.prototype.hasOwnProperty.call(hotUpdate, moduleId))
  /******/ 			hotUpdate[moduleId] = modules[moduleId];
  /******/ 	}
  /******/
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {},
  /******/ 			hot: hotCreateModule(moduleId),
  /******/ 			parents: (hotCurrentParentsTemp = hotCurrentParents, hotCurrentParents = [], hotCurrentParentsTemp),
  /******/ 			children: []
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, hotCreateRequire(moduleId));
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// __webpack_hash__
  /******/ 	__webpack_require__.h = function() { return hotCurrentHash; };
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return hotCreateRequire(0)(__webpack_require__.s = 0);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js":
  /*!**********************************************************************!*\
    !*** ./node_modules/@babel/runtime/helpers/interopRequireDefault.js ***!
    \**********************************************************************/
  /*! no static exports found */
  /***/ (function(module, exports) {
  
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      "default": obj
    };
  }
  
  module.exports = _interopRequireDefault;
  
  /***/ }),
  
  /***/ "./node_modules/gatsby-plugin-netlify-cms/cms-identity.js":
  /*!****************************************************************!*\
    !*** ./node_modules/gatsby-plugin-netlify-cms/cms-identity.js ***!
    \****************************************************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(module, setImmediate) {
  
  (function () {
    var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
    enterModule && enterModule(module);
  })();
  
  var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
    return a;
  };
  
  var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
  
  var _netlifyIdentityWidget = _interopRequireDefault(__webpack_require__(/*! netlify-identity-widget */ "netlify-identity-widget"));
  /* global __PATH_PREFIX__ CMS_PUBLIC_PATH */
  
  
  window.netlifyIdentity = _netlifyIdentityWidget.default;
  
  var addLoginListener = function addLoginListener() {
    return _netlifyIdentityWidget.default.on("login", function () {
      document.location.href = "" + "/" + "admin" + "/";
    });
  };
  
  _netlifyIdentityWidget.default.on("init", function (user) {
    if (!user) {
      addLoginListener();
    } else {
      _netlifyIdentityWidget.default.on("logout", function () {
        addLoginListener();
      });
    }
  }); // Boot on next tick to prevent clashes with css injected into NetlifyCMS
  // preview pane.
  
  
  setImmediate(function () {
    _netlifyIdentityWidget.default.init();
  });
  ;
  
  (function () {
    var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
  
    if (!reactHotLoader) {
      return;
    }
  
    reactHotLoader.register(_netlifyIdentityWidget, "_netlifyIdentityWidget", "C:\\Users\\gianl\\OneDrive\\\xC1rea de Trabalho\\projects\\My-personal-blog\\node_modules\\gatsby-plugin-netlify-cms\\cms-identity.js");
    reactHotLoader.register(addLoginListener, "addLoginListener", "C:\\Users\\gianl\\OneDrive\\\xC1rea de Trabalho\\projects\\My-personal-blog\\node_modules\\gatsby-plugin-netlify-cms\\cms-identity.js");
  })();
  
  ;
  
  (function () {
    var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
    leaveModule && leaveModule(module);
  })();
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/module.js */ "./node_modules/webpack/buildin/module.js")(module), __webpack_require__(/*! ./../timers-browserify/main.js */ "./node_modules/timers-browserify/main.js").setImmediate))
  
  /***/ }),
  
  /***/ "./node_modules/gatsby-plugin-netlify-cms/cms.js":
  /*!*******************************************************!*\
    !*** ./node_modules/gatsby-plugin-netlify-cms/cms.js ***!
    \*******************************************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(module) {
  
  (function () {
    var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
    enterModule && enterModule(module);
  })();
  
  var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
    return a;
  };
  
  var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
  
  var _netlifyCmsApp = _interopRequireDefault(__webpack_require__(/*! netlify-cms-app */ "netlify-cms-app"));
  
  var _emitter = _interopRequireDefault(__webpack_require__(/*! gatsby/cache-dir/emitter */ "./node_modules/gatsby/cache-dir/emitter.js")); // set global variables required by Gatsby's components
  // https://github.com/gatsbyjs/gatsby/blob/deb41cdfefbefe0c170b5dd7c10a19ba2b338f6e/docs/docs/production-app.md#window-variables
  // some Gatsby components require these global variables set here:
  // https://github.com/gatsbyjs/gatsby/blob/deb41cdfefbefe0c170b5dd7c10a19ba2b338f6e/packages/gatsby/cache-dir/production-app.js#L28
  
  
  window.___emitter = _emitter.default;
  window.___loader = {
    enqueue: function enqueue() {},
    hovering: function hovering() {}
  };
  /**
   * Load Netlify CMS automatically if `window.CMS_MANUAL_INIT` is set.
   */
  // eslint-disable-next-line no-undef
  
  if (true) {
    _netlifyCmsApp.default.init();
  } else {}
  /**
   * The stylesheet output from the modules at `modulePath` will be at `cms.css`.
   */
  
  
  _netlifyCmsApp.default.registerPreviewStyle("cms.css");
  
  ;
  
  (function () {
    var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
  
    if (!reactHotLoader) {
      return;
    }
  
    reactHotLoader.register(_netlifyCmsApp, "_netlifyCmsApp", "C:\\Users\\gianl\\OneDrive\\\xC1rea de Trabalho\\projects\\My-personal-blog\\node_modules\\gatsby-plugin-netlify-cms\\cms.js");
    reactHotLoader.register(_emitter, "_emitter", "C:\\Users\\gianl\\OneDrive\\\xC1rea de Trabalho\\projects\\My-personal-blog\\node_modules\\gatsby-plugin-netlify-cms\\cms.js");
  })();
  
  ;
  
  (function () {
    var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
    leaveModule && leaveModule(module);
  })();
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/module.js */ "./node_modules/webpack/buildin/module.js")(module)))
  
  /***/ }),
  
  /***/ "./node_modules/gatsby/cache-dir/emitter.js":
  /*!**************************************************!*\
    !*** ./node_modules/gatsby/cache-dir/emitter.js ***!
    \**************************************************/
  /*! exports provided: default */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  /* harmony import */ var mitt__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! mitt */ "./node_modules/mitt/dist/mitt.es.js");
  
  
  const emitter = Object(mitt__WEBPACK_IMPORTED_MODULE_0__["default"])()
  /* harmony default export */ __webpack_exports__["default"] = (emitter);
  
  
  /***/ }),
  
  /***/ "./node_modules/mitt/dist/mitt.es.js":
  /*!*******************************************!*\
    !*** ./node_modules/mitt/dist/mitt.es.js ***!
    \*******************************************/
  /*! exports provided: default */
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  //      
  // An event handler can take an optional event argument
  // and should not return a value
                                            
                                                                 
  
  // An array of all currently registered event handlers for a type
                                              
                                                              
  // A map of event types and their corresponding event handlers.
                          
                                   
                                     
    
  
  /** Mitt: Tiny (~200b) functional event emitter / pubsub.
   *  @name mitt
   *  @returns {Mitt}
   */
  function mitt(all                 ) {
  	all = all || Object.create(null);
  
  	return {
  		/**
  		 * Register an event handler for the given type.
  		 *
  		 * @param  {String} type	Type of event to listen for, or `"*"` for all events
  		 * @param  {Function} handler Function to call in response to given event
  		 * @memberOf mitt
  		 */
  		on: function on(type        , handler              ) {
  			(all[type] || (all[type] = [])).push(handler);
  		},
  
  		/**
  		 * Remove an event handler for the given type.
  		 *
  		 * @param  {String} type	Type of event to unregister `handler` from, or `"*"`
  		 * @param  {Function} handler Handler function to remove
  		 * @memberOf mitt
  		 */
  		off: function off(type        , handler              ) {
  			if (all[type]) {
  				all[type].splice(all[type].indexOf(handler) >>> 0, 1);
  			}
  		},
  
  		/**
  		 * Invoke all handlers for the given type.
  		 * If present, `"*"` handlers are invoked after type-matched handlers.
  		 *
  		 * @param {String} type  The event type to invoke
  		 * @param {Any} [evt]  Any value (object is recommended and powerful), passed to each handler
  		 * @memberOf mitt
  		 */
  		emit: function emit(type        , evt     ) {
  			(all[type] || []).slice().map(function (handler) { handler(evt); });
  			(all['*'] || []).slice().map(function (handler) { handler(type, evt); });
  		}
  	};
  }
  
  /* harmony default export */ __webpack_exports__["default"] = (mitt);
  //# sourceMappingURL=mitt.es.js.map
  
  
  /***/ }),
  
  /***/ "./node_modules/process/browser.js":
  /*!*****************************************!*\
    !*** ./node_modules/process/browser.js ***!
    \*****************************************/
  /*! no static exports found */
  /***/ (function(module, exports) {
  
  // shim for using process in browser
  var process = module.exports = {};
  
  // cached from whatever global is present so that test runners that stub it
  // don't break things.  But we need to wrap it in a try catch in case it is
  // wrapped in strict mode code which doesn't define any globals.  It's inside a
  // function because try/catches deoptimize in certain engines.
  
  var cachedSetTimeout;
  var cachedClearTimeout;
  
  function defaultSetTimout() {
      throw new Error('setTimeout has not been defined');
  }
  function defaultClearTimeout () {
      throw new Error('clearTimeout has not been defined');
  }
  (function () {
      try {
          if (typeof setTimeout === 'function') {
              cachedSetTimeout = setTimeout;
          } else {
              cachedSetTimeout = defaultSetTimout;
          }
      } catch (e) {
          cachedSetTimeout = defaultSetTimout;
      }
      try {
          if (typeof clearTimeout === 'function') {
              cachedClearTimeout = clearTimeout;
          } else {
              cachedClearTimeout = defaultClearTimeout;
          }
      } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
      }
  } ())
  function runTimeout(fun) {
      if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
      }
      // if setTimeout wasn't available but was latter defined
      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
      } catch(e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
              return cachedSetTimeout.call(null, fun, 0);
          } catch(e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
              return cachedSetTimeout.call(this, fun, 0);
          }
      }
  
  
  }
  function runClearTimeout(marker) {
      if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
      }
      // if clearTimeout wasn't available but was latter defined
      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
      } catch (e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
              return cachedClearTimeout.call(null, marker);
          } catch (e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
              // Some versions of I.E. have different rules for clearTimeout vs setTimeout
              return cachedClearTimeout.call(this, marker);
          }
      }
  
  
  
  }
  var queue = [];
  var draining = false;
  var currentQueue;
  var queueIndex = -1;
  
  function cleanUpNextTick() {
      if (!draining || !currentQueue) {
          return;
      }
      draining = false;
      if (currentQueue.length) {
          queue = currentQueue.concat(queue);
      } else {
          queueIndex = -1;
      }
      if (queue.length) {
          drainQueue();
      }
  }
  
  function drainQueue() {
      if (draining) {
          return;
      }
      var timeout = runTimeout(cleanUpNextTick);
      draining = true;
  
      var len = queue.length;
      while(len) {
          currentQueue = queue;
          queue = [];
          while (++queueIndex < len) {
              if (currentQueue) {
                  currentQueue[queueIndex].run();
              }
          }
          queueIndex = -1;
          len = queue.length;
      }
      currentQueue = null;
      draining = false;
      runClearTimeout(timeout);
  }
  
  process.nextTick = function (fun) {
      var args = new Array(arguments.length - 1);
      if (arguments.length > 1) {
          for (var i = 1; i < arguments.length; i++) {
              args[i - 1] = arguments[i];
          }
      }
      queue.push(new Item(fun, args));
      if (queue.length === 1 && !draining) {
          runTimeout(drainQueue);
      }
  };
  
  // v8 likes predictible objects
  function Item(fun, array) {
      this.fun = fun;
      this.array = array;
  }
  Item.prototype.run = function () {
      this.fun.apply(null, this.array);
  };
  process.title = 'browser';
  process.browser = true;
  process.env = {};
  process.argv = [];
  process.version = ''; // empty string to avoid regexp issues
  process.versions = {};
  
  function noop() {}
  
  process.on = noop;
  process.addListener = noop;
  process.once = noop;
  process.off = noop;
  process.removeListener = noop;
  process.removeAllListeners = noop;
  process.emit = noop;
  process.prependListener = noop;
  process.prependOnceListener = noop;
  
  process.listeners = function (name) { return [] }
  
  process.binding = function (name) {
      throw new Error('process.binding is not supported');
  };
  
  process.cwd = function () { return '/' };
  process.chdir = function (dir) {
      throw new Error('process.chdir is not supported');
  };
  process.umask = function() { return 0; };
  
  
  /***/ }),
  
  /***/ "./node_modules/setimmediate/setImmediate.js":
  /*!***************************************************!*\
    !*** ./node_modules/setimmediate/setImmediate.js ***!
    \***************************************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  /* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {
      "use strict";
  
      if (global.setImmediate) {
          return;
      }
  
      var nextHandle = 1; // Spec says greater than zero
      var tasksByHandle = {};
      var currentlyRunningATask = false;
      var doc = global.document;
      var registerImmediate;
  
      function setImmediate(callback) {
        // Callback can either be a function or a string
        if (typeof callback !== "function") {
          callback = new Function("" + callback);
        }
        // Copy function arguments
        var args = new Array(arguments.length - 1);
        for (var i = 0; i < args.length; i++) {
            args[i] = arguments[i + 1];
        }
        // Store and register the task
        var task = { callback: callback, args: args };
        tasksByHandle[nextHandle] = task;
        registerImmediate(nextHandle);
        return nextHandle++;
      }
  
      function clearImmediate(handle) {
          delete tasksByHandle[handle];
      }
  
      function run(task) {
          var callback = task.callback;
          var args = task.args;
          switch (args.length) {
          case 0:
              callback();
              break;
          case 1:
              callback(args[0]);
              break;
          case 2:
              callback(args[0], args[1]);
              break;
          case 3:
              callback(args[0], args[1], args[2]);
              break;
          default:
              callback.apply(undefined, args);
              break;
          }
      }
  
      function runIfPresent(handle) {
          // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
          // So if we're currently running a task, we'll need to delay this invocation.
          if (currentlyRunningATask) {
              // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
              // "too much recursion" error.
              setTimeout(runIfPresent, 0, handle);
          } else {
              var task = tasksByHandle[handle];
              if (task) {
                  currentlyRunningATask = true;
                  try {
                      run(task);
                  } finally {
                      clearImmediate(handle);
                      currentlyRunningATask = false;
                  }
              }
          }
      }
  
      function installNextTickImplementation() {
          registerImmediate = function(handle) {
              process.nextTick(function () { runIfPresent(handle); });
          };
      }
  
      function canUsePostMessage() {
          // The test against `importScripts` prevents this implementation from being installed inside a web worker,
          // where `global.postMessage` means something completely different and can't be used for this purpose.
          if (global.postMessage && !global.importScripts) {
              var postMessageIsAsynchronous = true;
              var oldOnMessage = global.onmessage;
              global.onmessage = function() {
                  postMessageIsAsynchronous = false;
              };
              global.postMessage("", "*");
              global.onmessage = oldOnMessage;
              return postMessageIsAsynchronous;
          }
      }
  
      function installPostMessageImplementation() {
          // Installs an event handler on `global` for the `message` event: see
          // * https://developer.mozilla.org/en/DOM/window.postMessage
          // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
  
          var messagePrefix = "setImmediate$" + Math.random() + "$";
          var onGlobalMessage = function(event) {
              if (event.source === global &&
                  typeof event.data === "string" &&
                  event.data.indexOf(messagePrefix) === 0) {
                  runIfPresent(+event.data.slice(messagePrefix.length));
              }
          };
  
          if (global.addEventListener) {
              global.addEventListener("message", onGlobalMessage, false);
          } else {
              global.attachEvent("onmessage", onGlobalMessage);
          }
  
          registerImmediate = function(handle) {
              global.postMessage(messagePrefix + handle, "*");
          };
      }
  
      function installMessageChannelImplementation() {
          var channel = new MessageChannel();
          channel.port1.onmessage = function(event) {
              var handle = event.data;
              runIfPresent(handle);
          };
  
          registerImmediate = function(handle) {
              channel.port2.postMessage(handle);
          };
      }
  
      function installReadyStateChangeImplementation() {
          var html = doc.documentElement;
          registerImmediate = function(handle) {
              // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
              // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
              var script = doc.createElement("script");
              script.onreadystatechange = function () {
                  runIfPresent(handle);
                  script.onreadystatechange = null;
                  html.removeChild(script);
                  script = null;
              };
              html.appendChild(script);
          };
      }
  
      function installSetTimeoutImplementation() {
          registerImmediate = function(handle) {
              setTimeout(runIfPresent, 0, handle);
          };
      }
  
      // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
      var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
      attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
  
      // Don't get fooled by e.g. browserify environments.
      if ({}.toString.call(global.process) === "[object process]") {
          // For Node.js before 0.9
          installNextTickImplementation();
  
      } else if (canUsePostMessage()) {
          // For non-IE10 modern browsers
          installPostMessageImplementation();
  
      } else if (global.MessageChannel) {
          // For web workers, where supported
          installMessageChannelImplementation();
  
      } else if (doc && "onreadystatechange" in doc.createElement("script")) {
          // For IE 6–8
          installReadyStateChangeImplementation();
  
      } else {
          // For older browsers
          installSetTimeoutImplementation();
      }
  
      attachTo.setImmediate = setImmediate;
      attachTo.clearImmediate = clearImmediate;
  }(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self));
  
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"), __webpack_require__(/*! ./../process/browser.js */ "./node_modules/process/browser.js")))
  
  /***/ }),
  
  /***/ "./node_modules/timers-browserify/main.js":
  /*!************************************************!*\
    !*** ./node_modules/timers-browserify/main.js ***!
    \************************************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  /* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) ||
              (typeof self !== "undefined" && self) ||
              window;
  var apply = Function.prototype.apply;
  
  // DOM APIs, for completeness
  
  exports.setTimeout = function() {
    return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
  };
  exports.setInterval = function() {
    return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
  };
  exports.clearTimeout =
  exports.clearInterval = function(timeout) {
    if (timeout) {
      timeout.close();
    }
  };
  
  function Timeout(id, clearFn) {
    this._id = id;
    this._clearFn = clearFn;
  }
  Timeout.prototype.unref = Timeout.prototype.ref = function() {};
  Timeout.prototype.close = function() {
    this._clearFn.call(scope, this._id);
  };
  
  // Does not start the time, just sets up the members needed.
  exports.enroll = function(item, msecs) {
    clearTimeout(item._idleTimeoutId);
    item._idleTimeout = msecs;
  };
  
  exports.unenroll = function(item) {
    clearTimeout(item._idleTimeoutId);
    item._idleTimeout = -1;
  };
  
  exports._unrefActive = exports.active = function(item) {
    clearTimeout(item._idleTimeoutId);
  
    var msecs = item._idleTimeout;
    if (msecs >= 0) {
      item._idleTimeoutId = setTimeout(function onTimeout() {
        if (item._onTimeout)
          item._onTimeout();
      }, msecs);
    }
  };
  
  // setimmediate attaches itself to the global object
  __webpack_require__(/*! setimmediate */ "./node_modules/setimmediate/setImmediate.js");
  // On some exotic environments, it's not clear which object `setimmediate` was
  // able to install onto.  Search each possibility in the same order as the
  // `setimmediate` library.
  exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) ||
                         (typeof global !== "undefined" && global.setImmediate) ||
                         (this && this.setImmediate);
  exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) ||
                           (typeof global !== "undefined" && global.clearImmediate) ||
                           (this && this.clearImmediate);
  
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))
  
  /***/ }),
  
  /***/ "./node_modules/webpack/buildin/global.js":
  /*!***********************************!*\
    !*** (webpack)/buildin/global.js ***!
    \***********************************/
  /*! no static exports found */
  /***/ (function(module, exports) {
  
  var g;
  
  // This works in non-strict mode
  g = (function() {
  	return this;
  })();
  
  try {
  	// This works if eval is allowed (see CSP)
  	g = g || new Function("return this")();
  } catch (e) {
  	// This works if the window reference is available
  	if (typeof window === "object") g = window;
  }
  
  // g can still be undefined, but nothing to do about it...
  // We return undefined, instead of nothing here, so it's
  // easier to handle this case. if(!global) { ...}
  
  module.exports = g;
  
  
  /***/ }),
  
  /***/ "./node_modules/webpack/buildin/module.js":
  /*!***********************************!*\
    !*** (webpack)/buildin/module.js ***!
    \***********************************/
  /*! no static exports found */
  /***/ (function(module, exports) {
  
  module.exports = function(module) {
  	if (!module.webpackPolyfill) {
  		module.deprecate = function() {};
  		module.paths = [];
  		// module.parent = undefined by default
  		if (!module.children) module.children = [];
  		Object.defineProperty(module, "loaded", {
  			enumerable: true,
  			get: function() {
  				return module.l;
  			}
  		});
  		Object.defineProperty(module, "id", {
  			enumerable: true,
  			get: function() {
  				return module.i;
  			}
  		});
  		module.webpackPolyfill = 1;
  	}
  	return module;
  };
  
  
  /***/ }),
  
  /***/ 0:
  /*!**********************************************************************************************************************!*\
    !*** multi ./node_modules/gatsby-plugin-netlify-cms/cms.js ./node_modules/gatsby-plugin-netlify-cms/cms-identity.js ***!
    \**********************************************************************************************************************/
  /*! no static exports found */
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__(/*! C:\Users\gianl\OneDrive\Área de Trabalho\projects\My-personal-blog\node_modules\gatsby-plugin-netlify-cms\cms.js */"./node_modules/gatsby-plugin-netlify-cms/cms.js");
  module.exports = __webpack_require__(/*! C:\Users\gianl\OneDrive\Área de Trabalho\projects\My-personal-blog\node_modules\gatsby-plugin-netlify-cms\cms-identity.js */"./node_modules/gatsby-plugin-netlify-cms/cms-identity.js");
  
  
  /***/ }),
  
  /***/ "netlify-cms-app":
  /*!********************************!*\
    !*** external "NetlifyCmsApp" ***!
    \********************************/
  /*! no static exports found */
  /***/ (function(module, exports) {
  
  module.exports = NetlifyCmsApp;
  
  /***/ }),
  
  /***/ "netlify-identity-widget":
  /*!**********************************!*\
    !*** external "netlifyIdentity" ***!
    \**********************************/
  /*! no static exports found */
  /***/ (function(module, exports) {
  
  module.exports = netlifyIdentity;
  
  /***/ })
  
  /******/ });
  //# sourceMappingURL=cms.js.map