☰

强制开启Vue Devtools

为生产构建的Vue2或Vue3应用强制开启Vue Devtools

// ==UserScript==
// @name              Force Enable Vue Devtools
// @version           0.2.3
// @author            Huang-Huang Bao <[email protected]> (https://github.com/EHfive)
// @description       Force enable Vue Devtools for any Vue2 or Vue3 production build.
// @homepage          https://github.com/EHfive/userscripts/tree/master/userscripts/enbale-vue-devtools
// @supportURL        https://github.com/EHfive/userscripts/issues
// @namespace         https://eh5.me
// @name:zh-CN        强制开启Vue Devtools
// @name:zh-TW        強制開啓Vue Devtools
// @description:zh-CN 为生产构建的Vue2或Vue3应用强制开启Vue Devtools
// @description:zh-TW 爲生產構建的Vue2或Vue3應用強制開啓Vue Devtools
// @license           MIT
// @run-at            document-start
// @noframes          
// @include           /^.*$/
// @grant             unsafeWindow
// @grant             GM_info
// @grant             GM.info
// ==/UserScript==

/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 1);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {

/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _vendor_gm4_polyfill_gm4_polyfill_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
/* harmony import */ var _vendor_gm4_polyfill_gm4_polyfill_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_vendor_gm4_polyfill_gm4_polyfill_js__WEBPACK_IMPORTED_MODULE_0__);


(function () {
  if(typeof unsafeWindow === 'object' && unsafeWindow) {
    unsafeWindow.GM = this.GM
  }
}).call(window);


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

/*** IMPORTS FROM imports-loader ***/

(function() {
/*
This helper script bridges compatibility between the Greasemonkey 4 APIs and
existing/legacy APIs.  Say for example your user script includes

    // @grant GM_getValue

And you'd like to be compatible with both Greasemonkey 3 and Greasemonkey 4
(and for that matter all versions of Violentmonkey, Tampermonkey, and any other
user script engine).  Add:

    // @grant GM.getValue
    // @require https://greasemonkey.github.io/gm4-polyfill/gm4-polyfill.js

And switch to the new (GM-dot) APIs, which return promises.  If your script
is running in an engine that does not provide the new asynchronous APIs, this
helper will add them, based on the old APIs.

If you use `await` at the top level, you'll need to wrap your script in an
`async` function to be compatible with any user script engine besides
Greasemonkey 4.

    (async () => {
    let x = await GM.getValue('x');
    })();
*/

if (typeof GM == 'undefined') {
  this.GM = {};
}


if (typeof GM_addStyle == 'undefined') {
  this.GM_addStyle = (aCss) => {
    'use strict';
    let head = document.getElementsByTagName('head')[0];
    if (head) {
      let style = document.createElement('style');
      style.setAttribute('type', 'text/css');
      style.textContent = aCss;
      head.appendChild(style);
      return style;
    }
    return null;
  };
}


if (typeof GM_registerMenuCommand == 'undefined') {
  this.GM_registerMenuCommand = (caption, commandFunc, accessKey) => {
    if (!document.body) {
      if (document.readyState === 'loading'
        && document.documentElement && document.documentElement.localName === 'html') {
        new MutationObserver((mutations, observer) => {
          if (document.body) {
            observer.disconnect();
            GM_registerMenuCommand(caption, commandFunc, accessKey);
          }
        }).observe(document.documentElement, {childList: true});
      } else {
        console.error('GM_registerMenuCommand got no body.');
      }
      return;
    }
    let contextMenu = document.body.getAttribute('contextmenu');
    let menu = (contextMenu ? document.querySelector('menu#' + contextMenu) : null);
    if (!menu) {
      menu = document.createElement('menu');
      menu.setAttribute('id', 'gm-registered-menu');
      menu.setAttribute('type', 'context');
      document.body.appendChild(menu);
      document.body.setAttribute('contextmenu', 'gm-registered-menu');
    }
    let menuItem = document.createElement('menuitem');
    menuItem.textContent = caption;
    menuItem.addEventListener('click', commandFunc, true);
    menu.appendChild(menuItem);
  };
}


if (typeof GM_getResourceText == 'undefined') {
  this.GM_getResourceText = (aRes) => {
    'use strict';
    return GM.getResourceUrl(aRes)
      .then(url => fetch(url))
      .then(resp => resp.text())
      .catch(function(error) {
        GM.log('Request failed', error);
        return null;
      });
  };
}


Object.entries({
  'log': console.log.bind(console),  // Pale Moon compatibility.  See #13.
  'info': GM_info,
}).forEach(([newKey, old]) => {
  if (old && (typeof GM[newKey] == 'undefined')) {
    GM[newKey] = old;
  }
});


Object.entries({
  'GM_addStyle': 'addStyle',
  'GM_deleteValue': 'deleteValue',
  'GM_getResourceURL': 'getResourceUrl',
  'GM_getValue': 'getValue',
  'GM_listValues': 'listValues',
  'GM_notification': 'notification',
  'GM_openInTab': 'openInTab',
  'GM_registerMenuCommand': 'registerMenuCommand',
  'GM_setClipboard': 'setClipboard',
  'GM_setValue': 'setValue',
  'GM_xmlhttpRequest': 'xmlHttpRequest',
  'GM_getResourceText': 'getResourceText',
}).forEach(([oldKey, newKey]) => {
  let old = this[oldKey];
  if (old && (typeof GM[newKey] == 'undefined')) {
    GM[newKey] = function(...args) {
      return new Promise((resolve, reject) => {
        try {
          resolve(old.apply(this, args));
        } catch (e) {
          reject(e);
        }
      });
    };
  }
});

}.call(window));


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

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

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXTERNAL MODULE: /home/eh5/Projects/userscripts/packages/polyfills/dist/index.js
var dist = __webpack_require__(0);

