keep-a-changelog 0.10.4 → 2.0.0-beta

package/types/deps/deno_land/std_0.113.0/path/mod.d.ts

@@ -0,0 +1,9 @@
+import * as _win32 from "./win32.js";
+import * as _posix from "./posix.js";
+export declare const win32: typeof _win32;
+export declare const posix: typeof _posix;
+export declare const basename: typeof _posix.basename | typeof _win32.basename, delimiter: string, dirname: typeof _posix.dirname | typeof _win32.dirname, extname: typeof _posix.extname | typeof _win32.extname, format: typeof _posix.format | typeof _win32.format, fromFileUrl: typeof _posix.fromFileUrl | typeof _win32.fromFileUrl, isAbsolute: typeof _win32.isAbsolute | typeof _posix.isAbsolute, join: typeof _posix.join | typeof _win32.join, normalize: typeof _win32.normalize | typeof _posix.normalize, parse: typeof _posix.parse | typeof _win32.parse, relative: typeof _posix.relative | typeof _win32.relative, resolve: typeof _win32.resolve | typeof _posix.resolve, sep: string, toFileUrl: typeof _posix.toFileUrl | typeof _win32.toFileUrl, toNamespacedPath: typeof _posix.toNamespacedPath | typeof _win32.toNamespacedPath;
+export * from "./common.js";
+export { SEP, SEP_PATTERN } from "./separator.js";
+export * from "./_interface.js";
+export * from "./glob.js";

package/types/deps/deno_land/std_0.113.0/path/posix.d.ts

