keep-a-changelog 2.1.0 → 2.2.1

package/CHANGELOG.md

@@ -1,12 +1,23 @@
 <!-- deno-fmt-ignore-file -->
 
 # Changelog
-
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [2.2.1] - 2023-01-25
+### Fixed
+- Allow list elements in the descriptions of releases and changelogs [#30].
+
+## [2.2.0] - 2023-01-18
+### Added
+- New option `format` to configure the output option [#28].
+- `Release.setYanked` function [#26].
+
+### Fixed
+- Removed unnecessary new line after the title [#27].
+
 ## [2.1.0] - 2022-04-03
 ### Added
 - Support for `[YANKED]` releases [#25]
@@ -29,7 +40,13 @@ New version merging Deno and Node code using Deno's `dnt` package.
 [#21]: https://github.com/oscarotero/keep-a-changelog/issues/21
 [#23]: https://github.com/oscarotero/keep-a-changelog/issues/23
 [#25]: https://github.com/oscarotero/keep-a-changelog/issues/25
+[#26]: https://github.com/oscarotero/keep-a-changelog/issues/26
+[#27]: https://github.com/oscarotero/keep-a-changelog/issues/27
+[#28]: https://github.com/oscarotero/keep-a-changelog/issues/28
+[#30]: https://github.com/oscarotero/keep-a-changelog/issues/30
 
+[2.2.1]: https://github.com/oscarotero/keep-a-changelog/compare/v2.2.0...v2.2.1
+[2.2.0]: https://github.com/oscarotero/keep-a-changelog/compare/v2.1.0...v2.2.0
 [2.1.0]: https://github.com/oscarotero/keep-a-changelog/compare/v2.0.1...v2.1.0
 [2.0.1]: https://github.com/oscarotero/keep-a-changelog/compare/v2.0.0...v2.0.1
 [2.0.0]: https://github.com/oscarotero/keep-a-changelog/releases/tag/v2.0.0

package/README.md

@@ -56,6 +56,17 @@ const changelog = new Changelog("My project")
 console.log(changelog.toString());
 ```
 
+### Custom output format
+
+By default, the output format of the markdown is "compact", that removes the
+space after the headings. You can change it to follow the
+[`markdownlint`](https://github.com/DavidAnson/markdownlint) rules:
+
+```js
+const changelog = new Changelog();
+changelog.format = "markdownlint";
+```
+
 ### Custom tag names
 
 By default, the tag names are `v` + version number. For example, the tag for the
@@ -73,10 +84,10 @@ By default and according to the
 [keepachangelog](http://keepachangelog.com/en/1.0.0/) format, the change types
 are `Added`, `Changed`, `Deprecated`, `Removed`, `Fixed`, and `Security`.
 
-In case you'd like add another type in order to use is in your changelog, you
-basically need to extend the `Release` class to support new types. Additionally,
-you have to tell the `parser` that it should create instances of your new
-extended `Release` in order to parse your changelog correctly.
+In case you'd like add another type, you need to extend the `Release` class to
+support new types. Additionally, you have to tell the `parser` that it should
+create instances of your new extended `Release` in order to parse your changelog
+correctly.
 
 For example, we would like to add a type `Maintenance`. Extend the provided
 `Release` class:
@@ -160,6 +171,7 @@ Available options:
 
 | Option             | Description                                                                                                                                                                                                    |
 | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--format`           | The output format for the generated markdown. It can be `markdownlint` or `compact`. The default value is `compact`.                                                                                                                                       |
 | `--file`           | The markdown file of the changelog. The default value is `CHANGELOG.md`.                                                                                                                                       |
 | `--url`            | The base url used to build the diff urls of the different releases. It is taken from the existing diff urls in the markdown. If no urls are found, try to catch it using the url of the git remote repository. |
 | `--https`          | Set to false to use `http` instead `https` in the url (`--https=false`).                                                                                                                                       |

package/esm/bin.js

@@ -1,28 +1,32 @@
 #!/usr/bin/env node
 import "./_dnt.polyfills.js";
 import * as dntShim from "./_dnt.shims.js";
-import { join } from "./deps/deno.land/std@0.120.0/path/mod.js";
+import { join } from "./deps/deno.land/std@0.173.0/path/mod.js";
 import { Changelog, parser, Release } from "./mod.js";
-import { parse as parseFlag } from "./deps/deno.land/std@0.120.0/flags/mod.js";
+import { parse as parseFlag } from "./deps/deno.land/std@0.173.0/flags/mod.js";
 import { parse as parseIni } from "./deps/deno.land/x/ini@v2.1.0/mod.js";
 const argv = parseFlag(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 = join(dntShim.Deno.cwd(), argv.file);
 try {
     if (argv.init) {
         const changelog = new Changelog("Changelog").addRelease(new Release("0.1.0", new Date(), "First version"));
+        changelog.format = argv.format;
         save(file, changelog, true);
         dntShim.Deno.exit(0);
     }
     const changelog = 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) {

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

@@ -0,0 +1,21 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * 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.
+ */
+export class DenoStdInternalError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DenoStdInternalError";
+    }
+}
+/** Make an assertion, if not `true`, then throw. */
+export function assert(expr, msg = "") {
+    if (!expr) {
+        throw new DenoStdInternalError(msg);
+    }
+}
+/** Use this to assert unreachable code. */
+export function unreachable() {
+    throw new DenoStdInternalError("unreachable");
+}

package/esm/deps/deno.land/{std@0.120.0 → std@0.173.0}/_util/os.js

@@ -1,4 +1,4 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import * as dntShim from "../../../../_dnt.shims.js";
 export const osType = (() => {
@@ -9,9 +9,10 @@ export const osType = (() => {
     }
     // deno-lint-ignore no-explicit-any
     const { navigator } = dntShim.dntGlobalThis;
-    if (navigator?.appVersion?.includes?.("Win") ?? false) {
+    if (navigator?.appVersion?.includes?.("Win")) {
         return "windows";
     }
     return "linux";
 })();
 export const isWindows = osType === "windows";
+export const isLinux = osType === "linux";

package/esm/deps/deno.land/{std@0.120.0 → std@0.173.0}/flags/mod.js

@@ -1,5 +1,37 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-import { assert } from "../_util/assert.js";
+// 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
+ */
+import { assert } from "../_util/asserts.js";
 const { hasOwn } = Object;
 function get(obj, key) {
     if (hasOwn(obj, key)) {
@@ -24,35 +56,52 @@ function hasKey(obj, keys) {
         o = (get(o, key) ?? {});
     });
     const key = keys[keys.length - 1];
-    return key in o;
+    return hasOwn(o, key);
 }
-/** Take a set of command line arguments, with an optional set of options, and
- * return an object representation of those argument.
+/** 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 "./mod.ts";
- *      const parsedArgs = parse(Deno.args);
+ * 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"] }
  * ```
  */
-export function parse(args, { "--": doubleDash = false, alias = {}, boolean = false, default: defaults = {}, stopEarly = false, string = [], unknown = (i) => i, } = {}) {
+export 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 (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 aliases = {};
     if (alias !== undefined) {
         for (const key in alias) {
             const val = getForce(alias, key);
@@ -67,8 +116,29 @@ export function parse(args, { "--": doubleDash = false, alias = {}, boolean = fa
             }
         }
     }
+    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;
+        const stringArgs = typeof string === "string"
+            ? [string]
+            : string;
         for (const key of stringArgs.filter(Boolean)) {
             flags.strings[key] = true;
             const alias = get(aliases, key);
@@ -79,6 +149,34 @@ export function parse(args, { "--": doubleDash = false, alias = {}, boolean = fa
             }
         }
     }
+    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)) ||
@@ -86,8 +184,9 @@ export function parse(args, { "--": doubleDash = false, alias = {}, boolean = fa
             !!get(flags.strings, key) ||
             !!get(aliases, key));
     }
-    function setKey(obj, keys, value) {
+    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] = {};
@@ -95,11 +194,13 @@ export function parse(args, { "--": doubleDash = false, alias = {}, boolean = fa
             o = get(o, key);
         });
         const key = keys[keys.length - 1];
-        if (get(o, key) === undefined ||
-            get(flags.bools, key) ||
-            typeof get(o, key) === "boolean") {
+        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);
         }
@@ -107,26 +208,23 @@ export function parse(args, { "--": doubleDash = false, alias = {}, boolean = fa
             o[key] = [get(o, key), value];
         }
     }
-    function setArg(key, val, arg = undefined) {
+    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.split("."), value);
+        setKey(argv, key, value, collect);
         const alias = get(aliases, key);
         if (alias) {
             for (const x of alias) {
-                setKey(argv, x.split("."), value);
+                setKey(argv, x, value, collect);
             }
         }
     }
     function aliasIsBoolean(key) {
         return getForce(aliases, key).some((x) => typeof get(flags.bools, x) === "boolean");
     }
-    for (const key of Object.keys(flags.bools)) {
-        setArg(key, defaults[key] === undefined ? false : defaults[key]);
-    }
     let notFlags = [];
     // all args after "--" are not parsed
     if (args.includes("--")) {
@@ -147,10 +245,10 @@ export function parse(args, { "--": doubleDash = false, alias = {}, boolean = fa
                 setArg(key, value, arg);
             }
         }
-        else if (/^--no-.+/.test(arg)) {
+        else if (/^--no-.+/.test(arg) && get(flags.negatable, arg.replace(/^--no-/, ""))) {
             const m = arg.match(/^--no-(.+)/);
             assert(m != null);
-            setArg(m[1], false, arg);
+            setArg(m[1], false, arg, false);
         }
         else if (/^--.+/.test(arg)) {
             const m = arg.match(/^--(.+)/);
@@ -230,16 +328,27 @@ export function parse(args, { "--": doubleDash = false, alias = {}, boolean = fa
             }
         }
     }
-    for (const key of Object.keys(defaults)) {
+    for (const [key, value] of Object.entries(defaults)) {
         if (!hasKey(argv, key.split("."))) {
-            setKey(argv, key.split("."), defaults[key]);
+            setKey(argv, key, value);
             if (aliases[key]) {
                 for (const x of aliases[key]) {
-                    setKey(argv, x.split("."), defaults[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) {

package/esm/deps/deno.land/{std@0.120.0 → std@0.173.0}/path/_constants.js

@@ -1,3 +1,4 @@
+// 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.

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

@@ -0,0 +1,3 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export {};

package/esm/deps/deno.land/{std@0.120.0 → std@0.173.0}/path/_util.js

@@ -1,3 +1,4 @@
+// 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.

package/esm/deps/deno.land/{std@0.120.0 → std@0.173.0}/path/common.js

@@ -1,4 +1,4 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { SEP } from "./separator.js";
 /** Determines the common path from a set of paths, using an optional separator,

package/esm/deps/deno.land/{std@0.120.0 → std@0.173.0}/path/glob.js

@@ -1,4 +1,4 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { isWindows, osType } from "../_util/os.js";
 import { SEP, SEP_PATTERN } from "./separator.js";

package/esm/deps/deno.land/std@0.173.0/path/mod.js

@@ -0,0 +1,32 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+// Ported mostly from https://github.com/browserify/path-browserify/
+/**
+ * Utilities for working with OS-specific file paths.
+ *
+ * Codes in the examples uses POSIX path but it automatically use Windows path
+ * on Windows. Use methods under `posix` or `win32` object instead to handle non
+ * platform specific path like:
+ * ```ts
+ * import { posix, win32 } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
+ * const p1 = posix.fromFileUrl("file:///home/foo");
+ * const p2 = win32.fromFileUrl("file:///home/foo");
+ * console.log(p1); // "/home/foo"
+ * console.log(p2); // "\\home\\foo"
+ * ```
+ *
+ * This module is browser compatible.
+ *
+ * @module
+ */
+import { isWindows } from "../_util/os.js";
+import * as _win32 from "./win32.js";
+import * as _posix from "./posix.js";
+const path = isWindows ? _win32 : _posix;
+export const win32 = _win32;
+export const posix = _posix;
+export const { basename, delimiter, dirname, extname, format, fromFileUrl, isAbsolute, join, normalize, parse, relative, resolve, sep, toFileUrl, toNamespacedPath, } = path;
+export * from "./common.js";
+export { SEP, SEP_PATTERN } from "./separator.js";
+export * from "./_interface.js";
+export * from "./glob.js";

package/esm/deps/deno.land/{std@0.120.0 → std@0.173.0}/path/posix.js

@@ -1,3 +1,4 @@
+// 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.
@@ -51,6 +52,8 @@ export function resolve(...pathSegments) {
 }
 /**
  * Normalize the `path`, resolving `'..'` and `'.'` segments.
+ * Note that resolving these segments does not necessarily mean that all will be eliminated.
+ * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.
  * @param path to be normalized
  */
 export function normalize(path) {
@@ -199,8 +202,8 @@ export function toNamespacedPath(path) {
     return path;
 }
 /**
- * Return the directory name of a `path`.
- * @param path to determine name for
+ * Return the directory path of a `path`.
+ * @param path to determine the directory path for
  */
 export function dirname(path) {
     assertPath(path);
@@ -248,7 +251,7 @@ export function basename(path, ext = "") {
         let firstNonSlashEnd = -1;
         for (i = path.length - 1; i >= 0; --i) {
             const code = path.charCodeAt(i);
-            if (code === CHAR_FORWARD_SLASH) {
+            if (isPosixPathSeparator(code)) {
                 // If we reached a path separator that was not part of a set of path
                 // separators at the end of the string, stop now
                 if (!matchedSlash) {
@@ -258,38 +261,38 @@ export function basename(path, ext = "") {
             }
             else {
                 if (firstNonSlashEnd === -1) {
-                    // We saw the first non-path separator, remember this index in case
-                    // we need it if the extension ends up not matching
+                    // We saw the first non-path separator, mark this as the end of our
+                    // path component in case we don't match a whole suffix
                     matchedSlash = false;
                     firstNonSlashEnd = i + 1;
+                    end = firstNonSlashEnd;
                 }
                 if (extIdx >= 0) {
-                    // Try to match the explicit extension
+                    // Try to match the explicit suffix
                     if (code === ext.charCodeAt(extIdx)) {
                         if (--extIdx === -1) {
-                            // We matched the extension, so mark this as the end of our path
+                            // We matched whole suffix, so mark this as the end of our path
                             // component
                             end = i;
                         }
                     }
                     else {
-                        // Extension does not match, so our result is the entire path
-                        // component
+                        // Suffix character does not match, so bail out early
+                        // from checking rest of characters
                         extIdx = -1;
-                        end = firstNonSlashEnd;
                     }
                 }
             }
         }
+        if (end === -1)
+            return "";
         if (start === end)
             end = firstNonSlashEnd;
-        else if (end === -1)
-            end = path.length;
         return path.slice(start, end);
     }
     else {
         for (i = path.length - 1; i >= 0; --i) {
-            if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+            if (isPosixPathSeparator(path.charCodeAt(i))) {
                 // If we reached a path separator that was not part of a set of path
                 // separators at the end of the string, stop now
                 if (!matchedSlash) {
@@ -310,8 +313,9 @@ export function basename(path, ext = "") {
     }
 }
 /**
- * Return the extension of the `path`.
+ * Return the extension of the `path` with leading period.
  * @param path with extension
+ * @returns extension (ex. for `file.ts` returns `.ts`)
  */
 export function extname(path) {
     assertPath(path);
@@ -465,7 +469,7 @@ export function parse(path) {
  * Converts a file URL to a path string.
  *
  * ```ts
- *      import { fromFileUrl } from "./posix.ts";
+ *      import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
  *      fromFileUrl("file:///home/foo"); // "/home/foo"
  * ```
  * @param url of a file URL
@@ -481,7 +485,7 @@ export function fromFileUrl(url) {
  * Converts a path string to a file URL.
  *
  * ```ts
- *      import { toFileUrl } from "./posix.ts";
+ *      import { toFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
  *      toFileUrl("/home/foo"); // new URL("file:///home/foo")
  * ```
  * @param path to convert to file URL

package/esm/deps/deno.land/{std@0.120.0 → std@0.173.0}/path/separator.js

@@ -1,4 +1,4 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { isWindows } from "../_util/os.js";
 export const SEP = isWindows ? "\\" : "/";