keep-a-changelog 2.0.1 → 2.2.1

package/script/deps/deno.land/std@0.51.0/fs/eol.js

@@ -0,0 +1,34 @@
+"use strict";
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = exports.detect = exports.EOL = void 0;
+/** EndOfLine character enum */
+var EOL;
+(function (EOL) {
+    EOL["LF"] = "\n";
+    EOL["CRLF"] = "\r\n";
+})(EOL = exports.EOL || (exports.EOL = {}));
+const regDetect = /(?:\r?\n)/g;
+/**
+ * Detect the EOL character for string input.
+ * returns null if no newline
+ */
+function detect(content) {
+    const d = content.match(regDetect);
+    if (!d || d.length === 0) {
+        return null;
+    }
+    const crlf = d.filter((x) => x === EOL.CRLF);
+    if (crlf.length > 0) {
+        return EOL.CRLF;
+    }
+    else {
+        return EOL.LF;
+    }
+}
+exports.detect = detect;
+/** Format the file to the targeted EOL */
+function format(content, eol) {
+    return content.replace(regDetect, eol);
+}
+exports.format = format;

package/script/deps/deno.land/x/ini@v2.1.0/ini.js

@@ -0,0 +1,256 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsafe = exports.safe = exports.decode = exports.encode = exports.stringify = exports.parse = void 0;
+const dntShim = __importStar(require("../../../../_dnt.shims.js"));
+const eol = __importStar(require("../../std@0.51.0/fs/eol.js"));
+const isWindows = dntShim.Deno.build.os == "windows";
+const EOL = isWindows ? eol.EOL.CRLF : eol.EOL.LF;
+exports.parse = decode;
+exports.stringify = encode;
+/**
+ * Encode the object `object` into an ini-style formatted string. If the
+ * optional parameter `section` is given, then all top-level properties
+ * of the object are put into this section and the `section`-string is
+ * prepended to all sub-sections, see the usage example above.
+ *
+ * The `options` object may contain the following:
+ * - `section` A string which will be the first `section` in the encoded
+ *   ini data.  Defaults to none.
+ * - `whitespace` Boolean to specify whether to put whitespace around the
+ *   `=` character.  By default, whitespace is omitted, to be friendly to
+ *   some persnickety old parsers that don't tolerate it well.  But some
+ *   find that it's more human-readable and pretty with the whitespace.
+ *
+ * For backwards compatibility reasons, if a `string` options is passed,
+ * then it is assumed to be the `section` value.
+ *
+ * @param obj Object to encode
+ * @param opt Encoding options
+ */
+function encode(obj, opt = { whitespace: false }) {
+    const children = [];
+    let out = '';
+    let options = typeof opt === 'string' ? { section: opt, whitespace: false } : opt;
+    const separator = options.whitespace ? ' = ' : '=';
+    Object.keys(obj).forEach(function (k, _, __) {
+        const val = obj[k];
+        if (val && Array.isArray(val)) {
+            val.forEach(function (item) {
+                out += safe(k + '[]') + separator + safe(item) + EOL;
+            });
+        }
+        else if (val && typeof val === 'object') {
+            children.push(k);
+        }
+        else {
+            out += safe(k) + separator + safe(val) + EOL;
+        }
+    });
+    if (options.section && out.length) {
+        out = '[' + safe(options.section) + ']' + EOL + out;
+    }
+    children.forEach(function (k, _, __) {
+        const nk = dotSplit(k).join('\\.');
+        const section = (options.section ? options.section + '.' : '') + nk;
+        const child = encode(obj[k], {
+            section: section,
+            whitespace: options.whitespace
+        });
+        if (out.length && child.length) {
+            out += EOL;
+        }
+        out += child;
+    });
+    return out;
+}
+exports.encode = encode;
+function dotSplit(str) {
+    return str.replace(/\1/g, '\u0002LITERAL\\1LITERAL\u0002')
+        .replace(/\\\./g, '\u0001')
+        .split(/\./).map(function (part) {
+        return part.replace(/\1/g, '\\.')
+            .replace(/\2LITERAL\\1LITERAL\2/g, '\u0001');
+    });
+}
+/**
+ * Decode the given ini-style formatted document into a nested object.
+ * @param str ini-style document
+ */
+function decode(str) {
+    const out = {};
+    let p = out;
+    //          section     |key      = value
+    const re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
+    const lines = str.split(/[\r\n]+/g);
+    lines.forEach(function (line, _, __) {
+        if (!line || line.match(/^\s*[;#]/))
+            return;
+        const match = line.match(re);
+        if (!match)
+            return;
+        if (match[1] !== undefined) {
+            let section = unsafe(match[1]);
+            p = out[section] = out[section] || {};
+            return;
+        }
+        let key = unsafe(match[2]);
+        let value = match[3] ? unsafe(match[4]) : true;
+        switch (value) {
+            case 'true':
+            case 'false':
+            case 'null': value = JSON.parse(value);
+        }
+        const valueAsFloat = parseFloat(`${value}`);
+        if (!Number.isNaN(valueAsFloat)) {
+            value = valueAsFloat;
+        }
+        // Convert keys with '[]' suffix to an array
+        if (key.length > 2 && key.slice(-2) === '[]') {
+            key = key.substring(0, key.length - 2);
+            if (!p[key]) {
+                p[key] = [];
+            }
+            else if (!Array.isArray(p[key])) {
+                p[key] = [p[key]];
+            }
+        }
+        // safeguard against resetting a previously defined
+        // array by accidentally forgetting the brackets
+        if (Array.isArray(p[key])) {
+            p[key].push(value);
+        }
+        else {
+            p[key] = value;
+        }
+    });
+    // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
+    // use a filter to return the keys that have to be deleted.
+    Object.keys(out).filter(function (k, _, __) {
+        if (!out[k] ||
+            typeof out[k] !== 'object' ||
+            Array.isArray(out[k])) {
+            return false;
+        }
+        // see if the parent section is also an object.
+        // if so, add it to that, and mark this one for deletion
+        const parts = dotSplit(k);
+        let parentSection = out;
+        const lastPart = parts.pop() ?? '';
+        const nl = lastPart.replace(/\\\./g, '.');
+        parts.forEach(function (part, _, __) {
+            if (!parentSection[part] || typeof parentSection[part] !== 'object')
+                parentSection[part] = {};
+            parentSection = parentSection[part];
+        });
+        if (parentSection === out && nl === lastPart) {
+            return false;
+        }
+        parentSection[nl] = out[k];
+        return true;
+    }).forEach(function (del, _, __) {
+        delete out[del];
+    });
+    return out;
+}
+exports.decode = decode;
+function isQuoted(val) {
+    return (val.charAt(0) === '"' && val.slice(-1) === '"') ||
+        (val.charAt(0) === "'" && val.slice(-1) === "'");
+}
+/**
+ * Escapes the string `val` such that it is safe to be used as a key or
+ * value in an ini-file. Basically escapes quotes. For example:
+ *
+ * ```javascript
+ * ini.safe('"unsafe string"')
+ * ```
+ *
+ * would result in
+ *
+ * ```javascript
+ * "\"unsafe string\""
+ * ```
+ * @param val String to escape
+ */
+function safe(val) {
+    return (typeof val !== 'string' ||
+        val.match(/[=\r\n]/) ||
+        val.match(/^\[/) ||
+        (val.length > 1 && isQuoted(val)) ||
+        val !== val.trim())
+        ? JSON.stringify(val)
+        : val.replace(/;/g, '\\;').replace(/#/g, '\\#');
+}
+exports.safe = safe;
+/**
+ * Unescapes the given string value.
+ * @param val String to unescape
+ */
+function unsafe(val = '') {
+    val = val.trim();
+    if (isQuoted(val)) {
+        // remove the single quotes before calling JSON.parse
+        if (val.charAt(0) === "'") {
+            val = val.substr(1, val.length - 2);
+        }
+        try {
+            val = JSON.parse(val);
+        }
+        catch (_) { }
+    }
+    else {
+        // walk the val to find the first unescaped ; character
+        let esc = false;
+        let unesc = '';
+        for (let i = 0, l = val.length; i < l; i++) {
+            const c = val.charAt(i);
+            if (esc) {
+                if ('\\;#'.indexOf(c) !== -1) {
+                    unesc += c;
+                }
+                else {
+                    unesc += '\\' + c;
+                }
+                esc = false;
+            }
+            else if (';#'.indexOf(c) !== -1) {
+                break;
+            }
+            else if (c === '\\') {
+                esc = true;
+            }
+            else {
+                unesc += c;
+            }
+        }
+        if (esc) {
+            unesc += '\\';
+        }
+        return unesc.trim();
+    }
+    return val;
+}
+exports.unsafe = unsafe;

package/script/deps/deno.land/x/ini@v2.1.0/mod.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ini.js"), exports);

package/script/mod.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Release = exports.parser = exports.Changelog = exports.Change = void 0;
+require("./_dnt.polyfills.js");
+const parser_js_1 = __importDefault(require("./src/parser.js"));
+exports.parser = parser_js_1.default;
+const Change_js_1 = __importDefault(require("./src/Change.js"));
+exports.Change = Change_js_1.default;
+const Changelog_js_1 = __importDefault(require("./src/Changelog.js"));
+exports.Changelog = Changelog_js_1.default;
+const Release_js_1 = __importDefault(require("./src/Release.js"));
+exports.Release = Release_js_1.default;

package/script/src/Change.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Change {
+    static extractIssues(text, issues) {
+        return text
+            .replace(/(^|[^\\])\[#(\d+)\](?=[^\(]|$)/g, (_, start, index) => {
+            if (!issues.includes(index)) {
+                issues.push(index);
+            }
+            return `${start}[#${index}]`;
+        })
+            .replace(/(^|[\s,])#(\d+)(?=[\s,\.]|$)/g, (_, start, index) => {
+            if (!issues.includes(index)) {
+                issues.push(index);
+            }
+            return `${start}[#${index}]`;
+        });
+    }
+    constructor(title, description = "") {
+        Object.defineProperty(this, "title", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "issues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.title = Change.extractIssues(title, this.issues);
+        this.description = Change.extractIssues(description, this.issues);
+    }
+    toString() {
+        let t = this.title.split("\n").map((line) => `  ${line}`.trimEnd());
+        t[0] = "-" + t[0].substr(1);
+        if (this.description) {
+            t.push("");
+            t = t.concat(this.description.split("\n").map((line) => `  ${line}`.trimEnd()));
+        }
+        return t.join("\n").trim();
+    }
+}
+exports.default = Change;

package/script/src/Changelog.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const deps_js_1 = require("./deps.js");
+class Changelog {
+    constructor(title, description = "") {
+        Object.defineProperty(this, "flag", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "title", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "head", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "HEAD"
+        });
+        Object.defineProperty(this, "footer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "releases", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "tagNameBuilder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "format", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "compact"
+        });
+        this.title = title;
+        this.description = description;
+    }
+    addRelease(release) {
+        this.releases.push(release);
+        this.sortReleases();
+        release.changelog = this;
+        return this;
+    }
+    findRelease(version) {
+        if (!version) {
+            return this.releases.find((release) => !release.version);
+        }
+        return this.releases.find((release) => release.version && (0, deps_js_1.eq)(release.version, version));
+    }
+    sortReleases() {
+        this.releases.sort((a, b) => a.compare(b));
+    }
+    tagName(release) {
+        if (this.tagNameBuilder) {
+            return this.tagNameBuilder(release);
+        }
+        return `v${release.version}`;
+    }
+    toString() {
+        const t = [];
+        if (this.flag) {
+            t.push(`<!-- ${this.flag} -->`);
+            t.push("");
+        }
+        t.push(`# ${this.title}`);
+        if (this.format === "markdownlint") {
+            t.push("");
+        }
+        const links = [];
+        const compareLinks = [];
+        const description = this.description.trim() ||
+            `All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).`;
+        if (description) {
+            t.push(description);
+        }
+        this.releases.forEach((release) => {
+            t.push("");
+            t.push(release.toString(this));
+            release.getLinks(this).forEach((link) => {
+                if (!links.includes(link)) {
+                    links.push(link);
+                }
+            });
+            const compareLink = release.getCompareLink(this);
+            if (compareLink) {
+                compareLinks.push(compareLink);
+            }
+        });
+        if (links.length) {
+            t.push("");
+            links.sort(compare);
+            links.forEach((link) => t.push(link));
+        }
+        if (compareLinks.length) {
+            t.push("");
+            compareLinks.forEach((link) => t.push(link));
+        }
+        t.push("");
+        if (this.footer) {
+            t.push("---");
+            t.push("");
+            t.push(this.footer);
+            t.push("");
+        }
+        return t.join("\n");
+    }
+}
+exports.default = Changelog;
+function compare(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    const reg = /^\[#(\d+)\]:/;
+    const aNumber = a.match(reg);
+    const bNumber = b.match(reg);
+    if (aNumber && bNumber) {
+        return parseInt(aNumber[1]) - parseInt(bNumber[1]);
+    }
+    return a < b ? -1 : 1;
+}