// CONCATENATED MODULE: /home/eh5/Projects/userscripts/.yarn/cache/consola-npm-2.15.0-71e35f623c-9a20844425.zip/node_modules/consola/src/logLevels.js
const LogLevel = {};
LogLevel[LogLevel.Fatal = 0] = 'Fatal';
LogLevel[LogLevel.Error = 0] = 'Error';
LogLevel[LogLevel.Warn = 1] = 'Warn';
LogLevel[LogLevel.Log = 2] = 'Log';
LogLevel[LogLevel.Info = 3] = 'Info';
LogLevel[LogLevel.Success = 3] = 'Success';
LogLevel[LogLevel.Debug = 4] = 'Debug';
LogLevel[LogLevel.Trace = 5] = 'Trace';
LogLevel[LogLevel.Silent = -Infinity] = 'Silent';
LogLevel[LogLevel.Verbose = Infinity] = 'Verbose';
// CONCATENATED MODULE: /home/eh5/Projects/userscripts/.yarn/cache/consola-npm-2.15.0-71e35f623c-9a20844425.zip/node_modules/consola/src/types.js

/* harmony default export */ var src_types = ({
  // Silent
  silent: {
    level: -1
  },
  // Level 0
  fatal: {
    level: LogLevel.Fatal
  },
  error: {
    level: LogLevel.Error
  },
  // Level 1
  warn: {
    level: LogLevel.Warn
  },
  // Level 2
  log: {
    level: LogLevel.Log
  },
  // Level 3
  info: {
    level: LogLevel.Info
  },
  success: {
    level: LogLevel.Success
  },
  // Level 4
  debug: {
    level: LogLevel.Debug
  },
  // Level 5
  trace: {
    level: LogLevel.Trace
  },
  // Verbose
  verbose: {
    level: LogLevel.Trace
  },
  // Legacy
  ready: {
    level: LogLevel.Info
  },
  start: {
    level: LogLevel.Info
  }
});
// CONCATENATED MODULE: /home/eh5/Projects/userscripts/.yarn/cache/consola-npm-2.15.0-71e35f623c-9a20844425.zip/node_modules/consola/src/utils/index.js
function isPlainObject(obj) {
  return Object.prototype.toString.call(obj) === '[object Object]';
} // TODO: remove for consola@3

function isLogObj(arg) {
  // Should be plain object
  if (!isPlainObject(arg)) {
    return false;
  } // Should contains either 'message' or 'args' field


  if (!arg.message && !arg.args) {
    return false;
  } // Handle non-standard error objects


  if (arg.stack) {
    return false;
  }

  return true;
}
// CONCATENATED MODULE: /home/eh5/Projects/userscripts/.yarn/cache/consola-npm-2.15.0-71e35f623c-9a20844425.zip/node_modules/consola/src/consola.js


let paused = false;
const queue = [];

class consola_Consola {
  constructor(options = {}) {
    this._reporters = options.reporters || [];
    this._types = options.types || src_types;
    this.level = options.level !== undefined ? options.level : 3;
    this._defaults = options.defaults || {};
    this._async = options.async !== undefined ? options.async : undefined;
    this._stdout = options.stdout;
    this._stderr = options.stderr;
    this._mockFn = options.mockFn;
    this._throttle = options.throttle || 1000;
    this._throttleMin = options.throttleMin || 5; // Create logger functions for current instance

    for (const type in this._types) {
      this[type] = this._wrapLogFn(Object.assign({
        type
      }, this._types[type], this._defaults));
    } // Use _mockFn if is set


    if (this._mockFn) {
      this.mockTypes();
    } // Keep serialized version of last log


    this._lastLogSerialized = undefined;
    this._lastLog = undefined;
    this._lastLogTime = undefined;
    this._lastLogCount = 0;
    this._throttleTimeout = undefined;
  }

