keep-a-changelog 2.0.1 → 2.2.1

package/script/bin.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./_dnt.polyfills.js");
+const dntShim = __importStar(require("./_dnt.shims.js"));
+const mod_js_1 = require("./deps/deno.land/std@0.173.0/path/mod.js");
+const mod_js_2 = require("./mod.js");
+const mod_js_3 = require("./deps/deno.land/std@0.173.0/flags/mod.js");
+const mod_js_4 = require("./deps/deno.land/x/ini@v2.1.0/mod.js");
+const argv = (0, mod_js_3.parse)(dntShim.Deno.args, {
+    default: {
+        file: "CHANGELOG.md",
+        format: "compact",
+        release: null,
+        url: null,
+        https: true,
+        quiet: false,
+    },
+    string: ["file", "format", "release", "url"],
+    boolean: ["https", "init", "latest-release", "quiet"],
+});
+const file = (0, mod_js_1.join)(dntShim.Deno.cwd(), argv.file);
+try {
+    if (argv.init) {
+        const changelog = new mod_js_2.Changelog("Changelog").addRelease(new mod_js_2.Release("0.1.0", new Date(), "First version"));
+        changelog.format = argv.format;
+        save(file, changelog, true);
+        dntShim.Deno.exit(0);
+    }
+    const changelog = (0, mod_js_2.parser)(dntShim.Deno.readTextFileSync(file));
+    changelog.format = argv.format;
+    if (argv["latest-release"]) {
+        const release = changelog.releases.find((release) => release.date && release.version);
+        if (release) {
+            console.log(release.version?.toString());
+        }
+        dntShim.Deno.exit(0);
+    }
+    if (argv.release) {
+        const release = changelog.releases.find((release) => {
+            if (release.date) {
+                return false;
+            }
+            if (typeof argv.release === "string") {
+                return !release.version || argv.release === release.version.toString();
+            }
+            return !!release.version;
+        });
+        if (release) {
+            release.date = new Date();
+            if (typeof argv.release === "string") {
+                release.setVersion(argv.release);
+            }
+        }
+        else {
+            console.error("Not found any valid unreleased version");
+            dntShim.Deno.exit(1);
+        }
+    }
+    if (!changelog.url) {
+        if (argv.url) {
+            changelog.url = argv.url;
+        }
+        else {
+            const url = getRemoteUrl(argv.https);
+            if (url) {
+                changelog.url = url;
+            }
+            else {
+                console.error(red('Please, set the repository url with --url="https://github.com/username/repository"'));
+                dntShim.Deno.exit(1);
+            }
+        }
+    }
+    save(file, changelog);
+}
+catch (err) {
+    console.error(red(err.message));
+    if (!argv.quiet) {
+        dntShim.Deno.exit(1);
+    }
+}
+function save(file, changelog, isNew = false) {
+    const url = changelog.url;
+    if (url && url.includes("gitlab.com")) {
+        changelog.head = "master";
+    }
+    dntShim.Deno.writeTextFileSync(file, changelog.toString());
+    if (isNew) {
+        console.log(green("Generated new file"), file);
+    }
+    else {
+        console.log(green("Updated file"), file);
+    }
+}
+function red(message) {
+    return "\u001b[" + 31 + "m" + message + "\u001b[" + 39 + "m";
+}
+function green(message) {
+    return "\u001b[" + 32 + "m" + message + "\u001b[" + 39 + "m";
+}
+function getRemoteUrl(https = true) {
+    try {
+        const file = (0, mod_js_1.join)(dntShim.Deno.cwd(), ".git", "config");
+        const content = dntShim.Deno.readTextFileSync(file);
+        const data = (0, mod_js_4.parse)(content);
+        const url = data?.['remote "origin"']?.url;
+        if (!url) {
+            return;
+        }
+        const remoteUrl = new URL(url.replace(/^git@([^:]+):(.*)\.git$/, "https://$1/$2"));
+        if (https) {
+            remoteUrl.protocol = "https:";
+        }
+        return remoteUrl.href;
+    }
+    catch (err) {
+        console.error(red(err.message));
+        // Ignore
+    }
+}

package/script/deps/deno.land/std@0.173.0/_util/asserts.js

