keep-a-changelog 2.1.0 → 2.3.0

package/script/deps/deno.land/std@0.189.0/path/win32.d.ts

@@ -0,0 +1,91 @@
+/// <reference types="node" />
+import type { FormatInputPathObject, ParsedPath } from "./_interface.js";
+export declare const sep = "\\";
+export declare const delimiter = ";";
+/**
+ * Resolves path segments into a `path`
+ * @param pathSegments to process to path
+ */
+export declare function resolve(...pathSegments: string[]): string;
+/**
+ * Normalizes a `path`
+ * @param path to normalize
+ */
+export declare function normalize(path: string): string;
+/**
+ * Verifies whether path is absolute
+ * @param path to verify
+ */
+export declare function isAbsolute(path: string): boolean;
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+export declare function join(...paths: string[]): string;
+/**
+ * It will solve the relative path from `from` to `to`, for instance:
+ *  from = 'C:\\orandea\\test\\aaa'
+ *  to = 'C:\\orandea\\impl\\bbb'
+ * The output of the function should be: '..\\..\\impl\\bbb'
+ * @param from relative path
+ * @param to relative path
+ */
+export declare function relative(from: string, to: string): string;
+/**
+ * Resolves path to a namespace path
+ * @param path to resolve to namespace
+ */
+export declare function toNamespacedPath(path: string): string;
+/**
+ * Return the directory path of a `path`.
+ * @param path - path to extract the directory from.
+ */
+export declare function dirname(path: string): string;
+/**
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @param path - path to extract name from.
+ * @param [suffix] - suffix to remove from extracted name.
+ */
+export declare function basename(path: string, suffix?: string): string;
+/**
+ * Return the extension of the `path` with leading period.
+ * @param path with extension
+ * @returns extension (ex. for `file.ts` returns `.ts`)
+ */
+export declare function extname(path: string): string;
+/**
+ * Generate a path from `FormatInputPathObject` object.
+ * @param pathObject with path
+ */
+export declare function format(pathObject: FormatInputPathObject): string;
+/**
+ * Return a `ParsedPath` object of the `path`.
+ * @param path to process
+ */
+export declare function parse(path: string): ParsedPath;
+/**
+ * Converts a file URL to a path string.
+ *
+ * ```ts
+ *      import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/win32.ts";
+ *      fromFileUrl("file:///home/foo"); // "\\home\\foo"
+ *      fromFileUrl("file:///C:/Users/foo"); // "C:\\Users\\foo"
+ *      fromFileUrl("file://localhost/home/foo"); // "\\\\localhost\\home\\foo"
+ * ```
+ * @param url of a file URL
+ */
+export declare function fromFileUrl(url: string | URL): string;
+/**
+ * Converts a path string to a file URL.
+ *
+ * ```ts
+ *      import { toFileUrl } from "https://deno.land/std@$STD_VERSION/path/win32.ts";
+ *      toFileUrl("\\home\\foo"); // new URL("file:///home/foo")
+ *      toFileUrl("C:\\Users\\foo"); // new URL("file:///C:/Users/foo")
+ *      toFileUrl("\\\\127.0.0.1\\home\\foo"); // new URL("file://127.0.0.1/home/foo")
+ * ```
+ * @param path to convert to file URL
+ */
+export declare function toFileUrl(path: string): URL;

package/script/deps/deno.land/{std@0.120.0 → std@0.189.0}/path/win32.js

@@ -24,13 +24,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toFileUrl = exports.fromFileUrl = exports.parse = exports.format = exports.extname = exports.basename = exports.dirname = exports.toNamespacedPath = exports.relative = exports.join = exports.isAbsolute = exports.normalize = exports.resolve = exports.delimiter = exports.sep = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // Copyright the Browserify authors. MIT License.
 // Ported from https://github.com/browserify/path-browserify/
 // This module is browser compatible.
 const dntShim = __importStar(require("../../../../_dnt.shims.js"));
 const _constants_js_1 = require("./_constants.js");
 const _util_js_1 = require("./_util.js");