  get stdout() {
    return this._stdout || console._stdout; // eslint-disable-line no-console
  }

  get stderr() {
    return this._stderr || console._stderr; // eslint-disable-line no-console
  }

  create(options) {
    return new consola_Consola(Object.assign({
      reporters: this._reporters,
      level: this.level,
      types: this._types,
      defaults: this._defaults,
      stdout: this._stdout,
      stderr: this._stderr,
      mockFn: this._mockFn
    }, options));
  }

  withDefaults(defaults) {
    return this.create({
      defaults: Object.assign({}, this._defaults, defaults)
    });
  }

  withTag(tag) {
    return this.withDefaults({
      tag: this._defaults.tag ? this._defaults.tag + ':' + tag : tag
    });
  }

  addReporter(reporter) {
    this._reporters.push(reporter);

    return this;
  }

  removeReporter(reporter) {
    if (reporter) {
      const i = this._reporters.indexOf(reporter);

      if (i >= 0) {
        return this._reporters.splice(i, 1);
      }
    } else {
      this._reporters.splice(0);
    }

    return this;
  }

  setReporters(reporters) {
    this._reporters = Array.isArray(reporters) ? reporters : [reporters];
    return this;
  }

  wrapAll() {
    this.wrapConsole();
    this.wrapStd();
  }

  restoreAll() {
    this.restoreConsole();
    this.restoreStd();
  }

  wrapConsole() {
    for (const type in this._types) {
      // Backup original value
      if (!console['__' + type]) {
        // eslint-disable-line no-console
        console['__' + type] = console[type]; // eslint-disable-line no-console
      } // Override


      console[type] = this[type]; // eslint-disable-line no-console
    }
  }

  restoreConsole() {
    for (const type in this._types) {
      // Restore if backup is available
      if (console['__' + type]) {
        // eslint-disable-line no-console
        console[type] = console['__' + type]; // eslint-disable-line no-console

        delete console['__' + type]; // eslint-disable-line no-console
      }
    }
  }

  wrapStd() {
    this._wrapStream(this.stdout, 'log');

    this._wrapStream(this.stderr, 'log');
  }

  _wrapStream(stream, type) {
    if (!stream) {
      return;
    } // Backup original value


    if (!stream.__write) {
      stream.__write = stream.write;
    } // Override


    stream.write = data => {
      this[type](String(data).trim());
    };
  }

  restoreStd() {
    this._restoreStream(this.stdout);

    this._restoreStream(this.stderr);
  }

  _restoreStream(stream) {
    if (!stream) {
      return;
    }

    if (stream.__write) {
      stream.write = stream.__write;
      delete stream.__write;
    }
  }

  pauseLogs() {
    paused = true;
  }

  resumeLogs() {
    paused = false; // Process queue

    const _queue = queue.splice(0);

    for (const item of _queue) {
      item[0]._logFn(item[1], item[2]);
    }
  }

  mockTypes(mockFn) {
    this._mockFn = mockFn || this._mockFn;

    if (typeof this._mockFn !== 'function') {
      return;
    }

    for (const type in this._types) {
      this[type] = this._mockFn(type, this._types[type]) || this[type];
    }
  }

  _wrapLogFn(defaults) {
    function logFn() {
      if (paused) {
        queue.push([this, defaults, arguments]);
        return;
      }

      return this._logFn(defaults, arguments);
    }

    return logFn.bind(this);
  }