@@ -0,0 +1,80 @@
+import type { FormatInputPathObject, ParsedPath } from "./_interface.js";
+export declare const sep = "/";
+export declare const delimiter = ":";
+/**
+ * Resolves `pathSegments` into an absolute path.
+ * @param pathSegments an array of path segments
+ */
+export declare function resolve(...pathSegments: string[]): string;
+/**
+ * Normalize the `path`, resolving `'..'` and `'.'` segments.
+ * @param path to be normalized
+ */
+export declare function normalize(path: string): string;
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+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;
+/**
+ * Return the relative path from `from` to `to` based on current working directory.
+ * @param from path in current working directory
+ * @param to path in current working directory
+ */
+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 name of a `path`.
+ * @param path to determine name for
+ */
+export declare function dirname(path: string): string;
+/**
+ * Return the last portion of a `path`. Trailing directory separators are ignored.
+ * @param path to process
+ * @param ext of path directory
+ */
+export declare function basename(path: string, ext?: string): string;
+/**
+ * Return the extension of the `path`.
+ * @param path with extension
+ */
+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 "./posix.ts";
+ *      fromFileUrl("file:///home/foo"); // "/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 "./posix.ts";
+ *      toFileUrl("/home/foo"); // new URL("file:///home/foo")
+ * ```
+ * @param path to convert to file URL
+ */
+export declare function toFileUrl(path: string): URL;

package/types/deps/deno_land/std_0.113.0/path/separator.d.ts

@@ -0,0 +1,2 @@
+export declare const SEP: string;
+export declare const SEP_PATTERN: RegExp;

package/types/deps/deno_land/std_0.113.0/path/win32.d.ts

@@ -0,0 +1,87 @@
+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 name of a `path`.
+ * @param path to determine name for
+ */
+export declare function dirname(path: string): string;
+/**
+ * Return the last portion of a `path`. Trailing directory separators are ignored.
+ * @param path to process
+ * @param ext of path directory
+ */
+export declare function basename(path: string, ext?: string): string;
+/**
+ * Return the extension of the `path`.
+ * @param path with extension
+ */
+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 "./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 "./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/types/deps/deno_land/std_0.115.1/fmt/colors.d.ts

@@ -0,0 +1,270 @@
+/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */
+interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Set changing text color to enabled or disabled
+ * @param value
+ */
+export declare function setColorEnabled(value: boolean): void;
+/** Get whether text color change is enabled or disabled. */
+export declare function getColorEnabled(): boolean;
+/**
+ * Reset the text modified
+ * @param str text to reset
+ */
+export declare function reset(str: string): string;
+/**
+ * Make the text bold.
+ * @param str text to make bold
+ */
+export declare function bold(str: string): string;
+/**
+ * The text emits only a small amount of light.
+ * @param str text to dim
+ */
+export declare function dim(str: string): string;
+/**
+ * Make the text italic.
+ * @param str text to make italic
+ */
+export declare function italic(str: string): string;
+/**
+ * Make the text underline.
+ * @param str text to underline
+ */
+export declare function underline(str: string): string;
+/**
+ * Invert background color and text color.
+ * @param str text to invert its color
+ */
+export declare function inverse(str: string): string;
+/**
+ * Make the text hidden.
+ * @param str text to hide
+ */
+export declare function hidden(str: string): string;
+/**
+ * Put horizontal line through the center of the text.
+ * @param str text to strike through
+ */
+export declare function strikethrough(str: string): string;
+/**
+ * Set text color to black.
+ * @param str text to make black
+ */
+export declare function black(str: string): string;
+/**
+ * Set text color to red.
+ * @param str text to make red
+ */
+export declare function red(str: string): string;
+/**
+ * Set text color to green.
+ * @param str text to make green
+ */
+export declare function green(str: string): string;
+/**
+ * Set text color to yellow.
+ * @param str text to make yellow
+ */
+export declare function yellow(str: string): string;
+/**
+ * Set text color to blue.
+ * @param str text to make blue
+ */
+export declare function blue(str: string): string;
+/**
+ * Set text color to magenta.
+ * @param str text to make magenta
+ */
+export declare function magenta(str: string): string;
+/**
+ * Set text color to cyan.
+ * @param str text to make cyan
+ */
+export declare function cyan(str: string): string;
+/**
+ * Set text color to white.
+ * @param str text to make white
+ */
+export declare function white(str: string): string;
+/**
+ * Set text color to gray.
+ * @param str text to make gray
+ */
+export declare function gray(str: string): string;
+/**
+ * Set text color to bright black.
+ * @param str text to make bright-black
+ */
+export declare function brightBlack(str: string): string;
+/**
+ * Set text color to bright red.
+ * @param str text to make bright-red
+ */
+export declare function brightRed(str: string): string;
+/**
+ * Set text color to bright green.
+ * @param str text to make bright-green
+ */
+export declare function brightGreen(str: string): string;
+/**
+ * Set text color to bright yellow.
+ * @param str text to make bright-yellow
+ */
+export declare function brightYellow(str: string): string;
+/**
+ * Set text color to bright blue.
+ * @param str text to make bright-blue
+ */
+export declare function brightBlue(str: string): string;
+/**
+ * Set text color to bright magenta.
+ * @param str text to make bright-magenta
+ */
+export declare function brightMagenta(str: string): string;
+/**
+ * Set text color to bright cyan.
+ * @param str text to make bright-cyan
+ */
+export declare function brightCyan(str: string): string;
+/**
+ * Set text color to bright white.
+ * @param str text to make bright-white
+ */
+export declare function brightWhite(str: string): string;
+/**
+ * Set background color to black.
+ * @param str text to make its background black
+ */
+export declare function bgBlack(str: string): string;
+/**
+ * Set background color to red.
+ * @param str text to make its background red
+ */
+export declare function bgRed(str: string): string;
+/**
+ * Set background color to green.
+ * @param str text to make its background green
+ */
+export declare function bgGreen(str: string): string;
+/**
+ * Set background color to yellow.
+ * @param str text to make its background yellow
+ */
+export declare function bgYellow(str: string): string;
+/**
+ * Set background color to blue.
+ * @param str text to make its background blue
+ */
+export declare function bgBlue(str: string): string;
+/**
+ *  Set background color to magenta.
+ * @param str text to make its background magenta
+ */
+export declare function bgMagenta(str: string): string;
+/**
+ * Set background color to cyan.
+ * @param str text to make its background cyan
+ */
+export declare function bgCyan(str: string): string;
+/**
+ * Set background color to white.
+ * @param str text to make its background white
+ */
+export declare function bgWhite(str: string): string;
+/**
+ * Set background color to bright black.
+ * @param str text to make its background bright-black
+ */
+export declare function bgBrightBlack(str: string): string;
+/**
+ * Set background color to bright red.
+ * @param str text to make its background bright-red
+ */
+export declare function bgBrightRed(str: string): string;
+/**
+ * Set background color to bright green.
+ * @param str text to make its background bright-green
+ */
+export declare function bgBrightGreen(str: string): string;
+/**
+ * Set background color to bright yellow.
+ * @param str text to make its background bright-yellow
+ */
+export declare function bgBrightYellow(str: string): string;
+/**
+ * Set background color to bright blue.
+ * @param str text to make its background bright-blue
+ */
+export declare function bgBrightBlue(str: string): string;
+/**
+ * Set background color to bright magenta.
+ * @param str text to make its background bright-magenta
+ */
+export declare function bgBrightMagenta(str: string): string;
+/**
+ * Set background color to bright cyan.
+ * @param str text to make its background bright-cyan
+ */
+export declare function bgBrightCyan(str: string): string;
+/**
+ * Set background color to bright white.
+ * @param str text to make its background bright-white
+ */
+export declare function bgBrightWhite(str: string): string;
+/**
+ * Set text color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit colors to
+ * @param color code
+ */
+export declare function rgb8(str: string, color: number): string;
+/**
+ * Set background color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit background colors to
+ * @param color code
+ */
+export declare function bgRgb8(str: string, color: number): string;
+/**
+ * Set text color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ * ```ts
+ *      import { rgb24 } from "./colors.ts";
+ *      rgb24("foo", 0xff00ff);
+ *      rgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function rgb24(str: string, color: number | Rgb): string;
+/**
+ * Set background color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ * ```ts
+ *      import { bgRgb24 } from "./colors.ts";
+ *      bgRgb24("foo", 0xff00ff);
+ *      bgRgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function bgRgb24(str: string, color: number | Rgb): string;
+/**
+ * Remove ANSI escape codes from the string.
+ * @param string to remove ANSI escape codes from
+ */
+export declare function stripColor(string: string): string;
+export {};