-const assert_js_1 = require("../_util/assert.js");
+const asserts_js_1 = require("../_util/asserts.js");
 exports.sep = "\\";
 exports.delimiter = ";";
 /**
@@ -355,7 +356,7 @@ function join(...paths) {
     //   path.join('//server', 'share') -> '\\\\server\\share\\')
     let needsReplace = true;
     let slashCount = 0;
-    (0, assert_js_1.assert)(firstPart != null);
+    (0, asserts_js_1.assert)(firstPart != null);
     if ((0, _util_js_1.isPathSeparator)(firstPart.charCodeAt(0))) {
         ++slashCount;
         const firstLen = firstPart.length;
@@ -538,8 +539,8 @@ function toNamespacedPath(path) {
 }
 exports.toNamespacedPath = toNamespacedPath;
 /**
- * Return the directory name of a `path`.
- * @param path to determine name for
+ * Return the directory path of a `path`.
+ * @param path - path to extract the directory from.
  */
 function dirname(path) {
     (0, _util_js_1.assertPath)(path);
@@ -629,26 +630,27 @@ function dirname(path) {
         else
             end = rootEnd;
     }
-    return path.slice(0, end);
+    return (0, _util_js_1.stripTrailingSeparators)(path.slice(0, end), _util_js_1.isPosixPathSeparator);
 }
 exports.dirname = dirname;
 /**
- * Return the last portion of a `path`. Trailing directory separators are ignored.
- * @param path to process
- * @param ext of path directory
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @param path - path to extract name from.
+ * @param [suffix] - suffix to remove from extracted name.
  */