@@ -0,0 +1,27 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unreachable = exports.assert = exports.DenoStdInternalError = void 0;
+/**
+ * All internal non-test code, that is files that do not have `test` or `bench` in the name, must use the assertion functions within `_utils/asserts.ts` and not `testing/asserts.ts`. This is to create a separation of concerns between internal and testing assertions.
+ */
+class DenoStdInternalError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DenoStdInternalError";
+    }
+}
+exports.DenoStdInternalError = DenoStdInternalError;
+/** Make an assertion, if not `true`, then throw. */
+function assert(expr, msg = "") {
+    if (!expr) {
+        throw new DenoStdInternalError(msg);
+    }
+}
+exports.assert = assert;
+/** Use this to assert unreachable code. */
+function unreachable() {
+    throw new DenoStdInternalError("unreachable");
+}
+exports.unreachable = unreachable;

package/script/deps/deno.land/std@0.173.0/_util/os.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLinux = exports.isWindows = exports.osType = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const dntShim = __importStar(require("../../../../_dnt.shims.js"));
+exports.osType = (() => {
+    // deno-lint-ignore no-explicit-any
+    const { Deno } = dntShim.dntGlobalThis;
+    if (typeof Deno?.build?.os === "string") {
+        return Deno.build.os;
+    }
+    // deno-lint-ignore no-explicit-any
+    const { navigator } = dntShim.dntGlobalThis;
+    if (navigator?.appVersion?.includes?.("Win")) {
+        return "windows";
+    }
+    return "linux";
+})();
+exports.isWindows = exports.osType === "windows";
+exports.isLinux = exports.osType === "linux";

