keep-a-changelog 0.10.3 → 2.0.1

package/types/deps/deno_land/std_0.120.0/path/glob.d.ts

@@ -0,0 +1,78 @@
+import type { OSType } from "../_util/os.js";
+export interface GlobOptions {
+    /** Extended glob syntax.
+     * See https://www.linuxjournal.com/content/bash-extended-globbing. Defaults
+     * to true. */
+    extended?: boolean;
+    /** Globstar syntax.
+     * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
+     * If false, `**` is treated like `*`. Defaults to true. */
+    globstar?: boolean;
+    /** Whether globstar should be case insensitive. */
+    caseInsensitive?: boolean;
+    /** Operating system. Defaults to the native OS. */
+    os?: OSType;
+}
+export declare type GlobToRegExpOptions = GlobOptions;
+/** Convert a glob string to a regular expression.
+ *
+ * Tries to match bash glob expansion as closely as possible.
+ *
+ * Basic glob syntax:
+ * - `*` - Matches everything without leaving the path segment.
+ * - `?` - Matches any single character.
+ * - `{foo,bar}` - Matches `foo` or `bar`.
+ * - `[abcd]` - Matches `a`, `b`, `c` or `d`.
+ * - `[a-d]` - Matches `a`, `b`, `c` or `d`.
+ * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.
+ * - `[[:<class>:]]` - Matches any character belonging to `<class>`.
+ *     - `[[:alnum:]]` - Matches any digit or letter.
+ *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.
+ *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes
+ *       for a complete list of supported character classes.
+ * - `\` - Escapes the next character for an `os` other than `"windows"`.
+ * - \` - Escapes the next character for `os` set to `"windows"`.
+ * - `/` - Path separator.
+ * - `\` - Additional path separator only for `os` set to `"windows"`.
+ *
+ * Extended syntax:
+ * - Requires `{ extended: true }`.
+ * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.
+ * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.
+ * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.
+ * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.
+ * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.
+ * - See https://www.linuxjournal.com/content/bash-extended-globbing.
+ *
+ * Globstar syntax:
+ * - Requires `{ globstar: true }`.
+ * - `**` - Matches any number of any path segments.
+ *     - Must comprise its entire path segment in the provided glob.
+ * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
+ *
+ * Note the following properties:
+ * - The generated `RegExp` is anchored at both start and end.
+ * - Repeating and trailing separators are tolerated. Trailing separators in the
+ *   provided glob have no meaning and are discarded.
+ * - Absolute globs will only match absolute paths, etc.
+ * - Empty globs will match nothing.
+ * - Any special glob syntax must be contained to one path segment. For example,
+ *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the
+ *   first segment ends with an unclosed group.
+ * - If a path segment ends with unclosed groups or a dangling escape prefix, a
+ *   parse error has occurred. Every character for that segment is taken
+ *   literally in this event.
+ *
+ * Limitations:
+ * - A negative group like `!(foo|bar)` will wrongly be converted to a negative
+ *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly
+ *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,
+ *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if
+ *   the group occurs not nested at the end of the segment. */
+export declare function globToRegExp(glob: string, { extended, globstar: globstarOption, os, caseInsensitive, }?: GlobToRegExpOptions): RegExp;
+/** Test whether the given string is a glob */
+export declare function isGlob(str: string): boolean;
+/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
+export declare function normalizeGlob(glob: string, { globstar }?: GlobOptions): string;
+/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
+export declare function joinGlobs(globs: string[], { extended, globstar }?: GlobOptions): string;

package/types/deps/deno_land/std_0.120.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.120.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.120.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.120.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.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';

package/types/deps/deno_land/x/semver_v1.4.0/mod.d.ts

