wiki-plugin-allyabase 0.0.1

package/test/node_modules/mocha/browser-entry.js

@@ -0,0 +1,226 @@
+'use strict';
+
+/* eslint no-unused-vars: off */
+/* eslint-env commonjs */
+
+/**
+ * Shim process.stdout.
+ */
+
+process.stdout = require('browser-stdout')({label: false});
+
+var parseQuery = require('./lib/browser/parse-query');
+var highlightTags = require('./lib/browser/highlight-tags');
+var Mocha = require('./lib/mocha');
+
+/**
+ * Create a Mocha instance.
+ *
+ * @return {undefined}
+ */
+
+var mocha = new Mocha({reporter: 'html'});
+
+/**
+ * Save timer references to avoid Sinon interfering (see GH-237).
+ */
+
+var Date = global.Date;
+var setTimeout = global.setTimeout;
+var setInterval = global.setInterval;
+var clearTimeout = global.clearTimeout;
+var clearInterval = global.clearInterval;
+
+var uncaughtExceptionHandlers = [];
+
+var originalOnerrorHandler = global.onerror;
+
+/**
+ * Remove uncaughtException listener.
+ * Revert to original onerror handler if previously defined.
+ */
+
+process.removeListener = function (e, fn) {
+  if (e === 'uncaughtException') {
+    if (originalOnerrorHandler) {
+      global.onerror = originalOnerrorHandler;
+    } else {
+      global.onerror = function () {};
+    }
+    var i = uncaughtExceptionHandlers.indexOf(fn);
+    if (i !== -1) {
+      uncaughtExceptionHandlers.splice(i, 1);
+    }
+  }
+};
+
+/**
+ * Implements listenerCount for 'uncaughtException'.
+ */
+
+process.listenerCount = function (name) {
+  if (name === 'uncaughtException') {
+    return uncaughtExceptionHandlers.length;
+  }
+  return 0;
+};
+
+/**
+ * Implements uncaughtException listener.
+ */
+
+process.on = function (e, fn) {
+  if (e === 'uncaughtException') {
+    global.onerror = function (msg, url, line, col, err) {
+      fn(err || new Error(msg + ' (' + url + ':' + line + ':' + col + ')'));
+      return !mocha.options.allowUncaught;
+    };
+    uncaughtExceptionHandlers.push(fn);
+  }
+};
+
+process.listeners = function (e) {
+  if (e === 'uncaughtException') {
+    return uncaughtExceptionHandlers;
+  }
+  return [];
+};
+
+// The BDD UI is registered by default, but no UI will be functional in the
+// browser without an explicit call to the overridden `mocha.ui` (see below).
+// Ensure that this default UI does not expose its methods to the global scope.
+mocha.suite.removeAllListeners('pre-require');
+
+var immediateQueue = [];
+var immediateTimeout;
+
+function timeslice() {
+  var immediateStart = new Date().getTime();
+  while (immediateQueue.length && new Date().getTime() - immediateStart < 100) {
+    immediateQueue.shift()();
+  }
+  if (immediateQueue.length) {
+    immediateTimeout = setTimeout(timeslice, 0);
+  } else {
+    immediateTimeout = null;
+  }
+}
+
+/**
+ * High-performance override of Runner.immediately.
+ */
+
+Mocha.Runner.immediately = function (callback) {
+  immediateQueue.push(callback);
+  if (!immediateTimeout) {
+    immediateTimeout = setTimeout(timeslice, 0);
+  }
+};
+
+/**
+ * Function to allow assertion libraries to throw errors directly into mocha.
+ * This is useful when running tests in a browser because window.onerror will
+ * only receive the 'message' attribute of the Error.
+ */
+mocha.throwError = function (err) {
+  uncaughtExceptionHandlers.forEach(function (fn) {
+    fn(err);
+  });
+  throw err;
+};
+
+/**
+ * Override ui to ensure that the ui functions are initialized.
+ * Normally this would happen in Mocha.prototype.loadFiles.
+ */
+
+mocha.ui = function (ui) {
+  Mocha.prototype.ui.call(this, ui);
+  this.suite.emit('pre-require', global, null, this);
+  return this;
+};
+
+/**
+ * Setup mocha with the given setting options.
+ */
+
+mocha.setup = function (opts) {
+  if (typeof opts === 'string') {
+    opts = {ui: opts};
+  }
+  if (opts.delay === true) {
+    this.delay();
+  }
+  var self = this;
+  Object.keys(opts)
+    .filter(function (opt) {
+      return opt !== 'delay';
+    })
+    .forEach(function (opt) {
+      if (Object.prototype.hasOwnProperty.call(opts, opt)) {
+        self[opt](opts[opt]);
+      }
+    });
+  return this;
+};
+
+/**
+ * Run mocha, returning the Runner.
+ */
+
+mocha.run = function (fn) {
+  var options = mocha.options;
+  mocha.globals('location');
+
+  var query = parseQuery(global.location.search || '');
+  if (query.grep) {
+    mocha.grep(query.grep);
+  }
+  if (query.fgrep) {
+    mocha.fgrep(query.fgrep);
+  }
+  if (query.invert) {
+    mocha.invert();
+  }
+
+  return Mocha.prototype.run.call(mocha, function (err) {
+    // The DOM Document is not available in Web Workers.
+    var document = global.document;
+    if (
+      document &&
+      document.getElementById('mocha') &&
+      options.noHighlighting !== true
+    ) {
+      highlightTags('code');
+    }
+    if (fn) {
+      fn(err);
+    }
+  });
+};
+
+/**
+ * Expose the process shim.
+ * https://github.com/mochajs/mocha/pull/916
+ */
+
+Mocha.process = process;
+
+/**
+ * Expose mocha.
+ */
+global.Mocha = Mocha;
+global.mocha = mocha;
+
+// for bundlers: enable `import {describe, it} from 'mocha'`
+// `bdd` interface only
+// prettier-ignore
+[ 
+  'describe', 'context', 'it', 'specify',
+  'xdescribe', 'xcontext', 'xit', 'xspecify',
+  'before', 'beforeEach', 'afterEach', 'after'
+].forEach(function(key) {
+  mocha[key] = global[key];
+});
+
+module.exports = mocha;

