<|start_filename|>node_modules/webpackbar/dist/utils/consts.js<|end_filename|>
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CIRCLE_OPEN = exports.CROSS = exports.TICK = exports.BULLET = exports.NEXT = exports.BLOCK_CHAR2 = exports.BLOCK_CHAR = exports.BAR_LENGTH = exports.nodeModules = undefined;

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _figures = require('figures');

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const nodeModules = exports.nodeModules = `${_path2.default.delimiter}node_modules${_path2.default.delimiter}`;
const BAR_LENGTH = exports.BAR_LENGTH = 25;
const BLOCK_CHAR = exports.BLOCK_CHAR = '█';
const BLOCK_CHAR2 = exports.BLOCK_CHAR2 = '█';
const NEXT = exports.NEXT = ' ' + _chalk2.default.blue(_figures.pointerSmall) + ' ';
const BULLET = exports.BULLET = _figures.bullet;
const TICK = exports.TICK = _figures.tick;
const CROSS = exports.CROSS = _figures.cross;
const CIRCLE_OPEN = exports.CIRCLE_OPEN = _figures.radioOff;

<|start_filename|>node_modules/@vuepress/shared-utils/lib/ensureLeadingSlash.js<|end_filename|>
"use strict";
module.exports = function ensureLeadingSlash(path) {
    return path.replace(/^\/?/, '/');
};


<|start_filename|>node_modules/autocomplete.js/src/jquery/plugin.js<|end_filename|>
'use strict';

// setup DOM element
var DOM = require('../common/dom.js');
var $ = require('jquery');
DOM.element = $;

// setup utils functions
var _ = require('../common/utils.js');
_.isArray = $.isArray;
_.isFunction = $.isFunction;
_.isObject = $.isPlainObject;
_.bind = $.proxy;
_.each = function(collection, cb) {
  // stupid argument order for jQuery.each
  $.each(collection, reverseArgs);
  function reverseArgs(index, value) {
    return cb(value, index);
  }
};
_.map = $.map;
_.mixin = $.extend;
_.Event = $.Event;

var Typeahead = require('../autocomplete/typeahead.js');
var EventBus = require('../autocomplete/event_bus.js');

var old;
var typeaheadKey;
var methods;

old = $.fn.autocomplete;

typeaheadKey = 'aaAutocomplete';

methods = {
  // supported signatures:
  // function(o, dataset, dataset, ...)
  // function(o, [dataset, dataset, ...])
  initialize: function initialize(o, datasets) {
    datasets = _.isArray(datasets) ? datasets : [].slice.call(arguments, 1);

    o = o || {};

    return this.each(attach);

    function attach() {
      var $input = $(this);
      var eventBus = new EventBus({el: $input});
      var typeahead;

      typeahead = new Typeahead({
        input: $input,
        eventBus: eventBus,
        dropdownMenuContainer: o.dropdownMenuContainer,
        hint: o.hint === undefined ? true : !!o.hint,
        minLength: o.minLength,
        autoselect: o.autoselect,
        autoselectOnBlur: o.autoselectOnBlur,
        tabAutocomplete: o.tabAutocomplete,
        openOnFocus: o.openOnFocus,
        templates: o.templates,
        debug: o.debug,
        clearOnSelected: o.clearOnSelected,
        cssClasses: o.cssClasses,
        datasets: datasets,
        keyboardShortcuts: o.keyboardShortcuts,
        appendTo: o.appendTo,
        autoWidth: o.autoWidth
      });

      $input.data(typeaheadKey, typeahead);
    }
  },

  open: function open() {
    return this.each(openTypeahead);

    function openTypeahead() {
      var $input = $(this);
      var typeahead;

      if (typeahead = $input.data(typeaheadKey)) {
        typeahead.open();
      }
    }
  },

  close: function close() {
    return this.each(closeTypeahead);

    function closeTypeahead() {
      var $input = $(this);
      var typeahead;

      if (typeahead = $input.data(typeaheadKey)) {
        typeahead.close();
      }
    }
  },

  val: function val(newVal) {
    // mirror jQuery#val functionality: read operate on first match,
    // write operates on all matches
    return !arguments.length ? getVal(this.first()) : this.each(setVal);

    function setVal() {
      var $input = $(this);
      var typeahead;

      if (typeahead = $input.data(typeaheadKey)) {
        typeahead.setVal(newVal);
      }
    }

    function getVal($input) {
      var typeahead;
      var query;

      if (typeahead = $input.data(typeaheadKey)) {
        query = typeahead.getVal();
      }

      return query;
    }
  },

  destroy: function destroy() {
    return this.each(unattach);

    function unattach() {
      var $input = $(this);
      var typeahead;

      if (typeahead = $input.data(typeaheadKey)) {
        typeahead.destroy();
        $input.removeData(typeaheadKey);
      }
    }
  }
};

