keep-a-changelog 2.2.1 → 2.4.1

package/script/deps/deno.land/std@0.203.0/semver/parse_range.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRange = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const constants_js_1 = require("./constants.js");
+const _shared_js_1 = require("./_shared.js");
+const parse_comparator_js_1 = require("./parse_comparator.js");
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceTildes(comp) {
+    return comp
+        .trim()
+        .split(/\s+/)
+        .map((comp) => replaceTilde(comp))
+        .join(" ");
+}
+function replaceTilde(comp) {
+    const r = _shared_js_1.re[_shared_js_1.TILDE];
+    return comp.replace(r, (_, M, m, p, pr) => {
+        let ret;
+        if (isX(M)) {
+            ret = "";
+        }
+        else if (isX(m)) {
+            ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        }
+        else if (isX(p)) {
+            // ~1.2 == >=1.2.0 <1.3.0
+            ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+        }
+        else if (pr) {
+            ret = ">=" +
+                M +
+                "." +
+                m +
+                "." +
+                p +
+                "-" +
+                pr +
+                " <" +
+                M +
+                "." +
+                (+m + 1) +
+                ".0";
+        }
+        else {
+            // ~1.2.3 == >=1.2.3 <1.3.0
+            ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
+        }
+        return ret;
+    });
+}
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2.0 --> >=1.2.0 <2.0.0
+function replaceCarets(comp) {
+    return comp
+        .trim()
+        .split(/\s+/)
+        .map((comp) => replaceCaret(comp))
+        .join(" ");
+}
+function replaceCaret(comp) {
+    const r = _shared_js_1.re[_shared_js_1.CARET];
+    return comp.replace(r, (_, M, m, p, pr) => {
+        let ret;
+        if (isX(M)) {
+            ret = "";
+        }
+        else if (isX(m)) {
+            ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        }
+        else if (isX(p)) {
+            if (M === "0") {
+                ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+            }
+            else {
+                ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
+            }
+        }
+        else if (pr) {
+            if (M === "0") {
+                if (m === "0") {
+                    ret = ">=" +
+                        M +
+                        "." +
+                        m +
+                        "." +
+                        p +
+                        "-" +
+                        pr +
+                        " <" +
+                        M +
+                        "." +
+                        m +
+                        "." +
+                        (+p + 1);
+                }
+                else {
+                    ret = ">=" +
+                        M +
+                        "." +
+                        m +
+                        "." +
+                        p +
+                        "-" +
+                        pr +
+                        " <" +
+                        M +
+                        "." +
+                        (+m + 1) +
+                        ".0";
+                }
+            }
+            else {
+                ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) +
+                    ".0.0";
+            }
+        }
+        else {
+            if (M === "0") {
+                if (m === "0") {
+                    ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." +
+                        (+p + 1);
+                }
+                else {
+                    ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
+                }
+            }
+            else {
+                ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
+            }
+        }
+        return ret;
+    });
+}
+function replaceXRanges(comp) {
+    return comp
+        .split(/\s+/)
+        .map((comp) => replaceXRange(comp))
+        .join(" ");
+}
+function replaceXRange(comp) {
+    comp = comp.trim();
+    const r = _shared_js_1.re[_shared_js_1.XRANGE];
+    return comp.replace(r, (ret, gtlt, M, m, p, _pr) => {
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if (gtlt === "=" && anyX) {
+            gtlt = "";
+        }
+        if (xM) {
+            if (gtlt === ">" || gtlt === "<") {
+                // nothing is allowed
+                ret = "<0.0.0";
+            }
+            else {
+                // nothing is forbidden
+                ret = "*";
+            }
+        }
+        else if (gtlt && anyX) {
+            // we know patch is an x, because we have any x at all.
+            // replace X with 0
+            if (xm) {
+                m = 0;
+            }
+            p = 0;
+            if (gtlt === ">") {
+                // >1 => >=2.0.0
+                // >1.2 => >=1.3.0
+                // >1.2.3 => >= 1.2.4
+                gtlt = ">=";
+                if (xm) {
+                    M = +M + 1;
+                    m = 0;
+                    p = 0;
+                }
+                else {
+                    m = +m + 1;
+                    p = 0;
+                }
+            }
+            else if (gtlt === "<=") {
+                // <=0.7.x is actually <0.8.0, since any 0.7.x should
+                // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+                gtlt = "<";
+                if (xm) {
+                    M = +M + 1;
+                }
+                else {
+                    m = +m + 1;
+                }
+            }
+            ret = gtlt + M + "." + m + "." + p;
+        }
+        else if (xm) {
+            ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        }
+        else if (xp) {
+            ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+        }
+        return ret;
+    });
+}
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+function replaceStars(comp) {
+    return comp.trim().replace(_shared_js_1.re[_shared_js_1.STAR], "");
+}
+// This function is passed to string.replace(re[HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 -> >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 -> >=1.2.0 <3.5.0 Any 3.4.x will do
+// 1.2 - 3.4 -> >=1.2.0 <3.5.0
+function hyphenReplace(_$0, from, fM, fm, fp, _fpr, _fb, to, tM, tm, tp, tpr, _tb) {
+    if (isX(fM)) {
+        from = "";
+    }
+    else if (isX(fm)) {
+        from = ">=" + fM + ".0.0";
+    }
+    else if (isX(fp)) {
+        from = ">=" + fM + "." + fm + ".0";
+    }
+    else {
+        from = ">=" + from;
+    }
+    if (isX(tM)) {
+        to = "";
+    }
+    else if (isX(tm)) {
+        to = "<" + (+tM + 1) + ".0.0";
+    }
+    else if (isX(tp)) {
+        to = "<" + tM + "." + (+tm + 1) + ".0";
+    }
+    else if (tpr) {
+        to = "<=" + tM + "." + tm + "." + tp + "-" + tpr;
+    }
+    else {
+        to = "<=" + to;
+    }
+    return (from + " " + to).trim();
+}
+function isX(id) {
+    return !id || id.toLowerCase() === "x" || id === "*";
+}
+/**
+ * Parses a range string into a SemVerRange object or throws a TypeError.
+ * @param range The range string
+ * @returns A valid semantic version range
+ */
+function parseRange(range) {
+    // handle spaces around and between comparator and version
+    range = range.trim().replaceAll(/(?<=<|>|=) /g, "");
+    if (range === "") {
+        return { ranges: [[constants_js_1.ALL]] };
+    }
+    // Split into groups of comparators, these are considered OR'd together.
+    const ranges = range
+        .trim()
+        .split(/\s*\|\|\s*/)
+        .map((range) => {
+        // convert `1.2.3 - 1.2.4` into `>=1.2.3 <=1.2.4`
+        const hr = _shared_js_1.re[_shared_js_1.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace);
+        range = replaceCarets(range);
+        range = replaceTildes(range);
+        range = replaceXRanges(range);
+        range = replaceStars(range);
+        // At this point, the range is completely trimmed and
+        // ready to be split into comparators.
+        // These are considered AND's
+        if (range === "") {
+            return [constants_js_1.ALL];
+        }
+        else {
+            return range
+                .split(" ")
+                .filter((r) => r)
+                .map((r) => (0, parse_comparator_js_1.parseComparator)(r));
+        }
+    });
+    return { ranges };
+}
+exports.parseRange = parseRange;