  _logFn(defaults, args) {
    if (defaults.level > this.level) {
      return this._async ? Promise.resolve(false) : false;
    } // Construct a new log object


    const logObj = Object.assign({
      date: new Date(),
      args: []
    }, defaults); // Consume arguments

    if (args.length === 1 && isLogObj(args[0])) {
      Object.assign(logObj, args[0]);
    } else {
      logObj.args = Array.from(args);
    } // Aliases


    if (logObj.message) {
      logObj.args.unshift(logObj.message);
      delete logObj.message;
    }

    if (logObj.additional) {
      if (!Array.isArray(logObj.additional)) {
        logObj.additional = logObj.additional.split('\n');
      }

      logObj.args.push('\n' + logObj.additional.join('\n'));
      delete logObj.additional;
    } // Normalize type and tag to lowercase


    logObj.type = typeof logObj.type === 'string' ? logObj.type.toLowerCase() : '';
    logObj.tag = typeof logObj.tag === 'string' ? logObj.tag.toLowerCase() : ''; // Resolve log

    /**
     * @param newLog false if the throttle expired and
     *  we don't want to log a duplicate
     */

    const resolveLog = (newLog = false) => {
      const repeated = this._lastLogCount - this._throttleMin;

      if (this._lastLog && repeated > 0) {
        const args = [...this._lastLog.args];

        if (repeated > 1) {
          args.push(`(repeated ${repeated} times)`);
        }

        this._log({ ...this._lastLog,
          args
        });

        this._lastLogCount = 1;
      } // Log


      if (newLog) {
        this._lastLog = logObj;

        if (this._async) {
          return this._logAsync(logObj);
        } else {
          this._log(logObj);
        }
      }
    }; // Throttle


    clearTimeout(this._throttleTimeout);
    const diffTime = this._lastLogTime ? logObj.date - this._lastLogTime : 0;
    this._lastLogTime = logObj.date;

    if (diffTime < this._throttle) {
      try {
        const serializedLog = JSON.stringify([logObj.type, logObj.tag, logObj.args]);
        const isSameLog = this._lastLogSerialized === serializedLog;
        this._lastLogSerialized = serializedLog;

        if (isSameLog) {
          this._lastLogCount++;

          if (this._lastLogCount > this._throttleMin) {
            // Auto-resolve when throttle is timed out
            this._throttleTimeout = setTimeout(resolveLog, this._throttle);
            return; // SPAM!
          }
        }
      } catch (_) {// Circular References
      }
    }

    resolveLog(true);
  }

  _log(logObj) {
    for (const reporter of this._reporters) {
      reporter.log(logObj, {
        async: false,
        stdout: this.stdout,
        stderr: this.stderr
      });
    }
  }

  _logAsync(logObj) {
    return Promise.all(this._reporters.map(reporter => reporter.log(logObj, {
      async: true,
      stdout: this.stdout,
      stderr: this.stderr
    })));
  }

} // Legacy support


consola_Consola.prototype.add = consola_Consola.prototype.addReporter;
consola_Consola.prototype.remove = consola_Consola.prototype.removeReporter;
consola_Consola.prototype.clear = consola_Consola.prototype.removeReporter;
consola_Consola.prototype.withScope = consola_Consola.prototype.withTag;
consola_Consola.prototype.mock = consola_Consola.prototype.mockTypes;
consola_Consola.prototype.pause = consola_Consola.prototype.pauseLogs;
consola_Consola.prototype.resume = consola_Consola.prototype.resumeLogs; // Export class

/* harmony default export */ var consola = (consola_Consola);
// CONCATENATED MODULE: /home/eh5/Projects/userscripts/.yarn/cache/consola-npm-2.15.0-71e35f623c-9a20844425.zip/node_modules/consola/src/reporters/browser.js
class BrowserReporter {
  constructor(options) {
    this.options = Object.assign({}, options);
    this.defaultColor = '#7f8c8d'; // Gray

    this.levelColorMap = {
      0: '#c0392b',
      // Red
      1: '#f39c12',
      // Yellow
      3: '#00BCD4' // Cyan

    };
    this.typeColorMap = {
      success: '#2ecc71' // Green

    };
  }

  log(logObj) {
    const consoleLogFn = logObj.level < 1 // eslint-disable-next-line no-console
    ? console.__error || console.error : // eslint-disable-next-line no-console
    logObj.level === 1 && console.warn ? console.__warn || console.warn : console.__log || console.log; // Type

    const type = logObj.type !== 'log' ? logObj.type : ''; // Tag

    const tag = logObj.tag ? logObj.tag : ''; // Styles

    const color = this.typeColorMap[logObj.type] || this.levelColorMap[logObj.level] || this.defaultColor;
    const style = `
      background: ${color};
      border-radius: 0.5em;
      color: white;
      font-weight: bold;
      padding: 2px 0.5em;
    `;
    const badge = `%c${[tag, type].filter(Boolean).join(':')}`; // Log to the console

    if (typeof logObj.args[0] === 'string') {
      consoleLogFn(`${badge}%c ${logObj.args[0]}`, style, // Empty string as style resets to default console style
      '', ...logObj.args.slice(1));
    } else {
      consoleLogFn(badge, style, ...logObj.args);
    }
  }

}
// CONCATENATED MODULE: ./src/logger.js