$.fn.autocomplete = function(method) {
  var tts;

  // methods that should only act on intialized typeaheads
  if (methods[method] && method !== 'initialize') {
    // filter out non-typeahead inputs
    tts = this.filter(function() { return !!$(this).data(typeaheadKey); });
    return methods[method].apply(tts, [].slice.call(arguments, 1));
  }
  return methods.initialize.apply(this, arguments);
};

$.fn.autocomplete.noConflict = function noConflict() {
  $.fn.autocomplete = old;
  return this;
};

$.fn.autocomplete.sources = Typeahead.sources;
$.fn.autocomplete.escapeHighlightedString = _.escapeHighlightedString;

module.exports = $.fn.autocomplete;


<|start_filename|>node_modules/@vuepress/shared-utils/lib/moduleLoader.js<|end_filename|>
"use strict";
// Modified from https://github.com/vuejs/vue-cli/blob/dev/packages/@0vue/cli-shared-utils/lib/module.js
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const semver_1 = __importDefault(require("semver"));
const env_1 = __importDefault(require("./env"));
function resolveFallback(request, options) {
    // eslint-disable-next-line @typescript-eslint/no-var-requires
    const Module = require('module');
    const isMain = false;
    const fakeParent = new Module('', null);
    const paths = [];
    for (let i = 0; i < options.paths.length; i++) {
        const path = (options.paths)[i];
        fakeParent.paths = Module._nodeModulePaths(path);
        const lookupPaths = Module._resolveLookupPaths(request, fakeParent, true);
        if (!paths.includes(path))
            paths.push(path);
        for (let j = 0; j < lookupPaths.length; j++) {
            if (!paths.includes(lookupPaths[j]))
                paths.push(lookupPaths[j]);
        }
    }
    const filename = Module._findPath(request, paths, isMain);
    if (!filename) {
        const err = new Error(`Cannot find module '${request}'`);
        err.code = 'MODULE_NOT_FOUND';
        throw err;
    }
    return filename;
}
function clearRequireCache(id, map = new Map()) {
    const module = require.cache[id];
    if (module) {
        map.set(id, true);
        // Clear children modules
        module.children.forEach((child) => {
            if (!map.get(child.id))
                clearRequireCache(child.id, map);
        });
        delete require.cache[id];
    }
}
const resolve = semver_1.default.satisfies(process.version, '>=10.0.0')
    ? require.resolve
    : resolveFallback;
function resolveModule(request, context) {
    if (env_1.default.isTest) {
        return require.resolve(request);
    }
    // module.paths is for globally install packages.
    const paths = [context || process.cwd(), ...module.paths];
    const resolvedPath = resolve(request, { paths });
    return resolvedPath;
}
exports.resolveModule = resolveModule;
function loadModule(request, context, force = false) {
    const resolvedPath = resolveModule(request, context);
    if (resolvedPath) {
        if (force) {
            clearRequireCache(resolvedPath);
        }
        return require(resolvedPath);
    }
}
exports.loadModule = loadModule;
function clearModule(request, context) {
    const resolvedPath = resolveModule(request, context);
    if (resolvedPath) {
        clearRequireCache(resolvedPath);
    }
}
exports.clearModule = clearModule;


<|start_filename|>node_modules/autocomplete.js/src/autocomplete/dropdown.js<|end_filename|>
'use strict';

var _ = require('../common/utils.js');
var DOM = require('../common/dom.js');
var EventEmitter = require('./event_emitter.js');
var Dataset = require('./dataset.js');
var css = require('./css.js');

// constructor
// -----------

