keep-a-changelog 0.10.4 → 2.0.0-beta

package/umd/deps/deno_land/std_0.113.0/flags/mod.js

@@ -0,0 +1,268 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../_util/assert.js"], factory);
+    }
+})(function (require, exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parse = void 0;
+    const assert_js_1 = require("../_util/assert.js");
+    const { hasOwn } = Object;
+    function get(obj, key) {
+        if (hasOwn(obj, key)) {
+            return obj[key];
+        }
+    }
+    function getForce(obj, key) {
+        const v = get(obj, key);
+        (0, assert_js_1.assert)(v != null);
+        return v;
+    }
+    function isNumber(x) {
+        if (typeof x === "number")
+            return true;
+        if (/^0x[0-9a-f]+$/i.test(String(x)))
+            return true;
+        return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(String(x));
+    }
+    function hasKey(obj, keys) {
+        let o = obj;
+        keys.slice(0, -1).forEach((key) => {
+            o = (get(o, key) ?? {});
+        });
+        const key = keys[keys.length - 1];
+        return key in o;
+    }
+    /** Take a set of command line arguments, with an optional set of options, and
+     * return an object representation of those argument.
+     *
+     * ```ts
+     *      import { parse } from "./mod.ts";
+     *      const parsedArgs = parse(Deno.args);
+     * ```
+     */
+    function parse(args, { "--": doubleDash = false, alias = {}, boolean = false, default: defaults = {}, stopEarly = false, string = [], unknown = (i) => i, } = {}) {
+        const flags = {
+            bools: {},
+            strings: {},
+            unknownFn: unknown,
+            allBools: false,
+        };
+        if (boolean !== undefined) {
+            if (typeof boolean === "boolean") {
+                flags.allBools = !!boolean;
+            }
+            else {
+                const booleanArgs = typeof boolean === "string" ? [boolean] : boolean;
+                for (const key of booleanArgs.filter(Boolean)) {
+                    flags.bools[key] = true;
+                }
+            }
+        }
+        const aliases = {};
+        if (alias !== undefined) {
+            for (const key in alias) {
+                const val = getForce(alias, key);
+                if (typeof val === "string") {
+                    aliases[key] = [val];
+                }
+                else {
+                    aliases[key] = val;
+                }
+                for (const alias of getForce(aliases, key)) {
+                    aliases[alias] = [key].concat(aliases[key].filter((y) => alias !== y));
+                }
+            }
+        }
+        if (string !== undefined) {
+            const stringArgs = typeof string === "string" ? [string] : string;
+            for (const key of stringArgs.filter(Boolean)) {
+                flags.strings[key] = true;
+                const alias = get(aliases, key);
+                if (alias) {
+                    for (const al of alias) {
+                        flags.strings[al] = true;
+                    }
+                }
+            }
+        }
+        const argv = { _: [] };
+        function argDefined(key, arg) {
+            return ((flags.allBools && /^--[^=]+$/.test(arg)) ||
+                get(flags.bools, key) ||
+                !!get(flags.strings, key) ||
+                !!get(aliases, key));
+        }
+        function setKey(obj, keys, value) {
+            let o = obj;
+            keys.slice(0, -1).forEach(function (key) {
+                if (get(o, key) === undefined) {
+                    o[key] = {};
+                }
+                o = get(o, key);
+            });
+            const key = keys[keys.length - 1];
+            if (get(o, key) === undefined ||
+                get(flags.bools, key) ||
+                typeof get(o, key) === "boolean") {
+                o[key] = value;
+            }
+            else if (Array.isArray(get(o, key))) {
+                o[key].push(value);
+            }
+            else {
+                o[key] = [get(o, key), value];
+            }
+        }
+        function setArg(key, val, arg = undefined) {
+            if (arg && flags.unknownFn && !argDefined(key, arg)) {
+                if (flags.unknownFn(arg, key, val) === false)
+                    return;
+            }
+            const value = !get(flags.strings, key) && isNumber(val) ? Number(val) : val;
+            setKey(argv, key.split("."), value);
+            const alias = get(aliases, key);
+            if (alias) {
+                for (const x of alias) {
+                    setKey(argv, x.split("."), value);
+                }
+            }
+        }
+        function aliasIsBoolean(key) {
+            return getForce(aliases, key).some((x) => typeof get(flags.bools, x) === "boolean");
+        }
+        for (const key of Object.keys(flags.bools)) {
+            setArg(key, defaults[key] === undefined ? false : defaults[key]);
+        }
+        let notFlags = [];
+        // all args after "--" are not parsed
+        if (args.includes("--")) {
+            notFlags = args.slice(args.indexOf("--") + 1);
+            args = args.slice(0, args.indexOf("--"));
+        }
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (/^--.+=/.test(arg)) {
+                const m = arg.match(/^--([^=]+)=(.*)$/s);
+                (0, assert_js_1.assert)(m != null);
+                const [, key, value] = m;
+                if (flags.bools[key]) {
+                    const booleanValue = value !== "false";
+                    setArg(key, booleanValue, arg);
+                }
+                else {
+                    setArg(key, value, arg);
+                }
+            }
+            else if (/^--no-.+/.test(arg)) {
+                const m = arg.match(/^--no-(.+)/);
+                (0, assert_js_1.assert)(m != null);
+                setArg(m[1], false, arg);
+            }
+            else if (/^--.+/.test(arg)) {
+                const m = arg.match(/^--(.+)/);
+                (0, assert_js_1.assert)(m != null);
+                const [, key] = m;
+                const next = args[i + 1];
+                if (next !== undefined &&
+                    !/^-/.test(next) &&
+                    !get(flags.bools, key) &&
+                    !flags.allBools &&
+                    (get(aliases, key) ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, next, arg);
+                    i++;
+                }
+                else if (/^(true|false)$/.test(next)) {
+                    setArg(key, next === "true", arg);
+                    i++;
+                }
+                else {
+                    setArg(key, get(flags.strings, key) ? "" : true, arg);
+                }
+            }
+            else if (/^-[^-]+/.test(arg)) {
+                const letters = arg.slice(1, -1).split("");
+                let broken = false;
+                for (let j = 0; j < letters.length; j++) {
+                    const next = arg.slice(j + 2);
+                    if (next === "-") {
+                        setArg(letters[j], next, arg);
+                        continue;
+                    }
+                    if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                        setArg(letters[j], next.split(/=(.+)/)[1], arg);
+                        broken = true;
+                        break;
+                    }
+                    if (/[A-Za-z]/.test(letters[j]) &&
+                        /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                        setArg(letters[j], next, arg);
+                        broken = true;
+                        break;
+                    }
+                    if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+                        setArg(letters[j], arg.slice(j + 2), arg);
+                        broken = true;
+                        break;
+                    }
+                    else {
+                        setArg(letters[j], get(flags.strings, letters[j]) ? "" : true, arg);
+                    }
+                }
+                const [key] = arg.slice(-1);
+                if (!broken && key !== "-") {
+                    if (args[i + 1] &&
+                        !/^(-|--)[^-]/.test(args[i + 1]) &&
+                        !get(flags.bools, key) &&
+                        (get(aliases, key) ? !aliasIsBoolean(key) : true)) {
+                        setArg(key, args[i + 1], arg);
+                        i++;
+                    }
+                    else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+                        setArg(key, args[i + 1] === "true", arg);
+                        i++;
+                    }
+                    else {
+                        setArg(key, get(flags.strings, key) ? "" : true, arg);
+                    }
+                }
+            }
+            else {
+                if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                    argv._.push(flags.strings["_"] ?? !isNumber(arg) ? arg : Number(arg));
+                }
+                if (stopEarly) {
+                    argv._.push(...args.slice(i + 1));
+                    break;
+                }
+            }
+        }
+        for (const key of Object.keys(defaults)) {
+            if (!hasKey(argv, key.split("."))) {
+                setKey(argv, key.split("."), defaults[key]);
+                if (aliases[key]) {
+                    for (const x of aliases[key]) {
+                        setKey(argv, x.split("."), defaults[key]);
+                    }
+                }
+            }
+        }
+        if (doubleDash) {
+            argv["--"] = [];
+            for (const key of notFlags) {
+                argv["--"].push(key);
+            }
+        }
+        else {
+            for (const key of notFlags) {
+                argv._.push(key);
+            }
+        }
+        return argv;
+    }
+    exports.parse = parse;
+});