package/test/node_modules/mocha/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/mocha');

package/test/node_modules/mocha/lib/browser/highlight-tags.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Highlight the given string of `js`.
+ *
+ * @private
+ * @param {string} js
+ * @return {string}
+ */
+function highlight(js) {
+  return js
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/\/\/(.*)/gm, '<span class="comment">//$1</span>')
+    .replace(/('.*?')/gm, '<span class="string">$1</span>')
+    .replace(/(\d+\.\d+)/gm, '<span class="number">$1</span>')
+    .replace(/(\d+)/gm, '<span class="number">$1</span>')
+    .replace(
+      /\bnew[ \t]+(\w+)/gm,
+      '<span class="keyword">new</span> <span class="init">$1</span>'
+    )
+    .replace(
+      /\b(function|new|throw|return|var|if|else)\b/gm,
+      '<span class="keyword">$1</span>'
+    );
+}
+
+/**
+ * Highlight the contents of tag `name`.
+ *
+ * @private
+ * @param {string} name
+ */
+module.exports = function highlightTags(name) {
+  var code = document.getElementById('mocha').getElementsByTagName(name);
+  for (var i = 0, len = code.length; i < len; ++i) {
+    code[i].innerHTML = highlight(code[i].innerHTML);
+  }
+};

package/test/node_modules/mocha/lib/browser/parse-query.js

@@ -0,0 +1,24 @@
+'use strict';
+
+/**
+ * Parse the given `qs`.
+ *
+ * @private
+ * @param {string} qs
+ * @return {Object<string, string>}
+ */
+module.exports = function parseQuery(qs) {
+  return qs
+    .replace('?', '')
+    .split('&')
+    .reduce(function (obj, pair) {
+      var i = pair.indexOf('=');
+      var key = pair.slice(0, i);
+      var val = pair.slice(++i);
+
+      // Due to how the URLSearchParams API treats spaces
+      obj[key] = decodeURIComponent(val.replace(/\+/g, '%20'));
+
+      return obj;
+    }, {});
+};

package/test/node_modules/mocha/lib/browser/template.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Mocha</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="stylesheet" href="mocha.css" />
+  </head>
+  <body>
+    <div id="mocha"></div>
+    <script src="mocha.js"></script>
+    <script>
+      mocha.setup('bdd');
+    </script>
+    <script src="tests.spec.js"></script>
+    <script>
+      mocha.run();
+    </script>
+  </body>
+</html>