-function basename(path, ext = "") {
-    if (ext !== undefined && typeof ext !== "string") {
-        throw new TypeError('"ext" argument must be a string');
-    }
+function basename(path, suffix = "") {
     (0, _util_js_1.assertPath)(path);
-    let start = 0;
-    let end = -1;
-    let matchedSlash = true;
-    let i;
+    if (path.length === 0)
+        return path;
+    if (typeof suffix !== "string") {
+        throw new TypeError(`Suffix must be a string. Received ${JSON.stringify(suffix)}`);
+    }
     // Check for a drive letter prefix so as not to mistake the following
     // path separator as an extra separator at the end of the path that can be
     // disregarded
+    let start = 0;
     if (path.length >= 2) {
         const drive = path.charCodeAt(0);
         if ((0, _util_js_1.isWindowsDeviceRoot)(drive)) {
@@ -656,78 +658,15 @@ function basename(path, ext = "") {
                 start = 2;
         }
     }
-    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
-        if (ext.length === path.length && ext === path)
-            return "";
-        let extIdx = ext.length - 1;
-        let firstNonSlashEnd = -1;
-        for (i = path.length - 1; i >= start; --i) {
-            const code = path.charCodeAt(i);
-            if ((0, _util_js_1.isPathSeparator)(code)) {
-                // If we reached a path separator that was not part of a set of path
-                // separators at the end of the string, stop now
-                if (!matchedSlash) {
-                    start = i + 1;
-                    break;
-                }
-            }
-            else {
-                if (firstNonSlashEnd === -1) {
-                    // We saw the first non-path separator, remember this index in case
-                    // we need it if the extension ends up not matching
-                    matchedSlash = false;
-                    firstNonSlashEnd = i + 1;
-                }
-                if (extIdx >= 0) {
-                    // Try to match the explicit extension
-                    if (code === ext.charCodeAt(extIdx)) {
-                        if (--extIdx === -1) {
-                            // We matched the extension, so mark this as the end of our path
-                            // component
-                            end = i;
-                        }
-                    }
-                    else {
-                        // Extension does not match, so our result is the entire path
-                        // component
-                        extIdx = -1;
-                        end = firstNonSlashEnd;
-                    }
-                }
-            }
-        }
-        if (start === end)
-            end = firstNonSlashEnd;
-        else if (end === -1)
-            end = path.length;
-        return path.slice(start, end);
-    }
-    else {
-        for (i = path.length - 1; i >= start; --i) {
-            if ((0, _util_js_1.isPathSeparator)(path.charCodeAt(i))) {
-                // If we reached a path separator that was not part of a set of path
-                // separators at the end of the string, stop now
-                if (!matchedSlash) {
-                    start = i + 1;
-                    break;
-                }
-            }
-            else if (end === -1) {
-                // We saw the first non-path separator, mark this as the end of our
-                // path component
-                matchedSlash = false;
-                end = i + 1;
-            }
-        }
-        if (end === -1)
-            return "";
-        return path.slice(start, end);
-    }
+    const lastSegment = (0, _util_js_1.lastPathSegment)(path, _util_js_1.isPathSeparator, start);
+    const strippedSegment = (0, _util_js_1.stripTrailingSeparators)(lastSegment, _util_js_1.isPathSeparator);
+    return suffix ? (0, _util_js_1.stripSuffix)(strippedSegment, suffix) : strippedSegment;
 }
 exports.basename = basename;
 /**
- * Return the extension of the `path`.
+ * Return the extension of the `path` with leading period.
  * @param path with extension
+ * @returns extension (ex. for `file.ts` returns `.ts`)
  */
 function extname(path) {
     (0, _util_js_1.assertPath)(path);
@@ -863,13 +802,14 @@ function parse(path) {
                             // `path` contains just a drive root, exit early to avoid
                             // unnecessary work
                             ret.root = ret.dir = path;
+                            ret.base = "\\";
                             return ret;
                         }
                         rootEnd = 3;
                     }
                 }
                 else {
-                    // `path` contains just a drive root, exit early to avoid
+                    // `path` contains just a relative drive root, exit early to avoid
                     // unnecessary work
                     ret.root = ret.dir = path;
                     return ret;
@@ -881,6 +821,7 @@ function parse(path) {
         // `path` contains just a path separator, exit early to avoid
         // unnecessary work
         ret.root = ret.dir = path;
+        ret.base = "\\";
         return ret;
     }
     if (rootEnd > 0)
@@ -939,6 +880,8 @@ function parse(path) {
         ret.base = path.slice(startPart, end);
         ret.ext = path.slice(startDot, end);
     }
+    // Fallback to '\' in case there is no basename
+    ret.base = ret.base || "\\";
     // If the directory is the root, use the entire root as the `dir` including
     // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the
     // trailing slash (`C:\abc\def` -> `C:\abc`).
@@ -954,7 +897,7 @@ exports.parse = parse;
  * Converts a file URL to a path string.
  *
  * ```ts
- *      import { fromFileUrl } from "./win32.ts";
+ *      import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/win32.ts";
  *      fromFileUrl("file:///home/foo"); // "\\home\\foo"
  *      fromFileUrl("file:///C:/Users/foo"); // "C:\\Users\\foo"
  *      fromFileUrl("file://localhost/home/foo"); // "\\\\localhost\\home\\foo"
@@ -980,7 +923,7 @@ exports.fromFileUrl = fromFileUrl;
  * Converts a path string to a file URL.
  *
  * ```ts
- *      import { toFileUrl } from "./win32.ts";
+ *      import { toFileUrl } from "https://deno.land/std@$STD_VERSION/path/win32.ts";
  *      toFileUrl("\\home\\foo"); // new URL("file:///home/foo")
  *      toFileUrl("C:\\Users\\foo"); // new URL("file:///C:/Users/foo")
  *      toFileUrl("\\\\127.0.0.1\\home\\foo"); // new URL("file://127.0.0.1/home/foo")

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

@@ -0,0 +1,12 @@
+/** EndOfLine character enum */
+export declare enum EOL {
+    LF = "\n",
+    CRLF = "\r\n"
+}
+/**
+ * Detect the EOL character for string input.
+ * returns null if no newline
+ */
+export declare function detect(content: string): EOL | null;
+/** Format the file to the targeted EOL */
+export declare function format(content: string, eol: EOL): string;

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

@@ -0,0 +1,53 @@
+export declare const parse: typeof decode;
+export declare const stringify: typeof encode;
+export interface EncodeOptions {
+    section?: string;
+    whitespace?: boolean;
+}
+/**
+ * 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
+ */
+export declare function encode(obj: any, opt?: string | EncodeOptions): string;
+/**
+ * Decode the given ini-style formatted document into a nested object.
+ * @param str ini-style document
+ */
+export declare function decode(str: string): any;
+/**
+ * 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
+ */
+export declare function safe(val: string | any): string;
+/**
+ * Unescapes the given string value.
+ * @param val String to unescape
+ */
+export declare function unsafe(val?: string): string;

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

@@ -0,0 +1 @@
+export * from './ini.js';

package/script/mod.d.ts

@@ -0,0 +1,6 @@
+import "./_dnt.polyfills.js";
+import parser from "./src/parser.js";
+import Change from "./src/Change.js";
+import Changelog from "./src/Changelog.js";
+import Release from "./src/Release.js";
+export { Change, Changelog, parser, Release };

package/script/src/Change.d.ts

@@ -0,0 +1,8 @@
+export default class Change {
+    title: string;
+    description: string;
+    issues: string[];
+    static extractIssues(text: string, issues: string[]): string;
+    constructor(title: string, description?: string);
+    toString(): string;
+}

package/script/src/Change.js

@@ -1,6 +1,21 @@
 "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,
@@ -23,21 +38,6 @@ class Change {
         this.title = Change.extractIssues(title, this.issues);
         this.description = Change.extractIssues(description, this.issues);
     }
-    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}]`;
-        });
-    }
     toString() {
         let t = this.title.split("\n").map((line) => `  ${line}`.trimEnd());
         t[0] = "-" + t[0].substr(1);

package/script/src/Changelog.d.ts

@@ -0,0 +1,19 @@
+import Release from "./Release.js";
+import { Semver } from "./deps.js";
+export default class Changelog {
+    flag?: string;
+    title: string;
+    description: string;
+    head: string;
+    footer?: string;
+    url?: string;
+    releases: Release[];
+    tagNameBuilder?: (release: Release) => string;
+    format: "compact" | "markdownlint";
+    constructor(title: string, description?: string);
+    addRelease(release: Release): this;
+    findRelease(version?: Semver | string): Release | undefined;
+    sortReleases(): void;
+    tagName(release: Release): string;
+    toString(): string;
+}

package/script/src/Changelog.js

@@ -51,6 +51,12 @@ class Changelog {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "format", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "compact"
+        });
         this.title = title;
         this.description = description;
     }
@@ -82,6 +88,9 @@ class Changelog {
             t.push("");
         }
         t.push(`# ${this.title}`);