package/script/deps/deno.land/std@0.173.0/flags/mod.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/**
+ * Command line arguments parser based on
+ * [minimist](https://github.com/minimistjs/minimist).
+ *
+ * This module is browser compatible.
+ *
+ * @example
+ * ```ts
+ * import { parse } from "https://deno.land/std@$STD_VERSION/flags/mod.ts";
+ *
+ * console.dir(parse(Deno.args));
+ * ```
+ *
+ * ```sh
+ * $ deno run https://deno.land/std/examples/flags.ts -a beep -b boop
+ * { _: [], a: 'beep', b: 'boop' }
+ * ```
+ *
+ * ```sh
+ * $ deno run https://deno.land/std/examples/flags.ts -x 3 -y 4 -n5 -abc --beep=boop foo bar baz
+ * { _: [ 'foo', 'bar', 'baz' ],
+ *   x: 3,
+ *   y: 4,
+ *   n: 5,
+ *   a: true,
+ *   b: true,
+ *   c: true,
+ *   beep: 'boop' }
+ * ```
+ *
+ * @module
+ */
+const asserts_js_1 = require("../_util/asserts.js");
+const { hasOwn } = Object;
+function get(obj, key) {
+    if (hasOwn(obj, key)) {
+        return obj[key];
+    }
+}
+function getForce(obj, key) {
+    const v = get(obj, key);
+    (0, asserts_js_1.assert)(v != null);
+    return v;
+}
+function isNumber(x) {
+    if (typeof x === "number")
+        return true;
+    if (/^0x[0-9a-f]+$/i.test(String(x)))
+        return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(String(x));
+}
+function hasKey(obj, keys) {
+    let o = obj;
+    keys.slice(0, -1).forEach((key) => {
+        o = (get(o, key) ?? {});
+    });
+    const key = keys[keys.length - 1];
+    return hasOwn(o, key);
+}
+/** Take a set of command line arguments, optionally with a set of options, and
+ * return an object representing the flags found in the passed arguments.
+ *
+ * By default, any arguments starting with `-` or `--` are considered boolean
+ * flags. If the argument name is followed by an equal sign (`=`) it is
+ * considered a key-value pair. Any arguments which could not be parsed are
+ * available in the `_` property of the returned object.
+ *
+ * By default, the flags module tries to determine the type of all arguments
+ * automatically and the return type of the `parse` method will have an index
+ * signature with `any` as value (`{ [x: string]: any }`).
+ *
+ * If the `string`, `boolean` or `collect` option is set, the return value of
+ * the `parse` method will be fully typed and the index signature of the return
+ * type will change to `{ [x: string]: unknown }`.
+ *
+ * Any arguments after `'--'` will not be parsed and will end up in `parsedArgs._`.
+ *
+ * Numeric-looking arguments will be returned as numbers unless `options.string`
+ * or `options.boolean` is set for that argument name.
+ *
+ * @example
+ * ```ts
+ * import { parse } from "https://deno.land/std@$STD_VERSION/flags/mod.ts";
+ * const parsedArgs = parse(Deno.args);
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { parse } from "https://deno.land/std@$STD_VERSION/flags/mod.ts";
+ * const parsedArgs = parse(["--foo", "--bar=baz", "./quux.txt"]);
+ * // parsedArgs: { foo: true, bar: "baz", _: ["./quux.txt"] }
+ * ```
+ */
+function parse(args, { "--": doubleDash = false, alias = {}, boolean = false, default: defaults = {}, stopEarly = false, string = [], collect = [], negatable = [], unknown = (i) => i, } = {}) {
+    const aliases = {};
+    const flags = {
+        bools: {},
+        strings: {},
+        unknownFn: unknown,
+        allBools: false,
+        collect: {},
+        negatable: {},
+    };
+    if (alias !== undefined) {
+        for (const key in alias) {
+            const val = getForce(alias, key);
+            if (typeof val === "string") {
+                aliases[key] = [val];
+            }
+            else {
+                aliases[key] = val;
+            }
+            for (const alias of getForce(aliases, key)) {
+                aliases[alias] = [key].concat(aliases[key].filter((y) => alias !== y));
+            }
+        }
+    }
+    if (boolean !== undefined) {
+        if (typeof boolean === "boolean") {
+            flags.allBools = !!boolean;
+        }
+        else {
+            const booleanArgs = typeof boolean === "string"
+                ? [boolean]
+                : boolean;
+            for (const key of booleanArgs.filter(Boolean)) {
+                flags.bools[key] = true;
+                const alias = get(aliases, key);
+                if (alias) {
+                    for (const al of alias) {
+                        flags.bools[al] = true;
+                    }
+                }
+            }
+        }
+    }
+    if (string !== undefined) {
+        const stringArgs = typeof string === "string"
+            ? [string]
+            : string;
+        for (const key of stringArgs.filter(Boolean)) {
+            flags.strings[key] = true;
+            const alias = get(aliases, key);
+            if (alias) {
+                for (const al of alias) {
+                    flags.strings[al] = true;
+                }
+            }
+        }
+    }
+    if (collect !== undefined) {
+        const collectArgs = typeof collect === "string"
+            ? [collect]
+            : collect;
+        for (const key of collectArgs.filter(Boolean)) {
+            flags.collect[key] = true;
+            const alias = get(aliases, key);
+            if (alias) {
+                for (const al of alias) {
+                    flags.collect[al] = true;
+                }
+            }
+        }
+    }
+    if (negatable !== undefined) {
+        const negatableArgs = typeof negatable === "string"
+            ? [negatable]
+            : negatable;
+        for (const key of negatableArgs.filter(Boolean)) {
+            flags.negatable[key] = true;
+            const alias = get(aliases, key);
+            if (alias) {
+                for (const al of alias) {
+                    flags.negatable[al] = true;
+                }
+            }
+        }
+    }
+    const argv = { _: [] };
+    function argDefined(key, arg) {
+        return ((flags.allBools && /^--[^=]+$/.test(arg)) ||
+            get(flags.bools, key) ||
+            !!get(flags.strings, key) ||
+            !!get(aliases, key));
+    }
+    function setKey(obj, name, value, collect = true) {
+        let o = obj;
+        const keys = name.split(".");
+        keys.slice(0, -1).forEach(function (key) {
+            if (get(o, key) === undefined) {
+                o[key] = {};
+            }
+            o = get(o, key);
+        });
+        const key = keys[keys.length - 1];
+        const collectable = collect && !!get(flags.collect, name);
+        if (!collectable) {
+            o[key] = value;
+        }
+        else if (get(o, key) === undefined) {
+            o[key] = [value];
+        }
+        else if (Array.isArray(get(o, key))) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [get(o, key), value];
+        }
+    }
+    function setArg(key, val, arg = undefined, collect) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg, key, val) === false)
+                return;
+        }
+        const value = !get(flags.strings, key) && isNumber(val) ? Number(val) : val;
+        setKey(argv, key, value, collect);
+        const alias = get(aliases, key);
+        if (alias) {
+            for (const x of alias) {
+                setKey(argv, x, value, collect);
+            }
+        }
+    }
+    function aliasIsBoolean(key) {
+        return getForce(aliases, key).some((x) => typeof get(flags.bools, x) === "boolean");
+    }
+    let notFlags = [];
+    // all args after "--" are not parsed
+    if (args.includes("--")) {
+        notFlags = args.slice(args.indexOf("--") + 1);
+        args = args.slice(0, args.indexOf("--"));
+    }
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (/^--.+=/.test(arg)) {
+            const m = arg.match(/^--([^=]+)=(.*)$/s);
+            (0, asserts_js_1.assert)(m != null);
+            const [, key, value] = m;
+            if (flags.bools[key]) {
+                const booleanValue = value !== "false";
+                setArg(key, booleanValue, arg);
+            }
+            else {
+                setArg(key, value, arg);
+            }
+        }
+        else if (/^--no-.+/.test(arg) && get(flags.negatable, arg.replace(/^--no-/, ""))) {
+            const m = arg.match(/^--no-(.+)/);
+            (0, asserts_js_1.assert)(m != null);
+            setArg(m[1], false, arg, false);
+        }
+        else if (/^--.+/.test(arg)) {
+            const m = arg.match(/^--(.+)/);
+            (0, asserts_js_1.assert)(m != null);
+            const [, key] = m;
+            const next = args[i + 1];
+            if (next !== undefined &&
+                !/^-/.test(next) &&
+                !get(flags.bools, key) &&
+                !flags.allBools &&
+                (get(aliases, key) ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === "true", arg);
+                i++;
+            }
+            else {
+                setArg(key, get(flags.strings, key) ? "" : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            const letters = arg.slice(1, -1).split("");
+            let broken = false;
+            for (let j = 0; j < letters.length; j++) {
+                const next = arg.slice(j + 2);
+                if (next === "-") {
+                    setArg(letters[j], next, arg);
+                    continue;
+                }
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split(/=(.+)/)[1], arg);
+                    broken = true;
+                    break;
+                }
+                if (/[A-Za-z]/.test(letters[j]) &&
+                    /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j + 2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], get(flags.strings, letters[j]) ? "" : true, arg);
+                }
+            }
+            const [key] = arg.slice(-1);
+            if (!broken && key !== "-") {
+                if (args[i + 1] &&
+                    !/^(-|--)[^-]/.test(args[i + 1]) &&
+                    !get(flags.bools, key) &&
+                    (get(aliases, key) ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i + 1], arg);
+                    i++;
+                }
+                else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+                    setArg(key, args[i + 1] === "true", arg);
+                    i++;
+                }
+                else {
+                    setArg(key, get(flags.strings, key) ? "" : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(flags.strings["_"] ?? !isNumber(arg) ? arg : Number(arg));
+            }
+            if (stopEarly) {
+                argv._.push(...args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    for (const [key, value] of Object.entries(defaults)) {
+        if (!hasKey(argv, key.split("."))) {
+            setKey(argv, key, value);
+            if (aliases[key]) {
+                for (const x of aliases[key]) {
+                    setKey(argv, x, value);
+                }
+            }
+        }
+    }
+    for (const key of Object.keys(flags.bools)) {
+        if (!hasKey(argv, key.split("."))) {
+            const value = get(flags.collect, key) ? [] : false;
+            setKey(argv, key, value, false);
+        }
+    }
+    for (const key of Object.keys(flags.strings)) {
+        if (!hasKey(argv, key.split(".")) && get(flags.collect, key)) {
+            setKey(argv, key, [], false);
+        }
+    }
+    if (doubleDash) {
+        argv["--"] = [];
+        for (const key of notFlags) {
+            argv["--"].push(key);
+        }
+    }
+    else {
+        for (const key of notFlags) {
+            argv._.push(key);
+        }
+    }
+    return argv;
+}
+exports.parse = parse;

package/script/deps/deno.land/std@0.173.0/path/_constants.js

@@ -0,0 +1,49 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHAR_9 = exports.CHAR_0 = exports.CHAR_EQUAL = exports.CHAR_AMPERSAND = exports.CHAR_AT = exports.CHAR_GRAVE_ACCENT = exports.CHAR_CIRCUMFLEX_ACCENT = exports.CHAR_SEMICOLON = exports.CHAR_PERCENT = exports.CHAR_SINGLE_QUOTE = exports.CHAR_DOUBLE_QUOTE = exports.CHAR_PLUS = exports.CHAR_HYPHEN_MINUS = exports.CHAR_RIGHT_CURLY_BRACKET = exports.CHAR_LEFT_CURLY_BRACKET = exports.CHAR_RIGHT_ANGLE_BRACKET = exports.CHAR_LEFT_ANGLE_BRACKET = exports.CHAR_RIGHT_SQUARE_BRACKET = exports.CHAR_LEFT_SQUARE_BRACKET = exports.CHAR_ZERO_WIDTH_NOBREAK_SPACE = exports.CHAR_NO_BREAK_SPACE = exports.CHAR_SPACE = exports.CHAR_HASH = exports.CHAR_EXCLAMATION_MARK = exports.CHAR_FORM_FEED = exports.CHAR_TAB = exports.CHAR_CARRIAGE_RETURN = exports.CHAR_LINE_FEED = exports.CHAR_UNDERSCORE = exports.CHAR_QUESTION_MARK = exports.CHAR_COLON = exports.CHAR_VERTICAL_LINE = exports.CHAR_BACKWARD_SLASH = exports.CHAR_FORWARD_SLASH = exports.CHAR_DOT = exports.CHAR_LOWERCASE_Z = exports.CHAR_UPPERCASE_Z = exports.CHAR_LOWERCASE_A = exports.CHAR_UPPERCASE_A = void 0;
+// Alphabet chars.
+exports.CHAR_UPPERCASE_A = 65; /* A */
+exports.CHAR_LOWERCASE_A = 97; /* a */
+exports.CHAR_UPPERCASE_Z = 90; /* Z */
+exports.CHAR_LOWERCASE_Z = 122; /* z */
+// Non-alphabetic chars.
+exports.CHAR_DOT = 46; /* . */
+exports.CHAR_FORWARD_SLASH = 47; /* / */
+exports.CHAR_BACKWARD_SLASH = 92; /* \ */
+exports.CHAR_VERTICAL_LINE = 124; /* | */
+exports.CHAR_COLON = 58; /* : */
+exports.CHAR_QUESTION_MARK = 63; /* ? */
+exports.CHAR_UNDERSCORE = 95; /* _ */
+exports.CHAR_LINE_FEED = 10; /* \n */
+exports.CHAR_CARRIAGE_RETURN = 13; /* \r */
+exports.CHAR_TAB = 9; /* \t */
+exports.CHAR_FORM_FEED = 12; /* \f */
+exports.CHAR_EXCLAMATION_MARK = 33; /* ! */
+exports.CHAR_HASH = 35; /* # */
+exports.CHAR_SPACE = 32; /*   */
+exports.CHAR_NO_BREAK_SPACE = 160; /* \u00A0 */
+exports.CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \uFEFF */
+exports.CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */
+exports.CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */
+exports.CHAR_LEFT_ANGLE_BRACKET = 60; /* < */
+exports.CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */
+exports.CHAR_LEFT_CURLY_BRACKET = 123; /* { */
+exports.CHAR_RIGHT_CURLY_BRACKET = 125; /* } */
+exports.CHAR_HYPHEN_MINUS = 45; /* - */
+exports.CHAR_PLUS = 43; /* + */
+exports.CHAR_DOUBLE_QUOTE = 34; /* " */
+exports.CHAR_SINGLE_QUOTE = 39; /* ' */
+exports.CHAR_PERCENT = 37; /* % */
+exports.CHAR_SEMICOLON = 59; /* ; */
+exports.CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */
+exports.CHAR_GRAVE_ACCENT = 96; /* ` */
+exports.CHAR_AT = 64; /* @ */
+exports.CHAR_AMPERSAND = 38; /* & */
+exports.CHAR_EQUAL = 61; /* = */
+// Digits
+exports.CHAR_0 = 48; /* 0 */
+exports.CHAR_9 = 57; /* 9 */

package/script/deps/deno.land/std@0.173.0/path/_interface.js

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