nx 18.0.3 → 18.0.5

package/src/command-line/release/command-object.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.yargsReleaseCommand = void 0;
 const yargs_1 = require("yargs");
 const file_utils_1 = require("../../project-graph/file-utils");
+const logger_1 = require("../../utils/logger");
 const shared_options_1 = require("../yargs-utils/shared-options");
 exports.yargsReleaseCommand = {
     command: 'release',
@@ -83,13 +84,17 @@ const releaseCommand = {
         }
         return true;
     }),
-    handler: (args) => Promise.resolve().then(() => require('./release')).then((m) => m.releaseCLIHandler(args))
-        .then((versionDataOrExitCode) => {
-        if (typeof versionDataOrExitCode === 'number') {
-            return process.exit(versionDataOrExitCode);
+    handler: async (args) => {
+        const release = await Promise.resolve().then(() => require('./release'));
+        const result = await release.releaseCLIHandler(args);
+        if (args.dryRun) {
+            logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+        }
+        if (typeof result === 'number') {
+            process.exit(result);
         }
         process.exit(0);
-    }),
+    },
 };
 const versionCommand = {
     command: 'version [specifier]',
@@ -109,13 +114,17 @@ const versionCommand = {
         type: 'boolean',
         describe: 'Whether or not to stage the changes made by this command. Useful when combining this command with changelog generation.',
     })),
-    handler: (args) => Promise.resolve().then(() => require('./version')).then((m) => m.releaseVersionCLIHandler(args))
-        .then((versionDataOrExitCode) => {
-        if (typeof versionDataOrExitCode === 'number') {
-            return process.exit(versionDataOrExitCode);
+    handler: async (args) => {
+        const release = await Promise.resolve().then(() => require('./version'));
+        const result = await release.releaseVersionCLIHandler(args);
+        if (args.dryRun) {
+            logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+        }
+        if (typeof result === 'number') {
+            process.exit(result);
         }
         process.exit(0);
-    }),
+    },
 };
 const changelogCommand = {
     command: 'changelog [version]',
@@ -155,8 +164,15 @@ const changelogCommand = {
         return true;
     })),
     handler: async (args) => {
-        const status = await (await Promise.resolve().then(() => require('./changelog'))).releaseChangelogCLIHandler(args);
-        process.exit(status);
+        const release = await Promise.resolve().then(() => require('./changelog'));
+        const result = await release.releaseChangelogCLIHandler(args);
+        if (args.dryRun) {
+            logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+        }
+        if (typeof result === 'number') {
+            process.exit(result);
+        }
+        process.exit(0);
     },
 };
 const publishCommand = {
@@ -178,6 +194,9 @@ const publishCommand = {
     }),
     handler: async (args) => {
         const status = await (await Promise.resolve().then(() => require('./publish'))).releasePublishCLIHandler(coerceParallelOption((0, shared_options_1.withOverrides)(args, 2)));
+        if (args.dryRun) {
+            logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+        }
         process.exit(status);
     },
 };

package/src/command-line/release/publish.js

@@ -6,7 +6,6 @@ const devkit_exports_1 = require("../../devkit-exports");
 const project_graph_1 = require("../../project-graph/project-graph");
 const run_command_1 = require("../../tasks-runner/run-command");
 const command_line_utils_1 = require("../../utils/command-line-utils");
-const logger_1 = require("../../utils/logger");
 const params_1 = require("../../utils/params");
 const project_graph_utils_1 = require("../../utils/project-graph-utils");
 const graph_1 = require("../graph/graph");
@@ -70,9 +69,6 @@ async function releasePublish(args, isCLI = false) {
             overallExitStatus = status || 1;
         }
     }
