keep-a-changelog 0.10.3 → 2.0.1

package/esm/deps/deno_land/std_0.120.0/flags/mod.js

@@ -0,0 +1,255 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+import { assert } from "../_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);
+    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);
+ * ```
+ */
+export 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);
+            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-(.+)/);
+            assert(m != null);
+            setArg(m[1], false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            const m = arg.match(/^--(.+)/);
+            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;
+}

package/esm/deps/deno_land/std_0.120.0/path/_constants.js

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

package/esm/deps/deno_land/std_0.120.0/path/_interface.js

@@ -0,0 +1,3 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export {};

package/esm/deps/deno_land/std_0.120.0/path/_util.js

@@ -0,0 +1,114 @@
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+import { CHAR_BACKWARD_SLASH, CHAR_DOT, CHAR_FORWARD_SLASH, CHAR_LOWERCASE_A, CHAR_LOWERCASE_Z, CHAR_UPPERCASE_A, CHAR_UPPERCASE_Z, } from "./_constants.js";
+export function assertPath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`);
+    }
+}
+export function isPosixPathSeparator(code) {
+    return code === CHAR_FORWARD_SLASH;
+}
+export function isPathSeparator(code) {
+    return isPosixPathSeparator(code) || code === CHAR_BACKWARD_SLASH;
+}
+export function isWindowsDeviceRoot(code) {
+    return ((code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ||
+        (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z));
+}
+// Resolves . and .. elements in a path with directory names
+export 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 = 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) !== CHAR_DOT ||
+                    res.charCodeAt(res.length - 2) !== 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 === CHAR_DOT && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+export 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;
+}
+const WHITESPACE_ENCODINGS = {
+    "\u0009": "%09",
+    "\u000A": "%0A",
+    "\u000B": "%0B",
+    "\u000C": "%0C",
+    "\u000D": "%0D",
+    "\u0020": "%20",
+};
+export function encodeWhitespace(string) {
+    return string.replaceAll(/[\s]/g, (c) => {
+        return WHITESPACE_ENCODINGS[c] ?? c;
+    });
+}

package/esm/deps/deno_land/std_0.120.0/path/common.js

@@ -0,0 +1,36 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { SEP } from "./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/"
+ * ```
+ */
+export function common(paths, sep = 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}`;
+}