function Dropdown(o) {
  var that = this;
  var onSuggestionClick;
  var onSuggestionMouseEnter;
  var onSuggestionMouseLeave;

  o = o || {};

  if (!o.menu) {
    _.error('menu is required');
  }

  if (!_.isArray(o.datasets) && !_.isObject(o.datasets)) {
    _.error('1 or more datasets required');
  }
  if (!o.datasets) {
    _.error('datasets is required');
  }

  this.isOpen = false;
  this.isEmpty = true;
  this.minLength = o.minLength || 0;
  this.templates = {};
  this.appendTo = o.appendTo || false;
  this.css = _.mixin({}, css, o.appendTo ? css.appendTo : {});
  this.cssClasses = o.cssClasses = _.mixin({}, css.defaultClasses, o.cssClasses || {});
  this.cssClasses.prefix =
    o.cssClasses.formattedPrefix || _.formatPrefix(this.cssClasses.prefix, this.cssClasses.noPrefix);

  // bound functions
  onSuggestionClick = _.bind(this._onSuggestionClick, this);
  onSuggestionMouseEnter = _.bind(this._onSuggestionMouseEnter, this);
  onSuggestionMouseLeave = _.bind(this._onSuggestionMouseLeave, this);

  var cssClass = _.className(this.cssClasses.prefix, this.cssClasses.suggestion);
  this.$menu = DOM.element(o.menu)
    .on('mouseenter.aa', cssClass, onSuggestionMouseEnter)
    .on('mouseleave.aa', cssClass, onSuggestionMouseLeave)
    .on('click.aa', cssClass, onSuggestionClick);

  this.$container = o.appendTo ? o.wrapper : this.$menu;

  if (o.templates && o.templates.header) {
    this.templates.header = _.templatify(o.templates.header);
    this.$menu.prepend(this.templates.header());
  }

  if (o.templates && o.templates.empty) {
    this.templates.empty = _.templatify(o.templates.empty);
    this.$empty = DOM.element('<div class="' +
      _.className(this.cssClasses.prefix, this.cssClasses.empty, true) + '">' +
      '</div>');
    this.$menu.append(this.$empty);
    this.$empty.hide();
  }

  this.datasets = _.map(o.datasets, function(oDataset) {
    return initializeDataset(that.$menu, oDataset, o.cssClasses);
  });
  _.each(this.datasets, function(dataset) {
    var root = dataset.getRoot();
    if (root && root.parent().length === 0) {
      that.$menu.append(root);
    }
    dataset.onSync('rendered', that._onRendered, that);
  });

  if (o.templates && o.templates.footer) {
    this.templates.footer = _.templatify(o.templates.footer);
    this.$menu.append(this.templates.footer());
  }

  var self = this;
  DOM.element(window).resize(function() {
    self._redraw();
  });
}

// instance methods
// ----------------