package/umd/deps/deno_land/std_0.113.0/path/_constants.js

@@ -0,0 +1,57 @@
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CHAR_9 = exports.CHAR_0 = exports.CHAR_EQUAL = exports.CHAR_AMPERSAND = exports.CHAR_AT = exports.CHAR_GRAVE_ACCENT = exports.CHAR_CIRCUMFLEX_ACCENT = exports.CHAR_SEMICOLON = exports.CHAR_PERCENT = exports.CHAR_SINGLE_QUOTE = exports.CHAR_DOUBLE_QUOTE = exports.CHAR_PLUS = exports.CHAR_HYPHEN_MINUS = exports.CHAR_RIGHT_CURLY_BRACKET = exports.CHAR_LEFT_CURLY_BRACKET = exports.CHAR_RIGHT_ANGLE_BRACKET = exports.CHAR_LEFT_ANGLE_BRACKET = exports.CHAR_RIGHT_SQUARE_BRACKET = exports.CHAR_LEFT_SQUARE_BRACKET = exports.CHAR_ZERO_WIDTH_NOBREAK_SPACE = exports.CHAR_NO_BREAK_SPACE = exports.CHAR_SPACE = exports.CHAR_HASH = exports.CHAR_EXCLAMATION_MARK = exports.CHAR_FORM_FEED = exports.CHAR_TAB = exports.CHAR_CARRIAGE_RETURN = exports.CHAR_LINE_FEED = exports.CHAR_UNDERSCORE = exports.CHAR_QUESTION_MARK = exports.CHAR_COLON = exports.CHAR_VERTICAL_LINE = exports.CHAR_BACKWARD_SLASH = exports.CHAR_FORWARD_SLASH = exports.CHAR_DOT = exports.CHAR_LOWERCASE_Z = exports.CHAR_UPPERCASE_Z = exports.CHAR_LOWERCASE_A = exports.CHAR_UPPERCASE_A = void 0;
+    // Alphabet chars.
+    exports.CHAR_UPPERCASE_A = 65; /* A */
+    exports.CHAR_LOWERCASE_A = 97; /* a */
+    exports.CHAR_UPPERCASE_Z = 90; /* Z */
+    exports.CHAR_LOWERCASE_Z = 122; /* z */
+    // Non-alphabetic chars.
+    exports.CHAR_DOT = 46; /* . */
+    exports.CHAR_FORWARD_SLASH = 47; /* / */
+    exports.CHAR_BACKWARD_SLASH = 92; /* \ */
+    exports.CHAR_VERTICAL_LINE = 124; /* | */
+    exports.CHAR_COLON = 58; /* : */
+    exports.CHAR_QUESTION_MARK = 63; /* ? */
+    exports.CHAR_UNDERSCORE = 95; /* _ */
+    exports.CHAR_LINE_FEED = 10; /* \n */
+    exports.CHAR_CARRIAGE_RETURN = 13; /* \r */
+    exports.CHAR_TAB = 9; /* \t */
+    exports.CHAR_FORM_FEED = 12; /* \f */
+    exports.CHAR_EXCLAMATION_MARK = 33; /* ! */
+    exports.CHAR_HASH = 35; /* # */
+    exports.CHAR_SPACE = 32; /*   */
+    exports.CHAR_NO_BREAK_SPACE = 160; /* \u00A0 */
+    exports.CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \uFEFF */
+    exports.CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */
+    exports.CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */
+    exports.CHAR_LEFT_ANGLE_BRACKET = 60; /* < */
+    exports.CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */
+    exports.CHAR_LEFT_CURLY_BRACKET = 123; /* { */
+    exports.CHAR_RIGHT_CURLY_BRACKET = 125; /* } */
+    exports.CHAR_HYPHEN_MINUS = 45; /* - */
+    exports.CHAR_PLUS = 43; /* + */
+    exports.CHAR_DOUBLE_QUOTE = 34; /* " */
+    exports.CHAR_SINGLE_QUOTE = 39; /* ' */
+    exports.CHAR_PERCENT = 37; /* % */
+    exports.CHAR_SEMICOLON = 59; /* ; */
+    exports.CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */
+    exports.CHAR_GRAVE_ACCENT = 96; /* ` */
+    exports.CHAR_AT = 64; /* @ */
+    exports.CHAR_AMPERSAND = 38; /* & */
+    exports.CHAR_EQUAL = 61; /* = */
+    // Digits
+    exports.CHAR_0 = 48; /* 0 */
+    exports.CHAR_9 = 57; /* 9 */
+});