+        if (this.format === "markdownlint") {
+            t.push("");
+        }
         const links = [];
         const compareLinks = [];
         const description = this.description.trim() ||
@@ -90,7 +99,6 @@ class Changelog {
 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("");
             t.push(description);
         }
         this.releases.forEach((release) => {

package/script/src/Release.d.ts

@@ -0,0 +1,27 @@
+import { Semver } from "./deps.js";
+import Change from "./Change.js";
+import Changelog from "./Changelog.js";
+export default class Release {
+    changelog?: Changelog;
+    version?: Semver;
+    date?: Date;
+    yanked: boolean;
+    description: string;
+    changes: Map<string, Change[]>;
+    constructor(version?: string | Semver, date?: string | Date, description?: string);
+    compare(release: Release): number;
+    isEmpty(): boolean;
+    setVersion(version?: string | Semver): void;
+    setDate(date?: Date | string): void;
+    setYanked(yanked?: boolean): this;
+    addChange(type: string, change: Change | string): this;
+    added(change: Change | string): this;
+    changed(change: Change | string): this;
+    deprecated(change: Change | string): this;
+    removed(change: Change | string): this;
+    fixed(change: Change | string): this;
+    security(change: Change | string): this;
+    toString(changelog?: Changelog): string;
+    getCompareLink(changelog?: Changelog): string | undefined;
+    getLinks(changelog: Changelog): string[];
+}

package/script/src/Release.js

@@ -95,6 +95,10 @@ class Release {
         }
         this.date = date;
     }
+    setYanked(yanked = true) {
+        this.yanked = yanked;
+        return this;
+    }
     addChange(type, change) {
         if (!(change instanceof Change_js_1.default)) {
             change = new Change_js_1.default(change);
@@ -143,6 +147,9 @@ class Release {
                 t.push(`## Unreleased${yanked}`);
             }
         }
+        if (changelog?.format === "markdownlint") {
+            t.push("");
+        }
         if (this.description.trim()) {
             t.push(this.description.trim());
             t.push("");
@@ -150,6 +157,9 @@ class Release {
         this.changes.forEach((changes, type) => {
             if (changes.length) {
                 t.push(`### ${type[0].toUpperCase()}${type.substring(1)}`);
+                if (changelog?.format === "markdownlint") {
+                    t.push("");
+                }
                 t = t.concat(changes.map((change) => change.toString()));
                 t.push("");
             }

package/script/src/deps.d.ts

@@ -0,0 +1 @@
+export { default as Semver, eq, } from "../deps/deno.land/std@0.173.0/semver/mod.js";

package/script/src/deps.js

@@ -4,6 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.eq = exports.Semver = void 0;
-var mod_js_1 = require("../deps/deno.land/x/semver@v1.4.0/mod.js");
+var mod_js_1 = require("../deps/deno.land/std@0.173.0/semver/mod.js");
 Object.defineProperty(exports, "Semver", { enumerable: true, get: function () { return __importDefault(mod_js_1).default; } });
 Object.defineProperty(exports, "eq", { enumerable: true, get: function () { return mod_js_1.eq; } });

package/script/src/parser.d.ts

@@ -0,0 +1,11 @@
+import Changelog from "./Changelog.js";
+import Release from "./Release.js";
+export interface Options {
+    /**
+     * Custom function to create Release instances.
+     * Needed if you want to use a custom Release class.
+     */
+    releaseCreator: (version?: string, date?: string, description?: string) => Release;
+}
+/** Parse a markdown string */
+export default function parser(markdown: string, options?: Options): Changelog;

package/script/src/parser.js

@@ -25,7 +25,7 @@ function processTokens(tokens, opts) {
     const changelog = new Changelog_js_1.default("");
     changelog.flag = getContent(tokens, "flag");
     changelog.title = getContent(tokens, "h1", true);
-    changelog.description = getContent(tokens, "p");
+    changelog.description = getTextContent(tokens);
     //Releases
     let release;
     while ((release = getContent(tokens, "h2").toLowerCase())) {
@@ -46,7 +46,7 @@ function processTokens(tokens, opts) {
             throw new Error(`Syntax error in the release title`);
         }
         changelog.addRelease(release);
-        release.description = getContent(tokens, "p");
+        release.description = getTextContent(tokens);
         let type;
         while ((type = getContent(tokens, "h3").toLowerCase())) {
             let change;
@@ -77,7 +77,8 @@ function processTokens(tokens, opts) {
 }
 /** Returns the content of a token */
 function getContent(tokens, type, required = false) {
-    if (!tokens[0] || tokens[0][1] !== type) {
+    const types = Array.isArray(type) ? type : [type];
+    if (!tokens[0] || types.indexOf(tokens[0][1]) === -1) {
         if (required) {
             throw new Error(`Required token missing in: "${tokens[0][0]}"`);
         }
@@ -85,6 +86,21 @@ function getContent(tokens, type, required = false) {
     }
     return tokens.shift()[2].join("\n");
 }
+/** Return the next text content */
+function getTextContent(tokens) {
+    const lines = [];
+    const types = ["p", "li"];
+    while (tokens[0] && types.indexOf(tokens[0][1]) !== -1) {
+        const token = tokens.shift();
+        if (token[1] === "li") {
+            lines.push("- " + token[2].join("\n"));
+        }
+        else {
+            lines.push(token[2].join("\n"));
+        }
+    }
+    return lines.join("\n");
+}
 /** Tokenize a markdown string */
 function tokenize(markdown) {
     const tokens = [];

package/script/test/Change.test.d.ts

@@ -0,0 +1 @@
+export {};

package/script/test/changelog.custom.type.md

@@ -1,5 +1,4 @@
 # Changelog - demo
-
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)