brut-js 0.0.20 → 0.0.22-RC

package/docs/node_modules/jsdoc/LICENSE.md

@@ -0,0 +1,102 @@
+# License
+
+JSDoc is free software, licensed under the Apache License, Version 2.0 (the
+"License"). Commercial and non-commercial use are permitted in compliance with
+the License.
+
+Copyright (c) 2011-present Michael Mathews <micmath@gmail.com> and the
+[contributors to JSDoc](https://github.com/jsdoc/jsdoc/graphs/contributors). All
+rights reserved.
+
+You can obtain a copy of the License at:
+https://www.apache.org/licenses/LICENSE-2.0
+
+In addition, a copy of the License is included with this distribution.
+
+As stated in Section 7, "Disclaimer of Warranty," of the License:
+
+> Licensor provides the Work (and each Contributor provides its Contributions)
+> on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+> express or implied, including, without limitation, any warranties or
+> conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+> PARTICULAR PURPOSE. You are solely responsible for determining the
+> appropriateness of using or redistributing the Work and assume any risks
+> associated with Your exercise of permissions under this License.
+
+The source code for JSDoc is available at: https://github.com/jsdoc/jsdoc
+
+# Third-party software
+
+JSDoc includes the following third-party software, either in whole or in part.
+Each third-party software package is provided under its own license.
+
+## MIT License
+
+Several of the following software packages are distributed under the MIT
+license, which is reproduced below:
+
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+## Google Code Prettify
+
+Google Code Prettify is distributed under the Apache License 2.0, which is
+included with this package.
+
+Copyright (c) 2006 Google Inc.
+
+The source code for Google Code Prettify is available at:
+https://code.google.com/p/google-code-prettify/
+
+## Jasmine
+
+Jasmine is distributed under the MIT license, which is reproduced above.
+
+Copyright (c) 2008-2011 Pivotal Labs.
+
+The source code for Jasmine is available at:
+https://github.com/pivotal/jasmine
+
+## jasmine-node
+
+jasmine-node is distributed under the MIT license, which is reproduced above.
+
+Copyright (c) 2010 Adam Abrons and Misko Hevery (http://getangular.com).
+
+The source code for jasmine-node is available at:
+https://github.com/mhevery/jasmine-node
+
+## Open Sans
+
+Open Sans is distributed under the Apache License 2.0, which is
+included with this package.
+
+Copyright (c) 2010-2011, Google Inc.
+
+This typeface, including the complete set of variations, are available at:
+https://fonts.google.com/specimen/Open+Sans
+
+## Tomorrow theme for Google Code Prettify
+
+The Tomorrow theme for Google Code Prettify is distributed under the MIT
+license, which is reproduced above.
+
+Copyright (c) 2016 Yoshihide Jimbo.
+
+The source code for the Tomorrow theme is available at:
+https://github.com/jmblog/color-themes-for-google-code-prettify

package/docs/node_modules/jsdoc/README.md

@@ -0,0 +1,93 @@
+# JSDoc
+
+[![Build Status](https://travis-ci.org/jsdoc/jsdoc.svg?branch=master)](http://travis-ci.org/jsdoc/jsdoc)
+
+An API documentation generator for JavaScript.
+
+Want to contribute to JSDoc? Please read `CONTRIBUTING.md`.
+
+Installation and Usage
+----------------------
+
+JSDoc supports stable versions of Node.js 12.0.0 and later. You can install
+JSDoc globally or in your project's `node_modules` folder.
+
+To install the latest version on npm globally (might require `sudo`;
+[learn how to fix this](https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally)):
+
+    npm install -g jsdoc
+
+To install the latest version on npm locally and save it in your package's
+`package.json` file:
+
+    npm install --save-dev jsdoc
+
+To install the latest development version locally, without updating your
+project's `package.json` file:
+
+    npm install git+https://github.com/jsdoc/jsdoc.git
+
+If you installed JSDoc locally, the JSDoc command-line tool is available in
+`./node_modules/.bin`. To generate documentation for the file
+`yourJavaScriptFile.js`:
+
+    ./node_modules/.bin/jsdoc yourJavaScriptFile.js
+
+If you installed JSDoc globally, run the `jsdoc` command:
+
+    jsdoc yourJavaScriptFile.js
+
+By default, the generated documentation is saved in a directory named `out`. You
+can use the `--destination` (`-d`) option to specify another directory.
+
+Run `jsdoc --help` for a complete list of command-line options.
+
+## Templates and tools
+
+The JSDoc community has created templates and other tools to help you generate
+and customize your documentation. Here are a few of them:
+
+### Templates
+
++ [jaguarjs-jsdoc](https://github.com/davidshimjs/jaguarjs-jsdoc)
++ [DocStrap](https://github.com/docstrap/docstrap)
+([example](https://docstrap.github.io/docstrap))
++ [jsdoc3Template](https://github.com/DBCDK/jsdoc3Template)
+  ([example](https://github.com/danyg/jsdoc3Template/wiki#wiki-screenshots))
++ [minami](https://github.com/Nijikokun/minami)
++ [docdash](https://github.com/clenemt/docdash)
+([example](http://clenemt.github.io/docdash/))
++ [tui-jsdoc-template](https://github.com/nhnent/tui.jsdoc-template)
+([example](https://nhnent.github.io/tui.jsdoc-template/latest/))
++ [better-docs](https://github.com/SoftwareBrothers/better-docs)
+([example](https://softwarebrothers.github.io/admin-bro-dev/index.html))
+
+### Build tools
+
++ [JSDoc Grunt plugin](https://github.com/krampstudio/grunt-jsdoc)
++ [JSDoc Gulp plugin](https://github.com/mlucool/gulp-jsdoc3)
+
+### Other tools
+
++ [jsdoc-to-markdown](https://github.com/jsdoc2md/jsdoc-to-markdown)
++ [Integrating GitBook with
+JSDoc](https://medium.com/@kevinast/integrate-gitbook-jsdoc-974be8df6fb3)
+
+## For more information
+
++ Documentation is available at [jsdoc.app](https://jsdoc.app/).
++ Contribute to the docs at
+[jsdoc/jsdoc.github.io](https://github.com/jsdoc/jsdoc.github.io).
++ [Join JSDoc's Slack channel](https://jsdoc-slack.appspot.com/).
++ Ask for help on the
+[JSDoc Users mailing list](http://groups.google.com/group/jsdoc-users).
++ Post questions tagged `jsdoc` to
+[Stack Overflow](http://stackoverflow.com/questions/tagged/jsdoc).
+
+## License
+
+JSDoc is copyright (c) 2011-present Michael Mathews <micmath@gmail.com> and the
+[contributors to JSDoc](https://github.com/jsdoc/jsdoc/graphs/contributors).
+
+JSDoc is free software, licensed under the Apache License, Version 2.0. See the
+file `LICENSE.md` in this distribution for more details.

package/docs/node_modules/jsdoc/cli.js

@@ -0,0 +1,465 @@
+/* eslint-disable indent, no-process-exit */
+/**
+ * Helper methods for running JSDoc on the command line.
+ *
+ * A few critical notes for anyone who works on this module:
+ *
+ * + The module should really export an instance of `cli`, and `props` should be properties of a
+ * `cli` instance.
+ *
+ * @private
+ */
+module.exports = (() => {
+    const app = require('jsdoc/app');
+    const env = require('jsdoc/env');
+    const logger = require('jsdoc/util/logger');
+    const stripBom = require('jsdoc/util/stripbom');
+    const stripJsonComments = require('strip-json-comments');
+    const Promise = require('bluebird');
+
+    const props = {
+        docs: [],
+        packageJson: null,
+        shouldExitWithError: false,
+        tmpdir: null
+    };
+
+    const FATAL_ERROR_MESSAGE = 'Exiting JSDoc because an error occurred. See the previous log ' +
+        'messages for details.';
+    const cli = {};
+
+    // TODO: docs
+    cli.setVersionInfo = () => {
+        const fs = require('fs');
+        const path = require('path');
+
+        // allow this to throw--something is really wrong if we can't read our own package file
+        const info = JSON.parse( stripBom.strip(fs.readFileSync(path.join(env.dirname, 'package.json'),
+            'utf8')) );
+
+        env.version = {
+            number: info.version,
+            revision: new Date( parseInt(info.revision, 10) ).toUTCString()
+        };
+
+        return cli;
+    };
+
+    // TODO: docs
+    cli.loadConfig = () => {
+        const _ = require('underscore');
+        const args = require('jsdoc/opts/args');
+        const Config = require('jsdoc/config');
+        let config;
+        const fs = require('jsdoc/fs');
+        const path = require('jsdoc/path');
+
+        let confPath;
+        let isFile;
+
+        const defaultOpts = {
+            destination: './out/',
+            encoding: 'utf8'
+        };
+
+        try {
+            env.opts = args.parse(env.args);
+        }
+        catch (e) {
+            console.error(`${e.message}\n`);
+            cli.printHelp().then(() => {
+                cli.exit(1);
+            });
+        }
+
+        confPath = env.opts.configure || path.join(env.dirname, 'conf.json');
+        try {
+            isFile = fs.statSync(confPath).isFile();
+        }
+        catch (e) {
+            isFile = false;
+        }
+
+        if ( !isFile && !env.opts.configure ) {
+            confPath = path.join(env.dirname, 'conf.json.EXAMPLE');
+        }
+
+        try {
+            switch ( path.extname(confPath) ) {
+                case '.js':
+                    config = require( path.resolve(confPath) ) || {};
+                    break;
+                case '.json':
+                case '.EXAMPLE':
+                default:
+                    config = fs.readFileSync(confPath, 'utf8');
+                    break;
+            }
+            env.conf = new Config(config).get();
+        }
+        catch (e) {
+            cli.exit(1, `Cannot parse the config file ${confPath}: ${e}\n${FATAL_ERROR_MESSAGE}`);
+        }
+
+        // look for options on the command line, in the config file, and in the defaults, in that order
+        env.opts = _.defaults(env.opts, env.conf.opts, defaultOpts);
+
+        return cli;
+    };
+
+    // TODO: docs
+    cli.configureLogger = () => {
+        function recoverableError() {
+            props.shouldExitWithError = true;
+        }
+
+        function fatalError() {
+            cli.exit(1);
+        }
+
+        if (env.opts.debug) {
+            logger.setLevel(logger.LEVELS.DEBUG);
+        }
+        else if (env.opts.verbose) {
+            logger.setLevel(logger.LEVELS.INFO);
+        }
+
+        if (env.opts.pedantic) {
+            logger.once('logger:warn', recoverableError);
+            logger.once('logger:error', fatalError);
+        }
+        else {
+            logger.once('logger:error', recoverableError);
+        }
+
+        logger.once('logger:fatal', fatalError);
+
+        return cli;
+    };
+
+    // TODO: docs
+    cli.logStart = () => {
+        logger.debug( cli.getVersion() );
+
+        logger.debug('Environment info: %j', {
+            env: {
+                conf: env.conf,
+                opts: env.opts
+            }
+        });
+    };
+
+    // TODO: docs
+    cli.logFinish = () => {
+        let delta;
+        let deltaSeconds;
+
+        if (env.run.finish && env.run.start) {
+            delta = env.run.finish.getTime() - env.run.start.getTime();
+        }
+
+        if (delta !== undefined) {
+            deltaSeconds = (delta / 1000).toFixed(2);
+            logger.info('Finished running in %s seconds.', deltaSeconds);
+        }
+    };
+
+    // TODO: docs
+    cli.runCommand = cb => {
+        let cmd;
+
+        const opts = env.opts;
+
+        if (opts.help) {
+            cmd = cli.printHelp;
+        }
+        else if (opts.test) {
+            cmd = cli.runTests;
+        }
+        else if (opts.version) {
+            cmd = cli.printVersion;
+        }
+        else {
+            cmd = cli.main;
+        }
+
+        cmd().then(errorCode => {
+            if (!errorCode && props.shouldExitWithError) {
+                errorCode = 1;
+            }
+            cb(errorCode);
+        });
+    };
+
+    // TODO: docs
+    cli.printHelp = () => {
+        cli.printVersion();
+        console.log( `\n${require('jsdoc/opts/args').help()}\n` );
+        console.log('Visit https://jsdoc.app/ for more information.');
+
+        return Promise.resolve(0);
+    };
+
+    // TODO: docs
+    cli.runTests = () => {
+        const path = require('jsdoc/path');
+
+        const runner = Promise.promisify(require( path.join(env.dirname, 'test/runner') ));
+
+        console.log('Running tests...');
+
+        return runner();
+    };
+
+    // TODO: docs
+    cli.getVersion = () => `JSDoc ${env.version.number} (${env.version.revision})`;
+
+    // TODO: docs
+    cli.printVersion = () => {
+        console.log( cli.getVersion() );
+
+        return Promise.resolve(0);
+    };
+
+    // TODO: docs
+    cli.main = () => {
+        cli.scanFiles();
+
+        if (env.sourceFiles.length === 0) {
+            console.log('There are no input files to process.');
+
+            return Promise.resolve(0);
+        } else {
+            return cli.createParser()
+                .parseFiles()
+                .processParseResults()
+                .then(() => {
+                    env.run.finish = new Date();
+
+                    return 0;
+                });
+        }
+    };
+
+    function readPackageJson(filepath) {
+        const fs = require('jsdoc/fs');
+
+        try {
+            return stripJsonComments( fs.readFileSync(filepath, 'utf8') );
+        }
+        catch (e) {
+            logger.error('Unable to read the package file "%s"', filepath);
+
+            return null;
+        }
+    }
+
+    function buildSourceList() {
+        const Readme = require('jsdoc/readme');
+
+        let packageJson;
+        let readmeHtml;
+        let sourceFile;
+        let sourceFiles = env.opts._ ? env.opts._.slice(0) : [];
+
+        if (env.conf.source && env.conf.source.include) {
+            sourceFiles = sourceFiles.concat(env.conf.source.include);
+        }
+
+        // load the user-specified package/README files, if any
+        if (env.opts.package) {
+            packageJson = readPackageJson(env.opts.package);
+        }
+        if (env.opts.readme) {
+            readmeHtml = new Readme(env.opts.readme).html;
+        }
+
+        // source files named `package.json` or `README.md` get special treatment, unless the user
+        // explicitly specified a package and/or README file
+        for (let i = 0, l = sourceFiles.length; i < l; i++) {
+            sourceFile = sourceFiles[i];
+
+            if ( !env.opts.package && /\bpackage\.json$/i.test(sourceFile) ) {
+                packageJson = readPackageJson(sourceFile);
+                sourceFiles.splice(i--, 1);
+            }
+
+            if ( !env.opts.readme && /(\bREADME|\.md)$/i.test(sourceFile) ) {
+                readmeHtml = new Readme(sourceFile).html;
+                sourceFiles.splice(i--, 1);
+            }
+        }
+
+        props.packageJson = packageJson;
+        env.opts.readme = readmeHtml;
+
+        return sourceFiles;
+    }
+
+    // TODO: docs
+    cli.scanFiles = () => {
+        const Filter = require('jsdoc/src/filter').Filter;
+
+        let filter;
+
+        env.opts._ = buildSourceList();
+
+        // are there any files to scan and parse?
+        if (env.conf.source && env.opts._.length) {
+            filter = new Filter(env.conf.source);
+
+            env.sourceFiles = app.jsdoc.scanner.scan(env.opts._,
+                (env.opts.recurse ? env.conf.recurseDepth : undefined), filter);
+        }
+
+        return cli;
+    };
+
+    function resolvePluginPaths(paths) {
+        const path = require('jsdoc/path');
+
+        const pluginPaths = [];
+
+        paths.forEach(plugin => {
+            const basename = path.basename(plugin);
+            const dirname = path.dirname(plugin);
+            const pluginPath = path.getResourcePath(dirname, basename);
+
+            if (!pluginPath) {
+                logger.error('Unable to find the plugin "%s"', plugin);
+
+                return;
+            }
+
+            pluginPaths.push( pluginPath );
+        });
+
+        return pluginPaths;
+    }
+
+    cli.createParser = () => {
+        const handlers = require('jsdoc/src/handlers');
+        const parser = require('jsdoc/src/parser');
+        const plugins = require('jsdoc/plugins');
+
+        app.jsdoc.parser = parser.createParser(env.conf.parser);
+
+        if (env.conf.plugins) {
+            env.conf.plugins = resolvePluginPaths(env.conf.plugins);
+            plugins.installPlugins(env.conf.plugins, app.jsdoc.parser);
+        }
+
+        handlers.attachTo(app.jsdoc.parser);
+
+        return cli;
+    };
+
+    cli.parseFiles = () => {
+        const augment = require('jsdoc/augment');
+        const borrow = require('jsdoc/borrow');
+        const Package = require('jsdoc/package').Package;
+
+        let docs;
+        let packageDocs;
+
+        props.docs = docs = app.jsdoc.parser.parse(env.sourceFiles, env.opts.encoding);
+
+        // If there is no package.json, just create an empty package
+        packageDocs = new Package(props.packageJson);
+        packageDocs.files = env.sourceFiles || [];
+        docs.push(packageDocs);
+
+        logger.debug('Adding inherited symbols, mixins, and interface implementations...');
+        augment.augmentAll(docs);
+        logger.debug('Adding borrowed doclets...');
+        borrow.resolveBorrows(docs);
+        logger.debug('Post-processing complete.');
+
+        app.jsdoc.parser.fireProcessingComplete(docs);
+
+        return cli;
+    };
+
+    cli.processParseResults = () => {
+        if (env.opts.explain) {
+            cli.dumpParseResults();
+
+            return Promise.resolve();
+        }
+        else {
+            cli.resolveTutorials();
+
+            return cli.generateDocs();
+        }
+    };
+
+    cli.dumpParseResults = () => {
+        console.log(require('jsdoc/util/dumper').dump(props.docs));
+
+        return cli;
+    };
+
+    cli.resolveTutorials = () => {
+        const resolver = require('jsdoc/tutorial/resolver');
+
+        if (env.opts.tutorials) {
+            resolver.load(env.opts.tutorials);
+            resolver.resolve();
+        }
+
+        return cli;
+    };
+
+    cli.generateDocs = () => {
+        const path = require('jsdoc/path');
+        const resolver = require('jsdoc/tutorial/resolver');
+        const { taffy } = require('@jsdoc/salty');
+
+        let template;
+
+        env.opts.template = (() => {
+            const publish = env.opts.template || 'templates/default';
+            const templatePath = path.getResourcePath(publish);
+
+            // if we didn't find the template, keep the user-specified value so the error message is
+            // useful
+            return templatePath || env.opts.template;
+        })();
+
+        try {
+            template = require(`${env.opts.template}/publish`);
+        }
+        catch (e) {
+            logger.fatal(`Unable to load template: ${e.message}` || e);
+        }
+
+        // templates should include a publish.js file that exports a "publish" function
+        if (template.publish && typeof template.publish === 'function') {
+            let publishPromise;
+
+            logger.info('Generating output files...');
+            publishPromise = template.publish(
+                taffy(props.docs),
+                env.opts,
+                resolver.root
+            );
+
+            return Promise.resolve(publishPromise);
+        }
+        else {
+            logger.fatal(`${env.opts.template} does not export a "publish" function. Global "publish" functions are no longer supported.`);
+        }
+
+        return Promise.resolve();
+    };
+
+    // TODO: docs
+    cli.exit = (exitCode, message) => {
+        if (exitCode > 0 && message) {
+            console.error(message);
+        }
+        process.on('exit', () => { process.exit(exitCode); });
+    };
+
+    return cli;
+})();

package/docs/node_modules/jsdoc/conf.json.EXAMPLE

@@ -0,0 +1,17 @@
+{
+    "tags": {
+        "allowUnknownTags": true
+    },
+    "source": {
+        "includePattern": ".+\\.js(doc|x)?$",
+        "excludePattern": "(^|\\/|\\\\)_"
+    },
+    "plugins": [],
+    "templates": {
+        "cleverLinks": false,
+        "monospaceLinks": false,
+        "default": {
+            "outputSourceFiles": true
+        }
+    }
+}