_.mixin(Dropdown.prototype, EventEmitter, {

  // ### private

  _onSuggestionClick: function onSuggestionClick($e) {
    this.trigger('suggestionClicked', DOM.element($e.currentTarget));
  },

  _onSuggestionMouseEnter: function onSuggestionMouseEnter($e) {
    var elt = DOM.element($e.currentTarget);
    if (elt.hasClass(_.className(this.cssClasses.prefix, this.cssClasses.cursor, true))) {
      // we're already on the cursor
      // => we're probably entering it again after leaving it for a nested div
      return;
    }
    this._removeCursor();

    // Fixes iOS double tap behaviour, by modifying the DOM right before the
    // native href clicks happens, iOS will requires another tap to follow
    // a suggestion that has an <a href> element inside
    // https://www.google.com/search?q=ios+double+tap+bug+href
    var suggestion = this;
    setTimeout(function() {
      // this exact line, when inside the main loop, will trigger a double tap bug
      // on iOS devices
      suggestion._setCursor(elt, false);
    }, 0);
  },

  _onSuggestionMouseLeave: function onSuggestionMouseLeave($e) {
    // $e.relatedTarget is the `EventTarget` the pointing device entered to
    if ($e.relatedTarget) {
      var elt = DOM.element($e.relatedTarget);
      if (elt.closest('.' + _.className(this.cssClasses.prefix, this.cssClasses.cursor, true)).length > 0) {
        // our father is a cursor
        // => it means we're just leaving the suggestion for a nested div
        return;
      }
    }
    this._removeCursor();
    this.trigger('cursorRemoved');
  },

  _onRendered: function onRendered(e, query) {
    this.isEmpty = _.every(this.datasets, isDatasetEmpty);

    if (this.isEmpty) {
      if (query.length >= this.minLength) {
        this.trigger('empty');
      }

      if (this.$empty) {
        if (query.length < this.minLength) {
          this._hide();
        } else {
          var html = this.templates.empty({
            query: this.datasets[0] && this.datasets[0].query
          });
          this.$empty.html(html);
          this.$empty.show();
          this._show();
        }
      } else if (_.any(this.datasets, hasEmptyTemplate)) {
        if (query.length < this.minLength) {
          this._hide();
        } else {
          this._show();
        }
      } else {
        this._hide();
      }
    } else if (this.isOpen) {
      if (this.$empty) {
        this.$empty.empty();
        this.$empty.hide();
      }

      if (query.length >= this.minLength) {
        this._show();
      } else {
        this._hide();
      }
    }

    this.trigger('datasetRendered');

    function isDatasetEmpty(dataset) {
      return dataset.isEmpty();
    }

    function hasEmptyTemplate(dataset) {
      return dataset.templates && dataset.templates.empty;
    }
  },

  _hide: function() {
    this.$container.hide();
  },

  _show: function() {
    // can't use jQuery#show because $menu is a span element we want
    // display: block; not dislay: inline;
    this.$container.css('display', 'block');

    this._redraw();

    this.trigger('shown');
  },

  _redraw: function redraw() {
    if (!this.isOpen || !this.appendTo) return;

    this.trigger('redrawn');
  },

  _getSuggestions: function getSuggestions() {
    return this.$menu.find(_.className(this.cssClasses.prefix, this.cssClasses.suggestion));
  },

  _getCursor: function getCursor() {
    return this.$menu.find(_.className(this.cssClasses.prefix, this.cssClasses.cursor)).first();
  },

  _setCursor: function setCursor($el, updateInput) {
    $el.first()
      .addClass(_.className(this.cssClasses.prefix, this.cssClasses.cursor, true))
      .attr('aria-selected', 'true');
    this.trigger('cursorMoved', updateInput);
  },

  _removeCursor: function removeCursor() {
    this._getCursor()
      .removeClass(_.className(this.cssClasses.prefix, this.cssClasses.cursor, true))
      .removeAttr('aria-selected');
  },

  _moveCursor: function moveCursor(increment) {
    var $suggestions;
    var $oldCursor;
    var newCursorIndex;
    var $newCursor;

    if (!this.isOpen) {
      return;
    }

    $oldCursor = this._getCursor();
    $suggestions = this._getSuggestions();

    this._removeCursor();

    // shifting before and after modulo to deal with -1 index
    newCursorIndex = $suggestions.index($oldCursor) + increment;
    newCursorIndex = (newCursorIndex + 1) % ($suggestions.length + 1) - 1;

    if (newCursorIndex === -1) {
      this.trigger('cursorRemoved');

      return;
    } else if (newCursorIndex < -1) {
      newCursorIndex = $suggestions.length - 1;
    }

    this._setCursor($newCursor = $suggestions.eq(newCursorIndex), true);

    // in the case of scrollable overflow
    // make sure the cursor is visible in the menu
    this._ensureVisible($newCursor);
  },

  _ensureVisible: function ensureVisible($el) {
    var elTop;
    var elBottom;
    var menuScrollTop;
    var menuHeight;

    elTop = $el.position().top;
    elBottom = elTop + $el.height() +
      parseInt($el.css('margin-top'), 10) +
      parseInt($el.css('margin-bottom'), 10);
    menuScrollTop = this.$menu.scrollTop();
    menuHeight = this.$menu.height() +
      parseInt(this.$menu.css('padding-top'), 10) +
      parseInt(this.$menu.css('padding-bottom'), 10);

    if (elTop < 0) {
      this.$menu.scrollTop(menuScrollTop + elTop);
    } else if (menuHeight < elBottom) {
      this.$menu.scrollTop(menuScrollTop + (elBottom - menuHeight));
    }
  },

  // ### public

  close: function close() {
    if (this.isOpen) {
      this.isOpen = false;

      this._removeCursor();
      this._hide();

      this.trigger('closed');
    }
  },

  open: function open() {
    if (!this.isOpen) {
      this.isOpen = true;

      if (!this.isEmpty) {
        this._show();
      }

      this.trigger('opened');
    }
  },

  setLanguageDirection: function setLanguageDirection(dir) {
    this.$menu.css(dir === 'ltr' ? this.css.ltr : this.css.rtl);
  },

  moveCursorUp: function moveCursorUp() {
    this._moveCursor(-1);
  },

  moveCursorDown: function moveCursorDown() {
    this._moveCursor(+1);
  },

  getDatumForSuggestion: function getDatumForSuggestion($el) {
    var datum = null;

    if ($el.length) {
      datum = {
        raw: Dataset.extractDatum($el),
        value: Dataset.extractValue($el),
        datasetName: Dataset.extractDatasetName($el)
      };
    }

    return datum;
  },

  getCurrentCursor: function getCurrentCursor() {
    return this._getCursor().first();
  },

  getDatumForCursor: function getDatumForCursor() {
    return this.getDatumForSuggestion(this._getCursor().first());
  },

  getDatumForTopSuggestion: function getDatumForTopSuggestion() {
    return this.getDatumForSuggestion(this._getSuggestions().first());
  },

  cursorTopSuggestion: function cursorTopSuggestion() {
    this._setCursor(this._getSuggestions().first(), false);
  },

  update: function update(query) {
    _.each(this.datasets, updateDataset);

    function updateDataset(dataset) {
      dataset.update(query);
    }
  },

  empty: function empty() {
    _.each(this.datasets, clearDataset);
    this.isEmpty = true;

    function clearDataset(dataset) {
      dataset.clear();
    }
  },

  isVisible: function isVisible() {
    return this.isOpen && !this.isEmpty;
  },

  destroy: function destroy() {
    this.$menu.off('.aa');

    this.$menu = null;

    _.each(this.datasets, destroyDataset);

    function destroyDataset(dataset) {
      dataset.destroy();
    }
  }
});

// helper functions
// ----------------
Dropdown.Dataset = Dataset;

function initializeDataset($menu, oDataset, cssClasses) {
  return new Dropdown.Dataset(_.mixin({$menu: $menu, cssClasses: cssClasses}, oDataset));
}

module.exports = Dropdown;