package/types/deps/deno_land/std_0.115.1/testing/_diff.d.ts

@@ -0,0 +1,23 @@
+export declare enum DiffType {
+    removed = "removed",
+    common = "common",
+    added = "added"
+}
+export interface DiffResult<T> {
+    type: DiffType;
+    value: T;
+    details?: Array<DiffResult<T>>;
+}
+/**
+ * Renders the differences between the actual and expected values
+ * @param A Actual value
+ * @param B Expected value
+ */
+export declare function diff<T>(A: T[], B: T[]): Array<DiffResult<T>>;
+/**
+ * Renders the differences between the actual and expected strings
+ * Partially inspired from https://github.com/kpdecker/jsdiff
+ * @param A Actual string
+ * @param B Expected string
+ */
+export declare function diffstr(A: string, B: string): DiffResult<string>[];

package/types/deps/deno_land/std_0.115.1/testing/asserts.d.ts

@@ -0,0 +1,151 @@
+export declare class AssertionError extends Error {
+    name: string;
+    constructor(message: string);
+}
+/**
+ * Converts the input into a string. Objects, Sets and Maps are sorted so as to
+ * make tests less flaky
+ * @param v Value to be formatted
+ */
+export declare function _format(v: unknown): string;
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ */
+export declare function equal(c: unknown, d: unknown): boolean;
+/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;
+/**
+ * Make an assertion that `actual` and `expected` are equal, deeply. If not
+ * deeply equal, then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ * For example:
+ * ```ts
+ * import { assertEquals } from "./asserts.ts";
+ *
+ * assertEquals<number>(1, 2)
+ * ```
+ */
+export declare function assertEquals(actual: unknown, expected: unknown, msg?: string): void;
+export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are not equal, deeply.
+ * If not then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ * For example:
+ * ```ts
+ * import { assertNotEquals } from "./asserts.ts";
+ *
+ * assertNotEquals<number>(1, 2)
+ * ```
+ */
+export declare function assertNotEquals(actual: unknown, expected: unknown, msg?: string): void;
+export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are strictly equal. If
+ * not then throw.
+ *
+ * ```ts
+ * import { assertStrictEquals } from "./asserts.ts";
+ *
+ * assertStrictEquals(1, 2)
+ * ```
+ */
+export declare function assertStrictEquals(actual: unknown, expected: unknown, msg?: string): void;
+export declare function assertStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are not strictly equal.
+ * If the values are strictly equal then throw.
+ *
+ * ```ts
+ * import { assertNotStrictEquals } from "./asserts.ts";
+ *
+ * assertNotStrictEquals(1, 1)
+ * ```
+ */
+export declare function assertNotStrictEquals(actual: unknown, expected: unknown, msg?: string): void;
+export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ */
+export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ */
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
+/**
+ * Make an assertion that `actual` includes the `expected` values.
+ * If not then an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ * For example:
+ *
+ * ```ts
+ * import { assertArrayIncludes } from "./asserts.ts";
+ *
+ * assertArrayIncludes<number>([1, 2], [2])
+ * ```
+ */
+export declare function assertArrayIncludes(actual: ArrayLike<unknown>, expected: ArrayLike<unknown>, msg?: string): void;
+export declare function assertArrayIncludes<T>(actual: ArrayLike<T>, expected: ArrayLike<T>, msg?: string): void;
+/**
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ */
+export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ */
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
+/**
+ * Make an assertion that `actual` object is a subset of `expected` object, deeply.
+ * If not, then throw.
+ */
+export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>): void;
+/**
+ * Forcefully throws a failed assertion
+ */
+export declare function fail(msg?: string): never;
+/**
+ * Make an assertion that `error` is an `Error`.
+ * If not then an error will be thrown.
+ * An error class and a string that should be included in the
+ * error message can also be asserted.
+ */
+export declare function assertIsError<E extends Error = Error>(error: unknown, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): asserts error is E;
+/**
+ * Executes a function, expecting it to throw.  If it does not, then it
+ * throws. An error class and a string that should be included in the
+ * error message can also be asserted. Or you can pass a
+ * callback which will be passed the error, usually to apply some custom
+ * assertions on it.
+ */
+export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): void;
+export declare function assertThrows(fn: () => unknown, errorCallback: (e: Error) => unknown, msg?: string): void;
+/**
+ * Executes a function which returns a promise, expecting it to throw or reject.
+ * If it does not, then it throws. An error class and a string that should be
+ * included in the error message can also be asserted. Or you can pass a
+ * callback which will be passed the error, usually to apply some custom
+ * assertions on it.
+ */
+export declare function assertRejects<E extends Error = Error>(fn: () => Promise<unknown>, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<void>;
+export declare function assertRejects(fn: () => Promise<unknown>, errorCallback: (e: Error) => unknown, msg?: string): Promise<void>;
+/**
+ * Executes a function which returns a promise, expecting it to throw or reject.
+ * If it does not, then it throws.  An error class and a string that should be
+ * included in the error message can also be asserted.
+ *
+ * @deprecated Use assertRejects instead.
+ */
+export declare const assertThrowsAsync: typeof assertRejects;
+/** Use this to stub out methods that will throw when invoked. */
+export declare function unimplemented(msg?: string): never;
+/** Use this to assert unreachable code. */
+export declare function unreachable(): never;

package/types/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/types/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/types/deps/deno_land/x/ini_v2.1.0/mod.d.ts

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