{“ast”:null,“code”:“function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }nn/n loglevel - github.com/pimterry/logleveln*n* Copyright © 2013 Tim Perryn* Licensed under the MIT license.n*/n(function (root, definition) {n "use strict";nn if (typeof define === 'function' && define.amd) {n define(definition);n } else if ((typeof module === "undefined" ? "undefined" : _typeof(module)) === 'object' && module.exports) {n module.exports = definition();n } else {n root.log = definition();n }n})(this, function () {n "use strict"; // Slightly dubious tricks to cut down minimized file sizenn var noop = function noop() {};nn var undefinedType = "undefined";n var logMethods = ["trace", "debug", "info", "warn", "error"]; // Cross-browser bind equivalent that works at least back to IE6nn function bindMethod(obj, methodName) {n var method = obj;nn if (typeof method.bind === 'function') {n return method.bind(obj);n } else {n try {n return Function.prototype.bind.call(method, obj);n } catch (e) {n // Missing bind shim or IE8 + Modernizr, fallback to wrappingn return function () {n return Function.prototype.apply.apply(method, [obj, arguments]);n };n }n }n } // Build the best logging method possible for this envn // Wherever possible we want to bind, not wrap, to preserve stack tracesnnn function realMethod(methodName) {n if (methodName === 'debug') {n methodName = 'log';n }nn if ((typeof console === "undefined" ? "undefined" : _typeof(console)) === undefinedType) {n return false; // No method possible, for now - fixed later by enableLoggingWhenConsoleArrivesn } else if (console !== undefined) {n return bindMethod(console, methodName);n } else if (console.log !== undefined) {n return bindMethod(console, 'log');n } else {n return noop;n }n } // These private functions always need `this` to be set properlynnn function replaceLoggingMethods(level, loggerName) {n /*jshint validthis:true */n for (var i = 0; i < logMethods.length; i++) {n var methodName = logMethods;n this = i < level ? noop : this.methodFactory(methodName, level, loggerName);n } // Define log.log as an alias for log.debugnnn this.log = this.debug;n } // In old IE versions, the console isn't present until you first open it.n // We build realMethod() replacements here that regenerate logging methodsnnn function enableLoggingWhenConsoleArrives(methodName, level, loggerName) {n return function () {n if ((typeof console === "undefined" ? "undefined" : _typeof(console)) !== undefinedType) {n replaceLoggingMethods.call(this, level, loggerName);n this.apply(this, arguments);n }n };n } // By default, we use closely bound real methods wherever possible, andn // otherwise we wait for a console to appear, and then try again.nnn function defaultMethodFactory(methodName, level, loggerName) {n /*jshint validthis:true */n return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);n }nn function Logger(name, defaultLevel, factory) {n var self = this;n var currentLevel;n var storageKey = "loglevel";nn if (name) {n storageKey += ":" + name;n }nn function persistLevelIfPossible(levelNum) {n var levelName = (logMethods || 'silent').toUpperCase();n if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === undefinedType) return; // Use localStorage if availablenn try {n window.localStorage = levelName;n return;n } catch (ignore) {} // Use session cookie as fallbacknnn try {n window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";n } catch (ignore) {}n }nn function getPersistedLevel() {n var storedLevel;n if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === undefinedType) return;nn try {n storedLevel = window.localStorage;n } catch (ignore) {} // Fallback to cookies if local storage gives us nothingnnn if (_typeof(storedLevel) === undefinedType) {n try {n var cookie = window.document.cookie;n var location = cookie.indexOf(encodeURIComponent(storageKey) + "=");nn if (location !== -1) {n storedLevel = /^([^;]+)/.exec(cookie.slice(location))[1];n }n } catch (ignore) {}n } // If the stored level is not valid, treat it as if nothing was stored.nnn if (self.levels === undefined) {n storedLevel = undefined;n }nn return storedLevel;n }n /*n *n * Public logger API - see github.com/pimterry/loglevel for detailsn *n */nnn self.name = name;n self.levels = {n "TRACE": 0,n "DEBUG": 1,n "INFO": 2,n "WARN": 3,n "ERROR": 4,n "SILENT": 5n };n self.methodFactory = factory || defaultMethodFactory;nn self.getLevel = function () {n return currentLevel;n };nn self.setLevel = function (level, persist) {n if (typeof level === "string" && self.levels !== undefined) {n level = self.levels;n }nn if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {n currentLevel = level;nn if (persist !== false) {n // defaults to truen persistLevelIfPossible(level);n }nn replaceLoggingMethods.call(self, level, name);nn if ((typeof console === "undefined" ? "undefined" : _typeof(console)) === undefinedType && level < self.levels.SILENT) {n return "No console available for logging";n }n } else {n throw "log.setLevel() called with invalid level: " + level;n }n };nn self.setDefaultLevel = function (level) {n if (!getPersistedLevel()) {n self.setLevel(level, false);n }n };nn self.enableAll = function (persist) {n self.setLevel(self.levels.TRACE, persist);n };nn self.disableAll = function (persist) {n self.setLevel(self.levels.SILENT, persist);n }; // Initialize with the right levelnnn var initialLevel = getPersistedLevel();nn if (initialLevel == null) {n initialLevel = defaultLevel == null ? "WARN" : defaultLevel;n }nn self.setLevel(initialLevel, false);n }n /*n *n * Top-level APIn *n */nnn var defaultLogger = new Logger();n var _loggersByName = {};nn defaultLogger.getLogger = function getLogger(name) {n if (typeof name !== "string" || name === "") {n throw new TypeError("You must supply a name when creating a logger.");n }nn var logger = _loggersByName;nn if (!logger) {n logger = _loggersByName = new Logger(name, defaultLogger.getLevel(), defaultLogger.methodFactory);n }nn return logger;n }; // Grab the current global log variable in case of overwritennn var _log = (typeof window === "undefined" ? "undefined" : _typeof(window)) !== undefinedType ? window.log : undefined;nn defaultLogger.noConflict = function () {n if ((typeof window === "undefined" ? "undefined" : _typeof(window)) !== undefinedType && window.log === defaultLogger) {n window.log = _log;n }nn return defaultLogger;n };nn defaultLogger.getLoggers = function getLoggers() {n return _loggersByName;n };nn return defaultLogger;n});”,“map”:null,“metadata”:{},“sourceType”:“module”}