package/test/node_modules/mocha/lib/cli/cli.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+'use strict';
+
+/**
+ * Contains CLI entry point and public API for programmatic usage in Node.js.
+ * - Option parsing is handled by {@link https://npm.im/yargs yargs}.
+ * - If executed via `node`, this module will run {@linkcode module:lib/cli.main main()}.
+ * @public
+ * @module lib/cli
+ */
+
+const debug = require('debug')('mocha:cli:cli');
+const symbols = require('log-symbols');
+const yargs = require('yargs');
+const path = require('path');
+const {
+  loadRc,
+  loadPkgRc,
+  loadOptions,
+  YARGS_PARSER_CONFIG
+} = require('./options');
+const lookupFiles = require('./lookup-files');
+const commands = require('./commands');
+const ansi = require('ansi-colors');
+const {repository, homepage, version, discord} = require('../../package.json');
+const {cwd} = require('../utils');
+
+/**
+ * - Accepts an `Array` of arguments
+ * - Modifies {@link https://nodejs.org/api/modules.html#modules_module_paths Node.js' search path} for easy loading of consumer modules
+ * - Sets {@linkcode https://nodejs.org/api/errors.html#errors_error_stacktracelimit Error.stackTraceLimit} to `Infinity`
+ * @public
+ * @summary Mocha's main command-line entry-point.
+ * @param {string[]} argv - Array of arguments to parse, or by default the lovely `process.argv.slice(2)`
+ * @param {object} [mochaArgs] - Object of already parsed Mocha arguments (by bin/mocha)
+ */
+exports.main = (argv = process.argv.slice(2), mochaArgs) => {
+  debug('entered main with raw args', argv);
+  // ensure we can require() from current working directory
+  if (typeof module.paths !== 'undefined') {
+    module.paths.push(cwd(), path.resolve('node_modules'));
+  }
+
+  try {
+    Error.stackTraceLimit = Infinity; // configurable via --stack-trace-limit?
+  } catch (err) {
+    debug('unable to set Error.stackTraceLimit = Infinity', err);
+  }
+
+  var args = mochaArgs || loadOptions(argv);
+
+  yargs()
+    .scriptName('mocha')
+    .command(commands.run)
+    .command(commands.init)
+    .updateStrings({
+      'Positionals:': 'Positional Arguments',
+      'Options:': 'Other Options',
+      'Commands:': 'Commands'
+    })
+    .fail((msg, err, yargs) => {
+      debug('caught error sometime before command handler: %O', err);
+      yargs.showHelp();
+      console.error(`\n${symbols.error} ${ansi.red('ERROR:')} ${msg}`);
+      process.exit(1);
+    })
+    .help('help', 'Show usage information & exit')
+    .alias('help', 'h')
+    .version('version', 'Show version number & exit', version)
+    .alias('version', 'V')
+    .wrap(process.stdout.columns ? Math.min(process.stdout.columns, 80) : 80)
+    .epilog(
+      `${ansi.reset("Mocha Resources")}
+    Chat: ${ansi.magenta(discord)}
+  GitHub: ${ansi.blue(repository.url)}
+    Docs: ${ansi.yellow(homepage)}
+      `
+    )
+    .parserConfiguration(YARGS_PARSER_CONFIG)
+    .config(args)
+    .parse(args._);
+};
+
+exports.lookupFiles = lookupFiles;
+exports.loadOptions = loadOptions;
+exports.loadPkgRc = loadPkgRc;
+exports.loadRc = loadRc;
+
+// allow direct execution
+if (require.main === module) {
+  exports.main();
+}