@@ -0,0 +1,116 @@
+export declare type ReleaseType = "pre" | "major" | "premajor" | "minor" | "preminor" | "patch" | "prepatch" | "prerelease";
+export declare type Operator = "===" | "!==" | "" | "=" | "==" | "!=" | ">" | ">=" | "<" | "<=";
+export interface Options {
+    loose?: boolean;
+    includePrerelease?: boolean;
+}
+export declare const SEMVER_SPEC_VERSION = "2.0.0";
+export declare function parse(version: string | SemVer | null, optionsOrLoose?: boolean | Options): SemVer | null;
+export declare function valid(version: string | SemVer | null, optionsOrLoose?: boolean | Options): string | null;
+export declare function clean(version: string, optionsOrLoose?: boolean | Options): string | null;
+export declare class SemVer {
+    raw: string;
+    loose: boolean;
+    options: Options;
+    major: number;
+    minor: number;
+    patch: number;
+    version: string;
+    build: ReadonlyArray<string>;
+    prerelease: Array<string | number>;
+    constructor(version: string | SemVer, optionsOrLoose?: boolean | Options);
+    format(): string;
+    compare(other: string | SemVer): 1 | 0 | -1;
+    compareMain(other: string | SemVer): 1 | 0 | -1;
+    comparePre(other: string | SemVer): 1 | 0 | -1;
+    compareBuild(other: string | SemVer): 1 | 0 | -1;
+    inc(release: ReleaseType, identifier?: string): SemVer;
+    toString(): string;
+}
+/**
+ * Return the version incremented by the release type (major, minor, patch, or prerelease), or null if it's not valid.
+ */
+export declare function inc(version: string | SemVer, release: ReleaseType, optionsOrLoose?: boolean | Options, identifier?: string): string | null;
+export declare function diff(version1: string | SemVer, version2: string | SemVer, optionsOrLoose?: boolean | Options): ReleaseType | null;
+export declare function compareIdentifiers(a: string | number | null, b: string | number | null): 1 | 0 | -1;
+export declare function rcompareIdentifiers(a: string | null, b: string | null): 1 | 0 | -1;
+/**
+ * Return the major version number.
+ */
+export declare function major(v: string | SemVer, optionsOrLoose?: boolean | Options): number;
+/**
+ * Return the minor version number.
+ */
+export declare function minor(v: string | SemVer, optionsOrLoose?: boolean | Options): number;
+/**
+ * Return the patch version number.
+ */
+export declare function patch(v: string | SemVer, optionsOrLoose?: boolean | Options): number;
+export declare function compare(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): 1 | 0 | -1;
+export declare function compareLoose(a: string | SemVer, b: string | SemVer): 1 | 0 | -1;
+export declare function compareBuild(a: string | SemVer, b: string | SemVer, loose?: boolean | Options): 1 | 0 | -1;
+export declare function rcompare(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): 1 | 0 | -1;
+export declare function sort<T extends string | SemVer>(list: T[], optionsOrLoose?: boolean | Options): T[];
+export declare function rsort<T extends string | SemVer>(list: T[], optionsOrLoose?: boolean | Options): T[];
+export declare function gt(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function lt(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function eq(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function neq(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function gte(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function lte(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function cmp(v1: string | SemVer, operator: Operator, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare class Comparator {
+    semver: SemVer;
+    operator: "" | "=" | "<" | ">" | "<=" | ">=";
+    value: string;
+    loose: boolean;
+    options: Options;
+    constructor(comp: string | Comparator, optionsOrLoose?: boolean | Options);
+    parse(comp: string): void;
+    test(version: string | SemVer): boolean;
+    intersects(comp: Comparator, optionsOrLoose?: boolean | Options): boolean;
+    toString(): string;
+}
+export declare class Range {
+    range: string;
+    raw: string;
+    loose: boolean;
+    options: Options;
+    includePrerelease: boolean;
+    set: ReadonlyArray<ReadonlyArray<Comparator>>;
+    constructor(range: string | Range | Comparator, optionsOrLoose?: boolean | Options);
+    format(): string;
+    parseRange(range: string): ReadonlyArray<Comparator>;
+    test(version: string | SemVer): boolean;
+    intersects(range?: Range, optionsOrLoose?: boolean | Options): boolean;
+    toString(): string;
+}
+export declare function toComparators(range: string | Range, optionsOrLoose?: boolean | Options): string[][];
+export declare function satisfies(version: string | SemVer, range: string | Range, optionsOrLoose?: boolean | Options): boolean;
+export declare function maxSatisfying<T extends string | SemVer>(versions: ReadonlyArray<T>, range: string | Range, optionsOrLoose?: boolean | Options): T | null;
+export declare function minSatisfying<T extends string | SemVer>(versions: ReadonlyArray<T>, range: string | Range, optionsOrLoose?: boolean | Options): T | null;
+export declare function minVersion(range: string | Range, optionsOrLoose?: boolean | Options): SemVer | null;
+export declare function validRange(range: string | Range | null, optionsOrLoose?: boolean | Options): string | null;
+/**
+ * Return true if version is less than all the versions possible in the range.
+ */
+export declare function ltr(version: string | SemVer, range: string | Range, optionsOrLoose?: boolean | Options): boolean;
+/**
+ * Return true if version is greater than all the versions possible in the range.
+ */
+export declare function gtr(version: string | SemVer, range: string | Range, optionsOrLoose?: boolean | Options): boolean;
+/**
+ * Return true if the version is outside the bounds of the range in either the high or low direction.
+ * The hilo argument must be either the string '>' or '<'. (This is the function called by gtr and ltr.)
+ */
+export declare function outside(version: string | SemVer, range: string | Range, hilo: ">" | "<", optionsOrLoose?: boolean | Options): boolean;
+export declare function prerelease(version: string | SemVer, optionsOrLoose?: boolean | Options): ReadonlyArray<string | number> | null;
+/**
+ * Return true if any of the ranges comparators intersect
+ */
+export declare function intersects(range1: string | Range | Comparator, range2: string | Range | Comparator, optionsOrLoose?: boolean | Options): boolean;
+/**
+ * Coerces a string to semver if possible
+ */
+export declare function coerce(version: string | SemVer, optionsOrLoose?: boolean | Options): SemVer | null;
+export default SemVer;

package/types/mod.d.ts

@@ -0,0 +1,5 @@
+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/types/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/types/src/Changelog.d.ts

@@ -0,0 +1,18 @@
+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;
+    constructor(title: string, description?: string);
+    addRelease(release: Release): this;
+    findRelease(version?: Semver | string): Release | undefined;
+    sortReleases(): void;
+    tagName(release: Release): string;
+    toString(): string;
+}

package/types/src/Release.d.ts

@@ -0,0 +1,25 @@
+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;
+    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;
+    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/types/src/deps.d.ts

@@ -0,0 +1 @@
+export { default as Semver, eq, } from "../deps/deno_land/x/semver_v1.4.0/mod.js";

package/types/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/umd/_dnt.shims.js

@@ -0,0 +1,76 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@deno/shim-deno", "@deno/shim-deno"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.dntGlobalThis = exports.Deno = void 0;
+    const shim_deno_1 = require("@deno/shim-deno");
+    var shim_deno_2 = require("@deno/shim-deno");
+    Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+    const dntGlobals = {
+        Deno: shim_deno_1.Deno,
+    };
+    exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+    // deno-lint-ignore ban-types
+    function createMergeProxy(baseObj, extObj) {
+        return new Proxy(baseObj, {
+            get(_target, prop, _receiver) {
+                if (prop in extObj) {
+                    return extObj[prop];
+                }
+                else {
+                    return baseObj[prop];
+                }
+            },
+            set(_target, prop, value) {
+                if (prop in extObj) {
+                    delete extObj[prop];
+                }
+                baseObj[prop] = value;
+                return true;
+            },
+            deleteProperty(_target, prop) {
+                let success = false;
+                if (prop in extObj) {
+                    delete extObj[prop];
+                    success = true;
+                }
+                if (prop in baseObj) {
+                    delete baseObj[prop];
+                    success = true;
+                }
+                return success;
+            },
+            ownKeys(_target) {
+                const baseKeys = Reflect.ownKeys(baseObj);
+                const extKeys = Reflect.ownKeys(extObj);
+                const extKeysSet = new Set(extKeys);
+                return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+            },
+            defineProperty(_target, prop, desc) {
+                if (prop in extObj) {
+                    delete extObj[prop];
+                }
+                Reflect.defineProperty(baseObj, prop, desc);
+                return true;
+            },
+            getOwnPropertyDescriptor(_target, prop) {
+                if (prop in extObj) {
+                    return Reflect.getOwnPropertyDescriptor(extObj, prop);
+                }
+                else {
+                    return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+                }
+            },
+            has(_target, prop) {
+                return prop in extObj || prop in baseObj;
+            },
+        });
+    }
+});