-    if (_args.dryRun) {
-        logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no projects were actually published.`);
-    }
     return overallExitStatus;
 }
 exports.releasePublish = releasePublish;
@@ -102,22 +98,23 @@ async function runPublishOnProjects(args, projectGraph, nxJson, projectNames, sh
     if (args.firstRelease) {
         overrides.firstRelease = args.firstRelease;
     }
-    const targets = ['nx-release-publish'];
+    const requiredTargetName = 'nx-release-publish';
     if (args.graph) {
         const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(args);
-        const projectNames = projectsToRun.map((t) => t.name);
+        const projectNamesWithTarget = projectsToRun
+            .map((t) => t.name)
+            .filter((projectName) => (0, project_graph_utils_1.projectHasTarget)(projectGraph.nodes[projectName], requiredTargetName));
         await (0, graph_1.generateGraph)({
             watch: false,
             all: false,
             open: true,
             view: 'tasks',
-            targets,
-            projects: projectNames,
+            targets: [requiredTargetName],
+            projects: projectNamesWithTarget,
             file,
-        }, projectNames);
+        }, projectNamesWithTarget);
         return 0;
     }
-    const requiredTargetName = 'nx-release-publish';
     const projectsWithTarget = projectsToRun.filter((project) => (0, project_graph_utils_1.projectHasTarget)(project, requiredTargetName));
     if (projectsWithTarget.length === 0) {
         throw new Error(`Based on your config, the following projects were matched for publishing but do not have the "${requiredTargetName}" target specified:\n${[
@@ -130,7 +127,7 @@ async function runPublishOnProjects(args, projectGraph, nxJson, projectNames, sh
      * Run the relevant nx-release-publish executor on each of the selected projects.
      */
     const status = await (0, run_command_1.runCommand)(projectsWithTarget, projectGraph, { nxJson }, {
-        targets,
+        targets: [requiredTargetName],
         outputStyle: 'static',
         ...args,
     }, overrides, null, {}, {

package/src/command-line/release/release.js

@@ -11,6 +11,7 @@ const config_1 = require("./config/config");
 const filter_release_groups_1 = require("./config/filter-release-groups");
 const publish_1 = require("./publish");
 const git_1 = require("./utils/git");
+const github_1 = require("./utils/github");
 const resolve_nx_json_error_message_1 = require("./utils/resolve-nx-json-error-message");
 const shared_1 = require("./utils/shared");
 const version_1 = require("./version");
@@ -51,13 +52,14 @@ async function release(args) {
         gitCommit: false,
         gitTag: false,
     });
-    await (0, changelog_1.releaseChangelog)({
+    const changelogResult = await (0, changelog_1.releaseChangelog)({
         ...args,
         versionData: versionResult.projectsVersionData,
         version: versionResult.workspaceVersion,
         stageChanges: shouldStage,
         gitCommit: false,
         gitTag: false,
+        createRelease: false,
     });
     const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
     if (filterError) {
@@ -90,8 +92,59 @@ async function release(args) {
             });
         }
     }
-    let shouldPublish = !!args.yes && !args.skipPublish;
-    const shouldPromptPublishing = !args.yes && !args.skipPublish && !args.dryRun;
+    const shouldCreateWorkspaceRelease = (0, changelog_1.shouldCreateGitHubRelease)(nxReleaseConfig.changelog.workspaceChangelog);
+    let hasPushedChanges = false;
+    let latestCommit;
+    if (shouldCreateWorkspaceRelease && changelogResult.workspaceChangelog) {
+        devkit_exports_1.output.logSingleLine(`Pushing to git remote`);
+        // Before we can create/update the release we need to ensure the commit exists on the remote
+        await (0, git_1.gitPush)({
+            dryRun: args.dryRun,
+            verbose: args.verbose,
+        });
+        hasPushedChanges = true;
+        devkit_exports_1.output.logSingleLine(`Creating GitHub Release`);
+        latestCommit = await (0, git_1.getCommitHash)('HEAD');
+        await (0, github_1.createOrUpdateGithubRelease)(changelogResult.workspaceChangelog.releaseVersion, changelogResult.workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
+    }
+    for (const releaseGroup of releaseGroups) {
+        const shouldCreateProjectReleases = (0, changelog_1.shouldCreateGitHubRelease)(releaseGroup.changelog);
+        if (shouldCreateProjectReleases && changelogResult.projectChangelogs) {
+            const projects = args.projects?.length
+                ? // If the user has passed a list of projects, we need to use the filtered list of projects within the release group
+                    Array.from(releaseGroupToFilteredProjects.get(releaseGroup))
+                : // Otherwise, we use the full list of projects within the release group
+                    releaseGroup.projects;
+            const projectNodes = projects.map((name) => projectGraph.nodes[name]);
+            for (const project of projectNodes) {
+                const changelog = changelogResult.projectChangelogs[project.name];
+                if (!changelog) {
+                    continue;
+                }
+                if (!hasPushedChanges) {
+                    devkit_exports_1.output.logSingleLine(`Pushing to git remote`);
+                    // Before we can create/update the release we need to ensure the commit exists on the remote
+                    await (0, git_1.gitPush)({
+                        dryRun: args.dryRun,
+                        verbose: args.verbose,
+                    });
+                    hasPushedChanges = true;
+                }
+                devkit_exports_1.output.logSingleLine(`Creating GitHub Release`);
+                if (!latestCommit) {
+                    latestCommit = await (0, git_1.getCommitHash)('HEAD');
+                }
+                await (0, github_1.createOrUpdateGithubRelease)(changelog.releaseVersion, changelog.contents, latestCommit, { dryRun: args.dryRun });
+            }
+        }
+    }
+    let hasNewVersion = false;
+    // null means that all projects are versioned together but there were no changes
+    if (versionResult.workspaceVersion !== null) {
+        hasNewVersion = Object.values(versionResult.projectsVersionData).some((version) => version.newVersion !== null);
+    }
+    let shouldPublish = !!args.yes && !args.skipPublish && hasNewVersion;
+    const shouldPromptPublishing = !args.yes && !args.skipPublish && !args.dryRun && hasNewVersion;
     if (shouldPromptPublishing) {
         shouldPublish = await promptForPublish();
     }
@@ -99,13 +152,12 @@ async function release(args) {
         await (0, publish_1.releasePublish)(args);
     }
     else {
-        console.log('Skipped publishing packages.');
+        devkit_exports_1.output.logSingleLine('Skipped publishing packages.');
     }
     return versionResult;
 }
 exports.release = release;
 async function promptForPublish() {
-    console.log('\n');
     try {
         const reply = await (0, enquirer_1.prompt)([
             {
@@ -117,7 +169,6 @@ async function promptForPublish() {
         return reply.confirmation;
     }
     catch (e) {
-        console.log('\n');
         // Handle the case where the user exits the prompt with ctrl+c
         return false;
     }

package/src/command-line/release/utils/git.d.ts

@@ -48,7 +48,11 @@ export declare function gitTag({ tag, message, additionalArgs, dryRun, verbose,
     verbose?: boolean;
     logFn?: (message: string) => void;
 }): Promise<string>;
-export declare function gitPush(gitRemote?: string): Promise<void>;
+export declare function gitPush({ gitRemote, dryRun, verbose, }: {
+    gitRemote?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+}): Promise<void>;
 export declare function parseCommits(commits: RawGitCommit[]): GitCommit[];
 export declare function parseGitCommit(commit: RawGitCommit): GitCommit | null;
 export declare function getCommitHash(ref: string): Promise<string>;

package/src/command-line/release/utils/git.js

@@ -155,17 +155,27 @@ async function gitTag({ tag, message, additionalArgs, dryRun, verbose, logFn, })
     }
 }
 exports.gitTag = gitTag;
-async function gitPush(gitRemote) {
+async function gitPush({ gitRemote, dryRun, verbose, }) {
+    const commandArgs = [
+        'push',
+        // NOTE: It's important we use --follow-tags, and not --tags, so that we are precise about what we are pushing
+        '--follow-tags',
+        '--no-verify',
+        '--atomic',
+        // Set custom git remote if provided
+        ...(gitRemote ? [gitRemote] : []),
+    ];
+    if (verbose) {
+        console.log(dryRun
+            ? `Would push the current branch to the remote with the following command, but --dry-run was set:`
+            : `Pushing the current branch to the remote with the following command:`);
+        console.log(`git ${commandArgs.join(' ')}`);
+    }
+    if (dryRun) {
+        return;
+    }
     try {
-        await (0, exec_command_1.execCommand)('git', [
-            'push',
-            // NOTE: It's important we use --follow-tags, and not --tags, so that we are precise about what we are pushing
-            '--follow-tags',
-            '--no-verify',
-            '--atomic',
-            // Set custom git remote if provided
-            ...(gitRemote ? [gitRemote] : []),
-        ]);
+        await (0, exec_command_1.execCommand)('git', commandArgs);
     }
     catch (err) {
         throw new Error(`Unexpected git push error: ${err}`);
@@ -252,7 +262,12 @@ async function getCommitHash(ref) {
 exports.getCommitHash = getCommitHash;
 async function getFirstGitCommit() {
     try {
-        return (await (0, exec_command_1.execCommand)('git', ['rev-list', '--max-parents=0', 'HEAD'])).trim();
+        return (await (0, exec_command_1.execCommand)('git', [
+            'rev-list',
+            '--max-parents=0',
+            'HEAD',
+            '--first-parent',
+        ])).trim();
     }
     catch (e) {
         throw new Error(`Unable to find first commit in git history`);

package/src/command-line/release/utils/github.d.ts

@@ -1,4 +1,5 @@
 import { Reference } from './git';
+import { ReleaseVersion } from './shared';
 export type RepoSlug = `${string}/${string}`;
 export interface GithubRequestConfig {
     repo: string;
@@ -14,14 +15,9 @@ export interface GithubRelease {
     prerelease?: boolean;
 }
 export declare function getGitHubRepoSlug(remoteName?: string): RepoSlug;
-interface GithubReleaseOptions {
-    version: string;
-    body: string;
-    prerelease: boolean;
-    commit: string;
-}
-export declare function createOrUpdateGithubRelease(githubRequestConfig: GithubRequestConfig, release: GithubReleaseOptions, existingGithubReleaseForVersion?: GithubRelease): Promise<void>;
+export declare function createOrUpdateGithubRelease(releaseVersion: ReleaseVersion, changelogContents: string, latestCommit: string, { dryRun }: {
+    dryRun: boolean;
+}): Promise<void>;
 export declare function resolveGithubToken(): Promise<string | null>;
 export declare function getGithubReleaseByTag(config: GithubRequestConfig, tag: string): Promise<GithubRelease>;
 export declare function formatReferences(references: Reference[], repoSlug: RepoSlug): string;
-export {};

package/src/command-line/release/utils/github.js

@@ -8,6 +8,8 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const output_1 = require("../../../utils/output");
 const path_1 = require("../../../utils/path");
+const print_changes_1 = require("./print-changes");
+const shared_1 = require("./shared");
 // axios types and values don't seem to match
 const _axios = require("axios");
 const axios = _axios;
@@ -32,7 +34,65 @@ function getGitHubRepoSlug(remoteName = 'origin') {
     }
 }
 exports.getGitHubRepoSlug = getGitHubRepoSlug;
-async function createOrUpdateGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion) {
+async function createOrUpdateGithubRelease(releaseVersion, changelogContents, latestCommit, { dryRun }) {
+    const githubRepoSlug = getGitHubRepoSlug();
+    if (!githubRepoSlug) {
+        output_1.output.error({
+            title: `Unable to create a GitHub release because the GitHub repo slug could not be determined.`,
+            bodyLines: [
+                `Please ensure you have a valid GitHub remote configured. You can run \`git remote -v\` to list your current remotes.`,
+            ],
+        });
+        process.exit(1);
+    }
+    const token = await resolveGithubToken();
+    const githubRequestConfig = {
+        repo: githubRepoSlug,
+        token,
+    };
+    let existingGithubReleaseForVersion;
+    try {
+        existingGithubReleaseForVersion = await getGithubReleaseByTag(githubRequestConfig, releaseVersion.gitTag);
+    }
+    catch (err) {
+        if (err.response?.status === 401) {
+            output_1.output.error({
+                title: `Unable to resolve data via the GitHub API. You can use any of the following options to resolve this:`,
+                bodyLines: [
+                    '- Set the `GITHUB_TOKEN` or `GH_TOKEN` environment variable to a valid GitHub token with `repo` scope',
+                    '- Have an active session via the official gh CLI tool (https://cli.github.com) in your current terminal',
+                ],
+            });
+            process.exit(1);
+        }
+        if (err.response?.status === 404) {
+            // No existing release found, this is fine
+        }
+        else {
+            // Rethrow unknown errors for now
+            throw err;
+        }
+    }
+    const logTitle = `https://github.com/${githubRepoSlug}/releases/tag/${releaseVersion.gitTag}`;
+    if (existingGithubReleaseForVersion) {
+        console.error(`${chalk.white('UPDATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+    }
+    else {
+        console.error(`${chalk.green('CREATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+    }
+    console.log('');
+    (0, print_changes_1.printDiff)(existingGithubReleaseForVersion ? existingGithubReleaseForVersion.body : '', changelogContents, 3, shared_1.noDiffInChangelogMessage);
+    if (!dryRun) {
+        await createOrUpdateGithubReleaseInternal(githubRequestConfig, {
+            version: releaseVersion.gitTag,
+            prerelease: releaseVersion.isPrerelease,
+            body: changelogContents,
+            commit: latestCommit,
+        }, existingGithubReleaseForVersion);
+    }
+}
+exports.createOrUpdateGithubRelease = createOrUpdateGithubRelease;
+async function createOrUpdateGithubReleaseInternal(githubRequestConfig, release, existingGithubReleaseForVersion) {
     const result = await syncGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion);
     /**
      * If something went wrong POSTing to Github we can still pre-populate the web form on github.com
@@ -60,39 +120,22 @@ async function createOrUpdateGithubRelease(githubRequestConfig, release, existin
                 console.error(`An unknown error occurred while trying to create a release on GitHub, please report this on https://github.com/nrwl/nx (NOTE: make sure to redact your GitHub token from the error message!)`);
             }
         }
-        const reply = await (0, enquirer_1.prompt)([
-            {
-                name: 'open',
-                message: 'Do you want to finish creating the release manually in your browser?',
-                type: 'autocomplete',
-                choices: [
-                    {
-                        name: 'Yes',
-                        hint: 'It will pre-populate the form for you',
-                    },
-                    {
-                        name: 'No',
-                    },
-                ],
-                initial: 0,
-            },
-        ]).catch(() => {
-            return { open: 'No' };
-        });
-        if (reply.open === 'Yes') {
-            const open = require('open');
-            await open(result.url)
-                .then(() => {
-                console.info(`\nFollow up in the browser to manually create the release:\n\n` +
-                    chalk.underline(chalk.cyan(result.url)) +
-                    `\n`);
-            })
-                .catch(() => {
-                console.info(`Open this link to manually create a release: \n` +
-                    chalk.underline(chalk.cyan(result.url)) +
-                    '\n');
-            });
+        const shouldContinueInGitHub = await promptForContinueInGitHub();
+        if (!shouldContinueInGitHub) {
+            return;
         }
+        const open = require('open');
+        await open(result.url)
+            .then(() => {
+            console.info(`\nFollow up in the browser to manually create the release:\n\n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                `\n`);
+        })
+            .catch(() => {
+            console.info(`Open this link to manually create a release: \n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                '\n');
+        });
     }
     /**
      * If something went wrong POSTing to Github we can still pre-populate the web form on github.com
@@ -115,7 +158,32 @@ async function createOrUpdateGithubRelease(githubRequestConfig, release, existin
         });
     }
 }
-exports.createOrUpdateGithubRelease = createOrUpdateGithubRelease;
+async function promptForContinueInGitHub() {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'open',
+                message: 'Do you want to finish creating the release manually in your browser?',
+                type: 'autocomplete',
+                choices: [
+                    {
+                        name: 'Yes',
+                        hint: 'It will pre-populate the form for you',
+                    },
+                    {
+                        name: 'No',
+                    },
+                ],
+                initial: 0,
+            },
+        ]);
+        return reply.open === 'Yes';
+    }
+    catch (e) {
+        // Handle the case where the user exits the prompt with ctrl+c
+        process.exit(1);
+    }
+}
 async function syncGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion) {
     const ghRelease = {
         tag_name: release.version,

package/src/command-line/release/utils/shared.d.ts

@@ -2,6 +2,7 @@ import { ProjectGraph } from '../../../config/project-graph';
 import { Tree } from '../../../generators/tree';
 import type { ReleaseGroupWithName } from '../config/filter-release-groups';
 import { GitCommit } from './git';
+export declare const noDiffInChangelogMessage: string;
 export type ReleaseVersionGeneratorResult = {
     data: VersionData;
     callback: (tree: Tree, opts: {

package/src/command-line/release/utils/shared.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCommitsRelevantToProjects = exports.handleDuplicateGitTags = exports.createGitTagValues = exports.createCommitMessageValues = exports.commitChanges = exports.ReleaseVersion = void 0;
+exports.getCommitsRelevantToProjects = exports.handleDuplicateGitTags = exports.createGitTagValues = exports.createCommitMessageValues = exports.commitChanges = exports.ReleaseVersion = exports.noDiffInChangelogMessage = void 0;
+const chalk = require("chalk");
 const semver_1 = require("semver");
 const file_map_utils_1 = require("../../../project-graph/file-map-utils");
 const utils_1 = require("../../../tasks-runner/utils");
 const output_1 = require("../../../utils/output");
 const git_1 = require("./git");
+exports.noDiffInChangelogMessage = chalk.yellow(`NOTE: There was no diff detected for the changelog entry. Maybe you intended to pass alternative git references via --from and --to?`);
 function isPrerelease(version) {
     // prerelease returns an array of matching prerelease "components", or null if the version is not a prerelease
     return (0, semver_1.prerelease)(version) !== null;

package/src/command-line/release/version.js

@@ -144,9 +144,6 @@ async function releaseVersion(args) {
                 });
             }
         }
-        if (args.dryRun) {
-            devkit_exports_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
-        }
         return {
             // An overall workspace version cannot be relevant when filtering to independent projects
             workspaceVersion: undefined,
@@ -234,9 +231,6 @@ async function releaseVersion(args) {
             });
         }
     }
-    if (args.dryRun) {
-        devkit_exports_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
-    }
     return {
         workspaceVersion,
         projectsVersionData: versionData,

package/src/core/graph/3rdpartylicenses.txt

@@ -704,57 +704,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 
-regenerator-runtime
-MIT
-MIT License
-
-Copyright (c) 2014-present, Facebook, Inc.
-
-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.
-
-
-tabbable
-MIT
-The MIT License (MIT)
-
-Copyright (c) 2015 David Clark
-
-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.
-
-
-
 toggle-selection
 MIT