package/test/node_modules/mocha/lib/cli/collect-files.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const ansi = require('ansi-colors');
+const debug = require('debug')('mocha:cli:run:helpers');
+const minimatch = require('minimatch');
+const {NO_FILES_MATCH_PATTERN} = require('../errors').constants;
+const lookupFiles = require('./lookup-files');
+const {castArray} = require('../utils');
+
+/**
+ * Exports a function that collects test files from CLI parameters.
+ * @see module:lib/cli/run-helpers
+ * @see module:lib/cli/watch-run
+ * @module
+ * @private
+ */
+
+/**
+ * Smash together an array of test files in the correct order
+ * @param {FileCollectionOptions} [opts] - Options
+ * @returns {FileCollectionResponse} An object containing a list of files to test and unmatched files.
+ * @private
+ */
+module.exports = ({
+  ignore,
+  extension,
+  file: fileArgs,
+  recursive,
+  sort,
+  spec
+} = {}) => {
+  const unmatchedSpecFiles = [];
+  const specFiles = spec.reduce((specFiles, arg) => {
+    try {
+      const moreSpecFiles = castArray(lookupFiles(arg, extension, recursive))
+        .filter(filename =>
+          ignore.every(
+            pattern =>
+              !minimatch(filename, pattern, {windowsPathsNoEscape: true})
+          )
+        )
+        .map(filename => path.resolve(filename));
+      return [...specFiles, ...moreSpecFiles];
+    } catch (err) {
+      if (err.code === NO_FILES_MATCH_PATTERN) {
+        unmatchedSpecFiles.push({message: err.message, pattern: err.pattern});
+        return specFiles;
+      }
+
+      throw err;
+    }
+  }, []);
+
+  // check that each file passed in to --file exists
+
+  const unmatchedFiles = [];
+  fileArgs.forEach(file => {
+    const fileAbsolutePath = path.resolve(file);
+    try {
+      // Used instead of fs.existsSync to ensure that file-ending less files are still resolved correctly
+      require.resolve(fileAbsolutePath);
+    } catch (err) {
+      if (err.code === 'MODULE_NOT_FOUND') {
+        unmatchedFiles.push({
+          pattern: file,
+          absolutePath: fileAbsolutePath
+        });
+        return;
+      }
+
+      throw err;
+    }
+  });
+
+  // ensure we don't sort the stuff from fileArgs; order is important!
+  if (sort) {
+    specFiles.sort();
+  }
+
+  // add files given through --file to be ran first
+  const files = [
+    ...fileArgs.map(filepath => path.resolve(filepath)),
+    ...specFiles
+  ];
+  debug('test files (in order): ', files);
+
+  if (!files.length) {
+    // give full message details when only 1 file is missing
+    const noneFoundMsg =
+      unmatchedSpecFiles.length === 1
+        ? `Error: No test files found: ${JSON.stringify(
+            unmatchedSpecFiles[0].pattern
+          )}` // stringify to print escaped characters raw
+        : 'Error: No test files found';
+    console.error(ansi.red(noneFoundMsg));
+    process.exit(1);
+  } else {
+    // print messages as a warning
+    unmatchedSpecFiles.forEach(warning => {
+      console.warn(ansi.yellow(`Warning: ${warning.message}`));
+    });
+  }
+
+  return {
+    files,
+    unmatchedFiles
+  };
+};
+
+/**
+ * An object to configure how Mocha gathers test files
+ * @private
+ * @typedef {Object} FileCollectionOptions
+ * @property {string[]} extension - File extensions to use
+ * @property {string[]} spec - Files, dirs, globs to run
+ * @property {string[]} ignore - Files, dirs, globs to ignore
+ * @property {string[]} file - List of additional files to include
+ * @property {boolean} recursive - Find files recursively
+ * @property {boolean} sort - Sort test files
+ */
+
+/**
+ * Diagnostic object containing unmatched files
+ * @typedef {Object} UnmatchedFile -
+ * @property {string} absolutePath - A list of unmatched files derived from the file arguments passed in.
+ * @property {string} pattern - A list of unmatched files derived from the file arguments passed in.
+ *
+ */
+
+/**
+ * Response object containing a list of files to test and unmatched files.
+ * @typedef {Object} FileCollectionResponse
+ * @property {string[]} files - A list of files to test
+ * @property {UnmatchedFile[]} unmatchedFiles - A list of unmatched files derived from the file arguments passed in.
+ */

package/test/node_modules/mocha/lib/cli/commands.js

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * Exports Yargs commands
+ * @see https://github.com/yargs/yargs/blob/main/docs/advanced.md
+ * @private
+ * @module
+ */
+
+module.exports = {
+  init: require('./init'),
+  // default command
+  run: require('./run'),
+}

package/test/node_modules/mocha/lib/cli/config.js