package/umd/deps/deno_land/std_0.113.0/path/_interface.js

@@ -0,0 +1,13 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/deps/deno_land/std_0.113.0/path/_util.js

@@ -0,0 +1,133 @@
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./_constants.js"], factory);
+    }
+})(function (require, exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.encodeWhitespace = exports._format = exports.normalizeString = exports.isWindowsDeviceRoot = exports.isPathSeparator = exports.isPosixPathSeparator = exports.assertPath = void 0;
+    const _constants_js_1 = require("./_constants.js");
+    function assertPath(path) {
+        if (typeof path !== "string") {
+            throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`);
+        }
+    }
+    exports.assertPath = assertPath;
+    function isPosixPathSeparator(code) {
+        return code === _constants_js_1.CHAR_FORWARD_SLASH;
+    }
+    exports.isPosixPathSeparator = isPosixPathSeparator;
+    function isPathSeparator(code) {
+        return isPosixPathSeparator(code) || code === _constants_js_1.CHAR_BACKWARD_SLASH;
+    }
+    exports.isPathSeparator = isPathSeparator;
+    function isWindowsDeviceRoot(code) {
+        return ((code >= _constants_js_1.CHAR_LOWERCASE_A && code <= _constants_js_1.CHAR_LOWERCASE_Z) ||
+            (code >= _constants_js_1.CHAR_UPPERCASE_A && code <= _constants_js_1.CHAR_UPPERCASE_Z));
+    }
+    exports.isWindowsDeviceRoot = isWindowsDeviceRoot;
+    // Resolves . and .. elements in a path with directory names
+    function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
+        let res = "";
+        let lastSegmentLength = 0;
+        let lastSlash = -1;
+        let dots = 0;
+        let code;
+        for (let i = 0, len = path.length; i <= len; ++i) {
+            if (i < len)
+                code = path.charCodeAt(i);
+            else if (isPathSeparator(code))
+                break;
+            else
+                code = _constants_js_1.CHAR_FORWARD_SLASH;
+            if (isPathSeparator(code)) {
+                if (lastSlash === i - 1 || dots === 1) {
+                    // NOOP
+                }
+                else if (lastSlash !== i - 1 && dots === 2) {
+                    if (res.length < 2 ||
+                        lastSegmentLength !== 2 ||
+                        res.charCodeAt(res.length - 1) !== _constants_js_1.CHAR_DOT ||
+                        res.charCodeAt(res.length - 2) !== _constants_js_1.CHAR_DOT) {
+                        if (res.length > 2) {
+                            const lastSlashIndex = res.lastIndexOf(separator);
+                            if (lastSlashIndex === -1) {
+                                res = "";
+                                lastSegmentLength = 0;
+                            }
+                            else {
+                                res = res.slice(0, lastSlashIndex);
+                                lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
+                            }
+                            lastSlash = i;
+                            dots = 0;
+                            continue;
+                        }
+                        else if (res.length === 2 || res.length === 1) {
+                            res = "";
+                            lastSegmentLength = 0;
+                            lastSlash = i;
+                            dots = 0;
+                            continue;
+                        }
+                    }
+                    if (allowAboveRoot) {
+                        if (res.length > 0)
+                            res += `${separator}..`;
+                        else
+                            res = "..";
+                        lastSegmentLength = 2;
+                    }
+                }
+                else {
+                    if (res.length > 0)
+                        res += separator + path.slice(lastSlash + 1, i);
+                    else
+                        res = path.slice(lastSlash + 1, i);
+                    lastSegmentLength = i - lastSlash - 1;
+                }
+                lastSlash = i;
+                dots = 0;
+            }
+            else if (code === _constants_js_1.CHAR_DOT && dots !== -1) {
+                ++dots;
+            }
+            else {
+                dots = -1;
+            }
+        }
+        return res;
+    }
+    exports.normalizeString = normalizeString;
+    function _format(sep, pathObject) {
+        const dir = pathObject.dir || pathObject.root;
+        const base = pathObject.base ||
+            (pathObject.name || "") + (pathObject.ext || "");
+        if (!dir)
+            return base;
+        if (dir === pathObject.root)
+            return dir + base;
+        return dir + sep + base;
+    }
+    exports._format = _format;
+    const WHITESPACE_ENCODINGS = {
+        "\u0009": "%09",
+        "\u000A": "%0A",
+        "\u000B": "%0B",
+        "\u000C": "%0C",
+        "\u000D": "%0D",
+        "\u0020": "%20",
+    };
+    function encodeWhitespace(string) {
+        return string.replaceAll(/[\s]/g, (c) => {
+            return WHITESPACE_ENCODINGS[c] ?? c;
+        });
+    }
+    exports.encodeWhitespace = encodeWhitespace;
+});

package/umd/deps/deno_land/std_0.113.0/path/common.js

@@ -0,0 +1,49 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./separator.js"], factory);
+    }
+})(function (require, exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.common = void 0;
+    const separator_js_1 = require("./separator.js");
+    /** Determines the common path from a set of paths, using an optional separator,
+     * which defaults to the OS default separator.
+     *
+     * ```ts
+     *       import { common } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
+     *       const p = common([
+     *         "./deno/std/path/mod.ts",
+     *         "./deno/std/fs/mod.ts",
+     *       ]);
+     *       console.log(p); // "./deno/std/"
+     * ```
+     */
+    function common(paths, sep = separator_js_1.SEP) {
+        const [first = "", ...remaining] = paths;
+        if (first === "" || remaining.length === 0) {
+            return first.substring(0, first.lastIndexOf(sep) + 1);
+        }
+        const parts = first.split(sep);
+        let endOfPrefix = parts.length;
+        for (const path of remaining) {
+            const compare = path.split(sep);
+            for (let i = 0; i < endOfPrefix; i++) {
+                if (compare[i] !== parts[i]) {
+                    endOfPrefix = i;
+                }
+            }
+            if (endOfPrefix === 0) {
+                return "";
+            }
+        }
+        const prefix = parts.slice(0, endOfPrefix).join(sep);
+        return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`;
+    }
+    exports.common = common;
+});