const pkgName = "enable-vue-devtools";
const logger = new consola({
  reporters: [new BrowserReporter()],
  defaults: {
    tag: pkgName
  }
});
/* harmony default export */ var src_logger = (logger);
// CONCATENATED MODULE: ./src/main.js
/* harmony default export */ var main = (main_main);


const _global = typeof unsafeWindow === 'object' && unsafeWindow || globalThis; // devtool hook should be ready when <body> exists


const _devtoolHook = _global.__VUE_DEVTOOLS_GLOBAL_HOOK__;

function main_main() {
  if (!_devtoolHook) {
    src_logger.warn('No Vue Devtools hook found', _global.location);
    return;
  }

  observeVueRoot(function (app, disconnect) {
    emitDevtoolVue2Hooks(app);
  }, function (app, disconnect) {
    emitDevtoolVue3Hooks(app);
  });
}

function emitDevtoolVue2Hooks(app) {
  let Vue = app.constructor;
  const store = app.$store;

  while (Vue.super) {
    // find base Vue
    Vue = Vue.super;
  }

  Vue.config.devtools = true;
  src_logger.info('enabling devtools for Vue instance', app); // must re-emit 'init' if this Vue is different with other Vue(s)
  // otherwise this `Vue`'s root instance would not be added to Devtools store
  // https://github.com/vuejs/vue-devtools/blob/933063fd06860464be4bfd8c83ba09d7fc2c753e/packages/app-backend/src/index.js#L218-L225

  _devtoolHook.emit('init', Vue); // TODO validate Vuex instance


  if (store) {
    src_logger.info('enabling devtools for Vuex instance', store);
    devtoolStorePlugin(store, _devtoolHook);
  }
}

function emitDevtoolVue3Hooks(app) {
  if (!Array.isArray(_devtoolHook.apps)) return;
  if (_devtoolHook.apps.includes(app)) return;
  let version = app.version;

  if (!version) {
    src_logger.warn('no Vue version detected, fallback to "3.0.0"');
    version = '3.0.0';
  }

  src_logger.info('enabling devtools for Vue 3 instance', app); // FIXME: impossible to get those Symbols,
  // https://github.com/vuejs/vue-next/blob/410e7abbbb78e83989ad2e5a1793c290129dfdc7/packages/runtime-core/src/devtools.ts#L38

  const types = {
    Fragment: undefined,
    Text: undefined,
    Comment: undefined,
    Static: undefined
  };

  _devtoolHook.emit('app:init', app, version, types);

  const unmount = app.unmount.bind(app);

  app.unmount = function () {
    _devtoolHook.emit('app:unmount', app);

    unmount();
  };
}

function checkVue2Instance(target) {
  const vue = target && target.__vue__;
  return !!(vue && typeof vue === 'object' && vue._isVue && typeof vue.constructor === 'function');
}

function checkVue3Instance(target) {
  const app = target && target.__vue_app__;
  return !!app;
}

function noop() {}

function observeVueRoot(callbackVue2, callbackVue3) {
  if (typeof callbackVue2 !== 'function') {
    callbackVue2 = noop;
  }

  if (typeof callbackVue3 !== 'function') {
    callbackVue3 = noop;
  }

  const vue2RootSet = new WeakSet();
  const vue3RootSet = new WeakSet();
  const observer = new MutationObserver((mutations, observer) => {
    const disconnect = observer.disconnect.bind(observer);

    for (const {
      target
    } of mutations) {
      if (!target) {
        return;
      } else if (checkVue2Instance(target)) {
        const inst = target.__vue__;
        const root = inst.$parent ? inst.$root : inst;

        if (vue2RootSet.has(root)) {
          // already callback, continue loop
          continue;
        }

        vue2RootSet.add(root);
        callbackVue2(root, disconnect);
      } else if (checkVue3Instance(target)) {
        const app = target.__vue_app__;

        if (vue3RootSet.has(app)) {
          // already callback, continue loop
          continue;
        }

        vue3RootSet.add(app);
        callbackVue3(app, disconnect);
      }
    }
  });
  observer.observe(document.documentElement, {
    attributes: true,
    subtree: true,
    childList: true
  });
  return observer;
}

function devtoolStorePlugin(store, devtoolHook) {
  store._devtoolHook = devtoolHook;
  devtoolHook.emit('vuex:init', store);
  devtoolHook.on('vuex:travel-to-state', targetState => {
    store.replaceState(targetState);
  });
  store.subscribe((mutation, state) => {
    devtoolHook.emit('vuex:mutation', mutation, state);
  });
}
// CONCATENATED MODULE: ./src/index.js




try {
  main();

  if (false) {}
} catch (e) {
  src_logger.error(e);
}

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