package/script/deps/deno.land/std@0.203.0/semver/range_format.d.ts

@@ -0,0 +1,8 @@
+import type { SemVerRange } from "./types.js";
+/**
+ * Formats the range into a string
+ * @example >=0.0.0 || <1.0.0
+ * @param range The range to format
+ * @returns A string representation of the range
+ */
+export declare function rangeFormat(range: SemVerRange): string;

package/script/deps/deno.land/std@0.203.0/semver/range_format.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeFormat = void 0;
+const comparator_format_js_1 = require("./comparator_format.js");
+/**
+ * Formats the range into a string
+ * @example >=0.0.0 || <1.0.0
+ * @param range The range to format
+ * @returns A string representation of the range
+ */
+function rangeFormat(range) {
+    return range.ranges.map((c) => c.map((c) => (0, comparator_format_js_1.comparatorFormat)(c)).join(" "))
+        .join("||");
+}
+exports.rangeFormat = rangeFormat;

package/script/deps/deno.land/std@0.203.0/semver/range_intersects.d.ts

@@ -0,0 +1,8 @@
+import type { SemVerRange } from "./types.js";
+/**
+ * The ranges intersect every range of AND comparators intersects with a least one range of OR ranges.
+ * @param r0 range 0
+ * @param r1 range 1
+ * @returns returns true if any
+ */
+export declare function rangeIntersects(r0: SemVerRange, r1: SemVerRange): boolean;