@@ -0,0 +1,100 @@
+'use strict';
+
+/**
+ * Responsible for loading / finding Mocha's "rc" files.
+ *
+ * @private
+ * @module
+ */
+
+const fs = require('fs');
+const path = require('path');
+const debug = require('debug')('mocha:cli:config');
+const findUp = require('find-up');
+const {createUnparsableFileError} = require('../errors');
+const utils = require('../utils');
+
+/**
+ * These are the valid config files, in order of precedence;
+ * e.g., if `.mocharc.js` is present, then `.mocharc.yaml` and the rest
+ * will be ignored.
+ * The user should still be able to explicitly specify a file.
+ * @private
+ */
+exports.CONFIG_FILES = [
+  '.mocharc.cjs',
+  '.mocharc.js',
+  '.mocharc.yaml',
+  '.mocharc.yml',
+  '.mocharc.jsonc',
+  '.mocharc.json'
+];
+
+/**
+ * Parsers for various config filetypes. Each accepts a filepath and
+ * returns an object (but could throw)
+ */
+const parsers = (exports.parsers = {
+  yaml: filepath => require('js-yaml').load(fs.readFileSync(filepath, 'utf8')),
+  js: filepath => {
+    let cwdFilepath;
+    try {
+      debug('parsers: load cwd-relative path: "%s"', path.resolve(filepath));
+      cwdFilepath = require.resolve(path.resolve(filepath)); // evtl. throws
+      return require(cwdFilepath);
+    } catch (err) {
+      if (cwdFilepath) throw err;
+
+      debug('parsers: retry load as module-relative path: "%s"', filepath);
+      return require(filepath);
+    }
+  },
+  json: filepath =>
+    JSON.parse(
+      require('strip-json-comments')(fs.readFileSync(filepath, 'utf8'))
+    )
+});
+
+/**
+ * Loads and parses, based on file extension, a config file.
+ * "JSON" files may have comments.
+ *
+ * @private
+ * @param {string} filepath - Config file path to load
+ * @returns {Object} Parsed config object
+ */
+exports.loadConfig = filepath => {
+  let config = {};
+  debug('loadConfig: trying to parse config at %s', filepath);
+
+  const ext = path.extname(filepath);
+  try {
+    if (ext === '.yml' || ext === '.yaml') {
+      config = parsers.yaml(filepath);
+    } else if (ext === '.js' || ext === '.cjs') {
+      config = parsers.js(filepath);
+    } else {
+      config = parsers.json(filepath);
+    }
+  } catch (err) {
+    throw createUnparsableFileError(
+      `Unable to read/parse ${filepath}: ${err}`,
+      filepath
+    );
+  }
+  return config;
+};
+
+/**
+ * Find ("find up") config file starting at `cwd`
+ *
+ * @param {string} [cwd] - Current working directory
+ * @returns {string|null} Filepath to config, if found
+ */
+exports.findConfig = (cwd = utils.cwd()) => {
+  const filepath = findUp.sync(exports.CONFIG_FILES, {cwd});
+  if (filepath) {
+    debug('findConfig: found config file %s', filepath);
+  }
+  return filepath;
+};

package/test/node_modules/mocha/lib/cli/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./cli');

package/test/node_modules/mocha/lib/cli/init.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/**
+ * Command module for "init" command
+ *
+ * @private
+ * @module
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+exports.command = 'init <path>';
+
+exports.description = 'create a client-side Mocha setup at <path>';
+
+exports.builder = yargs =>
+  yargs.positional('path', {
+    type: 'string',
+    normalize: true
+  });
+
+exports.handler = argv => {
+  const destdir = argv.path;
+  const srcdir = path.join(__dirname, '..', '..');
+  fs.mkdirSync(destdir, {recursive: true});
+  const css = fs.readFileSync(path.join(srcdir, 'mocha.css'));
+  const js = fs.readFileSync(path.join(srcdir, 'mocha.js'));
+  const tmpl = fs.readFileSync(
+    path.join(srcdir, 'lib', 'browser', 'template.html')
+  );
+  fs.writeFileSync(path.join(destdir, 'mocha.css'), css);
+  fs.writeFileSync(path.join(destdir, 'mocha.js'), js);
+  fs.writeFileSync(path.join(destdir, 'tests.spec.js'), '');
+  fs.writeFileSync(path.join(destdir, 'index.html'), tmpl);
+};