package/script/deps/deno.land/std@0.203.0/semver/range_intersects.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeIntersects = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const comparator_intersects_js_1 = require("./comparator_intersects.js");
+function rangesSatisfiable(ranges) {
+    return ranges.every((r) => {
+        // For each OR at least one AND must be satisfiable
+        return r.ranges.some((comparators) => comparatorsSatisfiable(comparators));
+    });
+}
+function comparatorsSatisfiable(comparators) {
+    // Comparators are satisfiable if they all intersect with each other
+    for (let i = 0; i < comparators.length - 1; i++) {
+        const c0 = comparators[i];
+        for (const c1 of comparators.slice(i + 1)) {
+            if (!(0, comparator_intersects_js_1.comparatorIntersects)(c0, c1)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * The ranges intersect every range of AND comparators intersects with a least one range of OR ranges.
+ * @param r0 range 0
+ * @param r1 range 1
+ * @returns returns true if any
+ */
+function rangeIntersects(r0, r1) {
+    return rangesSatisfiable([r0, r1]) && r0.ranges.some((r00) => {
+        return r1.ranges.some((r11) => {
+            return r00.every((c0) => {
+                return r11.every((c1) => (0, comparator_intersects_js_1.comparatorIntersects)(c0, c1));
+            });
+        });
+    });
+}
+exports.rangeIntersects = rangeIntersects;

package/script/deps/deno.land/std@0.203.0/semver/range_max.d.ts

@@ -0,0 +1,7 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * The maximum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the max for
+ * @returns A valid SemVer or INVALID
+ */
+export declare function rangeMax(range: SemVerRange): SemVer | undefined;

package/script/deps/deno.land/std@0.203.0/semver/range_max.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeMax = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const constants_js_1 = require("./constants.js");
+const sort_js_1 = require("./sort.js");
+const test_range_js_1 = require("./test_range.js");
+/**
+ * The maximum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the max for
+ * @returns A valid SemVer or INVALID
+ */
+function rangeMax(range) {
+    // For and's, you take the smallest max
+    // For or's, you take the biggest max
+    //[ [1 and 2] or [2 and 3] ] = [ 1 or 2 ] = 2
+    return (0, sort_js_1.sort)(range.ranges.map((r) => (0, sort_js_1.sort)(r.filter((c) => (0, test_range_js_1.testRange)(c.max, range)).map((c) => c.max)).shift())).filter((v) => v).pop() ?? constants_js_1.INVALID;
+}
+exports.rangeMax = rangeMax;

package/script/deps/deno.land/std@0.203.0/semver/range_min.d.ts

@@ -0,0 +1,7 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * The minimum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the min for
+ * @returns A valid SemVer or INVALID
+ */
+export declare function rangeMin(range: SemVerRange): SemVer;

package/script/deps/deno.land/std@0.203.0/semver/range_min.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeMin = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const constants_js_1 = require("./constants.js");
+const sort_js_1 = require("./sort.js");
+const test_range_js_1 = require("./test_range.js");
+/**
+ * The minimum valid SemVer for a given range or INVALID
+ * @param range The range to calculate the min for
+ * @returns A valid SemVer or INVALID
+ */
+function rangeMin(range) {
+    // For or's, you take the smallest min
+    //[ [1 and 2] or [2 and 3] ] = [ 2 or 3 ] = 2
+    return (0, sort_js_1.sort)(range.ranges.map((r) => (0, sort_js_1.sort)(r.filter((c) => (0, test_range_js_1.testRange)(c.min, range)).map((c) => c.min)).pop()).filter((v) => v)).shift() ?? constants_js_1.INVALID;
+}
+exports.rangeMin = rangeMin;

package/script/deps/deno.land/std@0.203.0/semver/rcompare.d.ts

@@ -0,0 +1,8 @@
+import type { SemVer } from "./types.js";
+/**
+ * A reverse comparison of two versions. Same as compare but
+ * `1` and `-1` are inverted.
+ *
+ * Sorts in descending order if passed to `Array.sort()`,
+ */
+export declare function rcompare(s0: SemVer, s1: SemVer): 1 | 0 | -1;

package/script/deps/deno.land/std@0.203.0/semver/rcompare.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rcompare = void 0;
+const compare_js_1 = require("./compare.js");
+/**
+ * A reverse comparison of two versions. Same as compare but
+ * `1` and `-1` are inverted.
+ *
+ * Sorts in descending order if passed to `Array.sort()`,
+ */
+function rcompare(s0, s1) {
+    return (0, compare_js_1.compare)(s1, s0);
+}
+exports.rcompare = rcompare;

package/script/deps/deno.land/std@0.203.0/semver/rsort.d.ts

@@ -0,0 +1,3 @@
+import type { SemVer } from "./types.js";
+/** Sorts a list of semantic versions in descending order. */
+export declare function rsort(list: SemVer[]): SemVer[];

package/script/deps/deno.land/std@0.203.0/semver/rsort.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rsort = void 0;
+const compare_js_1 = require("./compare.js");
+/** Sorts a list of semantic versions in descending order. */
+function rsort(list) {
+    return list.sort((a, b) => (0, compare_js_1.compare)(b, a));
+}
+exports.rsort = rsort;

package/script/deps/deno.land/std@0.203.0/semver/sort.d.ts

@@ -0,0 +1,3 @@
+import type { SemVer } from "./types.js";
+/** Sorts a list of semantic versions in ascending order. */
+export declare function sort(list: SemVer[]): SemVer[];

package/script/deps/deno.land/std@0.203.0/semver/sort.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sort = void 0;
+const compare_js_1 = require("./compare.js");
+/** Sorts a list of semantic versions in ascending order. */
+function sort(list) {
+    return list.sort((a, b) => (0, compare_js_1.compare)(a, b));
+}
+exports.sort = sort;

package/script/deps/deno.land/std@0.203.0/semver/test_comparator.d.ts

@@ -0,0 +1,8 @@
+import type { SemVer, SemVerComparator } from "./types.js";
+/**
+ * Test to see if a semantic version falls within the range of the comparator.
+ * @param version The version to compare
+ * @param comparator The comparator
+ * @returns True if the version is within the comparators set otherwise false
+ */
+export declare function testComparator(version: SemVer, comparator: SemVerComparator): boolean;

package/script/deps/deno.land/std@0.203.0/semver/test_comparator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testComparator = void 0;
+const cmp_js_1 = require("./cmp.js");
+/**
+ * Test to see if a semantic version falls within the range of the comparator.
+ * @param version The version to compare
+ * @param comparator The comparator
+ * @returns True if the version is within the comparators set otherwise false
+ */
+function testComparator(version, comparator) {
+    return (0, cmp_js_1.cmp)(version, comparator.operator, comparator.semver);
+}
+exports.testComparator = testComparator;

package/script/deps/deno.land/std@0.203.0/semver/test_range.d.ts

@@ -0,0 +1,8 @@
+import type { SemVer, SemVerRange } from "./types.js";
+/**
+ * Test to see if the version satisfies the range.
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ */
+export declare function testRange(version: SemVer, range: SemVerRange): boolean;

package/script/deps/deno.land/std@0.203.0/semver/test_range.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testRange = void 0;
+const gte_js_1 = require("./gte.js");
+const lte_js_1 = require("./lte.js");
+/**
+ * Test to see if the version satisfies the range.
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ */
+function testRange(version, range) {
+    for (const r of range.ranges) {
+        if (r.every((c) => (0, gte_js_1.gte)(version, c.min) && (0, lte_js_1.lte)(version, c.max))) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.testRange = testRange;

package/script/deps/deno.land/std@0.203.0/semver/types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The possible release types are used as an operator for the
+ * increment function and as a result of the difference function.
+ */
+export type ReleaseType = "pre" | "major" | "premajor" | "minor" | "preminor" | "patch" | "prepatch" | "prerelease";
+/**
+ * SemVer comparison operators.
+ */
+export type Operator = "" | "=" | "==" | "===" | "!==" | "!=" | ">" | ">=" | "<" | "<=";
+/**
+ * The style to use when formatting a SemVer object into a string
+ */
+export type FormatStyle = "full" | "release" | "primary" | "build" | "pre" | "patch" | "minor" | "major";
+/**
+ * The shape of a valid semantic version comparator
+ * @example >=0.0.0
+ */
+export interface SemVerComparator {
+    operator: Operator;
+    semver: SemVer;
+    min: SemVer;
+    max: SemVer;
+}
+/**
+ * A SemVer object parsed into its constituent parts.
+ */
+export interface SemVer {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: (string | number)[];
+    build: string[];
+}
+type SemVerRangeAnd = SemVerComparator[];
+type SemVerRangeOr = SemVerRangeAnd[];
+/**
+ * A type representing a semantic version range. The ranges consist of
+ * a nested array, which represents a set of OR comparisons while the
+ * inner array represents AND comparisons.
+ */
+export interface SemVerRange {
+    ranges: SemVerRangeOr;
+}
+export {};

package/script/deps/deno.land/std@0.203.0/semver/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });

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 };