fontconv 0.0.3 → 0.0.5

package/esm/deps/jsr.io/@std/path/1.0.8/windows/from_file_url.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Converts a file URL to a path string.
+ *
+ * @example Usage
+ * ```ts
+ * import { fromFileUrl } from "@std/path/windows/from-file-url";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(fromFileUrl("file:///home/foo"), "\\home\\foo");
+ * assertEquals(fromFileUrl("file:///C:/Users/foo"), "C:\\Users\\foo");
+ * assertEquals(fromFileUrl("file://localhost/home/foo"), "\\home\\foo");
+ * ```
+ *
+ * @param url The file URL to convert.
+ * @returns The path string.
+ */
+export declare function fromFileUrl(url: URL | string): string;
+//# sourceMappingURL=from_file_url.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/from_file_url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from_file_url.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/from_file_url.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,CAYrD"}

package/esm/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/from_file_url.js

@@ -4,14 +4,18 @@ import { assertArg } from "../_common/from_file_url.js";
 /**
  * Converts a file URL to a path string.
  *
+ * @example Usage
  * ```ts
- * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/windows/from_file_url.ts";
+ * import { fromFileUrl } from "@std/path/windows/from-file-url";
+ * import { assertEquals } from "@std/assert";
  *
- * fromFileUrl("file:///home/foo"); // "\\home\\foo"
- * fromFileUrl("file:///C:/Users/foo"); // "C:\\Users\\foo"
- * fromFileUrl("file://localhost/home/foo"); // "\\\\localhost\\home\\foo"
+ * assertEquals(fromFileUrl("file:///home/foo"), "\\home\\foo");
+ * assertEquals(fromFileUrl("file:///C:/Users/foo"), "C:\\Users\\foo");
+ * assertEquals(fromFileUrl("file://localhost/home/foo"), "\\home\\foo");
  * ```
- * @param url of a file URL
+ *
+ * @param url The file URL to convert.
+ * @returns The path string.
  */
 export function fromFileUrl(url) {
     url = assertArg(url);

package/esm/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/glob_to_regexp.d.ts

@@ -1,4 +1,4 @@
-import { type GlobToRegExpOptions } from "../_common/glob_to_reg_exp.js";
+import { type GlobOptions } from "../_common/glob_to_reg_exp.js";
 /** Convert a glob string to a regular expression.
  *
  * Tries to match bash glob expansion as closely as possible.
@@ -53,5 +53,19 @@ import { type GlobToRegExpOptions } from "../_common/glob_to_reg_exp.js";
  *   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, options?: GlobToRegExpOptions): RegExp;
+ *   the group occurs not nested at the end of the segment.
+ *
+ * @example Usage
+ * ```ts
+ * import { globToRegExp } from "@std/path/windows/glob-to-regexp";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(globToRegExp("*.js"), /^[^\\/]*\.js(?:\\|\/)*$/);
+ * ```
+ *
+ * @param glob Glob string to convert.
+ * @param options Conversion options.
+ * @returns The regular expression equivalent to the glob.
+ */
+export declare function globToRegExp(glob: string, options?: GlobOptions): RegExp;
+//# sourceMappingURL=glob_to_regexp.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/glob_to_regexp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob_to_regexp.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/glob_to_regexp.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AAWvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,CAER"}

package/esm/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/glob_to_regexp.js

@@ -63,7 +63,20 @@ const constants = {
  *   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. */
+ *   the group occurs not nested at the end of the segment.
+ *
+ * @example Usage
+ * ```ts
+ * import { globToRegExp } from "@std/path/windows/glob-to-regexp";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(globToRegExp("*.js"), /^[^\\/]*\.js(?:\\|\/)*$/);
+ * ```
+ *
+ * @param glob Glob string to convert.
+ * @param options Conversion options.
+ * @returns The regular expression equivalent to the glob.
+ */
 export function globToRegExp(glob, options = {}) {
     return _globToRegExp(constants, glob, options);
 }

package/esm/deps/jsr.io/@std/path/1.0.8/windows/is_absolute.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Verifies whether provided path is absolute.
+ *
+ * @example Usage
+ * ```ts
+ * import { isAbsolute } from "@std/path/windows/is-absolute";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * assert(isAbsolute("C:\\foo\\bar"));
+ * assertFalse(isAbsolute("..\\baz"));
+ * ```
+ *
+ * @param path The path to verify.
+ * @returns `true` if the path is absolute, `false` otherwise.
+ */
+export declare function isAbsolute(path: string): boolean;
+//# sourceMappingURL=is_absolute.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/is_absolute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_absolute.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/is_absolute.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAiBhD"}

package/esm/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/is_absolute.js

@@ -4,8 +4,19 @@ import { CHAR_COLON } from "../_common/constants.js";
 import { assertPath } from "../_common/assert_path.js";
 import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
 /**
- * Verifies whether provided path is absolute
- * @param path to be verified as absolute
+ * Verifies whether provided path is absolute.
+ *
+ * @example Usage
+ * ```ts
+ * import { isAbsolute } from "@std/path/windows/is-absolute";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * assert(isAbsolute("C:\\foo\\bar"));
+ * assertFalse(isAbsolute("..\\baz"));
+ * ```
+ *
+ * @param path The path to verify.
+ * @returns `true` if the path is absolute, `false` otherwise.
  */
 export function isAbsolute(path) {
     assertPath(path);

package/esm/deps/jsr.io/@std/path/1.0.8/windows/join.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ *
+ * @example Usage
+ * ```ts
+ * import { join } from "@std/path/windows/join";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const joined = join("C:\\foo", "bar", "baz\\..");
+ * assertEquals(joined, "C:\\foo\\bar");
+ * ```
+ *
+ * Note: If you are working with file URLs,
+ * use the new version of `join` from `@std/path/windows/unstable-join`.
+ *
+ * @param paths The paths to join.
+ * @returns The joined path.
+ */
+export declare function join(...paths: string[]): string;
+//# sourceMappingURL=join.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/join.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAiD/C"}

package/esm/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/join.js

@@ -1,30 +1,31 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
-import { assert } from "../../assert/assert.js";
 import { assertPath } from "../_common/assert_path.js";
 import { isPathSeparator } from "./_util.js";
 import { normalize } from "./normalize.js";
 /**
  * Join all given a sequence of `paths`,then normalizes the resulting path.
- * @param paths to be joined and normalized
+ *
+ * @example Usage
+ * ```ts
+ * import { join } from "@std/path/windows/join";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const joined = join("C:\\foo", "bar", "baz\\..");
+ * assertEquals(joined, "C:\\foo\\bar");
+ * ```
+ *
+ * Note: If you are working with file URLs,
+ * use the new version of `join` from `@std/path/windows/unstable-join`.
+ *
+ * @param paths The paths to join.
+ * @returns The joined path.
  */
 export function join(...paths) {
+    paths.forEach((path) => assertPath(path));
+    paths = paths.filter((path) => path.length > 0);
     if (paths.length === 0)
         return ".";
-    let joined;
-    let firstPart = null;
-    for (let i = 0; i < paths.length; ++i) {
-        const path = paths[i];
-        assertPath(path);
-        if (path.length > 0) {
-            if (joined === undefined)
-                joined = firstPart = path;
-            else
-                joined += `\\${path}`;
-        }
-    }
-    if (joined === undefined)
-        return ".";
     // Make sure that the joined path doesn't start with two slashes, because
     // normalize() will mistake it for an UNC path then.
     //
@@ -37,10 +38,10 @@ export function join(...paths) {
     // have at least 2 components, so we don't filter for that here.
     // This means that the user can use join to construct UNC paths from
     // a server name and a share name; for example:
-    //   path.join('//server', 'share') -> '\\\\server\\share\\')
+    //   path.join('//server', 'share') -> '\\\\server\\share\\'
     let needsReplace = true;
     let slashCount = 0;
-    assert(firstPart !== null);
+    const firstPart = paths[0];
     if (isPathSeparator(firstPart.charCodeAt(0))) {
         ++slashCount;
         const firstLen = firstPart.length;
@@ -58,6 +59,7 @@ export function join(...paths) {
             }
         }
     }
+    let joined = paths.join("\\");
     if (needsReplace) {
         // Find any more consecutive slashes we need to replace
         for (; slashCount < joined.length; ++slashCount) {

package/esm/deps/jsr.io/@std/path/1.0.8/windows/join_globs.d.ts

@@ -0,0 +1,21 @@
+import type { GlobOptions } from "../_common/glob_to_reg_exp.js";
+export type { GlobOptions };
+/**
+ * Like join(), but doesn't collapse "**\/.." when `globstar` is true.
+ *
+ * @example Usage
+ *
+ * ```ts
+ * import { joinGlobs } from "@std/path/windows/join-globs";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const joined = joinGlobs(["foo", "**", "bar"], { globstar: true });
+ * assertEquals(joined, "foo\\**\\bar");
+ * ```
+ *
+ * @param globs The globs to join.
+ * @param options The options for glob pattern.
+ * @returns The joined glob pattern.
+ */
+export declare function joinGlobs(globs: string[], options?: Pick<GlobOptions, "globstar">): string;
+//# sourceMappingURL=join_globs.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/join_globs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join_globs.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/join_globs.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAKjE,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAM,GAC1C,MAAM,CAeR"}

package/esm/deps/{deno.land/std@0.224.0/path/posix → jsr.io/@std/path/1.0.8/windows}/join_globs.js

@@ -3,13 +3,28 @@
 import { join } from "./join.js";
 import { SEPARATOR } from "./constants.js";
 import { normalizeGlob } from "./normalize_glob.js";
-/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
-export function joinGlobs(globs, { extended = true, globstar = false } = {}) {
+/**
+ * Like join(), but doesn't collapse "**\/.." when `globstar` is true.
+ *
+ * @example Usage
+ *
+ * ```ts
+ * import { joinGlobs } from "@std/path/windows/join-globs";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const joined = joinGlobs(["foo", "**", "bar"], { globstar: true });
+ * assertEquals(joined, "foo\\**\\bar");
+ * ```
+ *
+ * @param globs The globs to join.
+ * @param options The options for glob pattern.
+ * @returns The joined glob pattern.
+ */
+export function joinGlobs(globs, options = {}) {
+    const { globstar = false } = options;
     if (!globstar || globs.length === 0) {
         return join(...globs);
     }
-    if (globs.length === 0)
-        return ".";
     let joined;
     for (const glob of globs) {
         const path = glob;
@@ -22,5 +37,5 @@ export function joinGlobs(globs, { extended = true, globstar = false } = {}) {
     }
     if (!joined)
         return ".";
-    return normalizeGlob(joined, { extended, globstar });
+    return normalizeGlob(joined, { globstar });
 }

package/esm/deps/jsr.io/@std/path/1.0.8/windows/normalize.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 `'.'`.
+ *
+ * @example Usage
+ * ```ts
+ * import { normalize } from "@std/path/windows/normalize";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const normalized = normalize("C:\\foo\\..\\bar");
+ * assertEquals(normalized, "C:\\bar");
+ * ```
+ *
+ * Note: If you are working with file URLs,
+ * use the new version of `normalize` from `@std/path/windows/unstable-normalize`.
+ *
+ * @param path The path to normalize
+ * @returns The normalized path
+ */
+export declare function normalize(path: string): string;
+//# sourceMappingURL=normalize.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/normalize.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA0G9C"}

package/esm/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/normalize.js

@@ -8,7 +8,21 @@ import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
  * 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
+ *
+ * @example Usage
+ * ```ts
+ * import { normalize } from "@std/path/windows/normalize";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const normalized = normalize("C:\\foo\\..\\bar");
+ * assertEquals(normalized, "C:\\bar");
+ * ```
+ *
+ * Note: If you are working with file URLs,
+ * use the new version of `normalize` from `@std/path/windows/unstable-normalize`.
+ *
+ * @param path The path to normalize
+ * @returns The normalized path
  */
 export function normalize(path) {
     assertArg(path);
@@ -108,12 +122,7 @@ export function normalize(path) {
             else
                 return "\\";
         }
-        else if (tail.length > 0) {
-            return tail;
-        }
-        else {
-            return "";
-        }
+        return tail;
     }
     else if (isAbsolute) {
         if (tail.length > 0)
@@ -121,10 +130,5 @@ export function normalize(path) {
         else
             return `${device}\\`;
     }
-    else if (tail.length > 0) {
-        return device + tail;
-    }
-    else {
-        return device;
-    }
+    return device + tail;
 }

package/esm/deps/jsr.io/@std/path/1.0.8/windows/normalize_glob.d.ts

@@ -0,0 +1,20 @@
+import type { GlobOptions } from "../_common/glob_to_reg_exp.js";
+export type { GlobOptions };
+/**
+ * Like normalize(), but doesn't collapse "**\/.." when `globstar` is true.
+ *
+ * @example Usage
+ * ```ts
+ * import { normalizeGlob } from "@std/path/windows/normalize-glob";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const normalized = normalizeGlob("**\\foo\\..\\bar", { globstar: true });
+ * assertEquals(normalized, "**\\bar");
+ * ```
+ *
+ * @param glob The glob pattern to normalize.
+ * @param options The options for glob pattern.
+ * @returns The normalized glob pattern.
+ */
+export declare function normalizeGlob(glob: string, options?: Pick<GlobOptions, "globstar">): string;
+//# sourceMappingURL=normalize_glob.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/normalize_glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize_glob.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/normalize_glob.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAIjE,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAM,GAC1C,MAAM,CAcR"}

package/esm/deps/jsr.io/@std/path/1.0.8/windows/normalize_glob.js

@@ -0,0 +1,32 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { normalize } from "./normalize.js";
+import { SEPARATOR_PATTERN } from "./constants.js";
+/**
+ * Like normalize(), but doesn't collapse "**\/.." when `globstar` is true.
+ *
+ * @example Usage
+ * ```ts
+ * import { normalizeGlob } from "@std/path/windows/normalize-glob";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const normalized = normalizeGlob("**\\foo\\..\\bar", { globstar: true });
+ * assertEquals(normalized, "**\\bar");
+ * ```
+ *
+ * @param glob The glob pattern to normalize.
+ * @param options The options for glob pattern.
+ * @returns The normalized glob pattern.
+ */
+export function normalizeGlob(glob, options = {}) {
+    const { globstar = false } = options;
+    if (glob.match(/\0/g)) {
+        throw new Error(`Glob contains invalid characters: "${glob}"`);
+    }
+    if (!globstar) {
+        return normalize(glob);
+    }
+    const s = SEPARATOR_PATTERN.source;
+    const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g");
+    return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
+}

package/esm/deps/jsr.io/@std/path/1.0.8/windows/parse.d.ts

@@ -0,0 +1,25 @@
+import type { ParsedPath } from "../types.js";
+export type { ParsedPath } from "../types.js";
+/**
+ * Return a `ParsedPath` object of the `path`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/path/windows/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const parsed = parse("C:\\foo\\bar\\baz.ext");
+ * assertEquals(parsed, {
+ *   root: "C:\\",
+ *   dir: "C:\\foo\\bar",
+ *   base: "baz.ext",
+ *   ext: ".ext",
+ *   name: "baz",
+ * });
+ * ```
+ *
+ * @param path The path to parse.
+ * @returns The `ParsedPath` object.
+ */
+export declare function parse(path: string): ParsedPath;
+//# sourceMappingURL=parse.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/parse.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAwJ9C"}

package/esm/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/parse.js

@@ -5,7 +5,24 @@ import { assertPath } from "../_common/assert_path.js";
 import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
 /**
  * Return a `ParsedPath` object of the `path`.
- * @param path to process
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/path/windows/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const parsed = parse("C:\\foo\\bar\\baz.ext");
+ * assertEquals(parsed, {
+ *   root: "C:\\",
+ *   dir: "C:\\foo\\bar",
+ *   base: "baz.ext",
+ *   ext: ".ext",
+ *   name: "baz",
+ * });
+ * ```
+ *
+ * @param path The path to parse.
+ * @returns The `ParsedPath` object.
  */
 export function parse(path) {
     assertPath(path);

package/esm/deps/jsr.io/@std/path/1.0.8/windows/relative.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Return the relative path from `from` to `to` based on current working directory.
+ *
+ * An example in windws, for instance:
+ *  from = 'C:\\orandea\\test\\aaa'
+ *  to = 'C:\\orandea\\impl\\bbb'
+ * The output of the function should be: '..\\..\\impl\\bbb'
+ *
+ * @example Usage
+ * ```ts
+ * import { relative } from "@std/path/windows/relative";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const relativePath = relative("C:\\foobar\\test\\aaa", "C:\\foobar\\impl\\bbb");
+ * assertEquals(relativePath, "..\\..\\impl\\bbb");
+ * ```
+ *
+ * @param from The path from which to calculate the relative path
+ * @param to The path to which to calculate the relative path
+ * @returns The relative path from `from` to `to`
+ */
+export declare function relative(from: string, to: string): string;
+//# sourceMappingURL=relative.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/relative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relative.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/relative.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAmGzD"}

package/esm/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/relative.js

@@ -11,8 +11,18 @@ import { assertArgs } from "../_common/relative.js";
  *  to = 'C:\\orandea\\impl\\bbb'
  * The output of the function should be: '..\\..\\impl\\bbb'
  *
- * @param from path in current working directory
- * @param to path in current working directory
+ * @example Usage
+ * ```ts
+ * import { relative } from "@std/path/windows/relative";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const relativePath = relative("C:\\foobar\\test\\aaa", "C:\\foobar\\impl\\bbb");
+ * assertEquals(relativePath, "..\\..\\impl\\bbb");
+ * ```
+ *
+ * @param from The path from which to calculate the relative path
+ * @param to The path to which to calculate the relative path
+ * @returns The relative path from `from` to `to`
  */
 export function relative(from, to) {
     assertArgs(from, to);

package/esm/deps/jsr.io/@std/path/1.0.8/windows/resolve.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolves path segments into a `path`.
+ *
+ * @example Usage
+ * ```ts
+ * import { resolve } from "@std/path/windows/resolve";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const resolved = resolve("C:\\foo\\bar", "..\\baz");
+ * assertEquals(resolved, "C:\\foo\\baz");
+ * ```
+ *
+ * @param pathSegments The path segments to process to path
+ * @returns The resolved path
+ */
+export declare function resolve(...pathSegments: string[]): string;
+//# sourceMappingURL=resolve.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/resolve.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,GAAG,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,CAwJzD"}

package/esm/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/resolve.js

@@ -1,13 +1,24 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
-import * as dntShim from "../../../../../_dnt.shims.js";
+import * as dntShim from "../../../../../../_dnt.shims.js";
 import { CHAR_COLON } from "../_common/constants.js";
 import { normalizeString } from "../_common/normalize_string.js";
 import { assertPath } from "../_common/assert_path.js";
 import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
 /**
- * Resolves path segments into a `path`
- * @param pathSegments to process to path
+ * Resolves path segments into a `path`.
+ *
+ * @example Usage
+ * ```ts
+ * import { resolve } from "@std/path/windows/resolve";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const resolved = resolve("C:\\foo\\bar", "..\\baz");
+ * assertEquals(resolved, "C:\\foo\\baz");
+ * ```
+ *
+ * @param pathSegments The path segments to process to path
+ * @returns The resolved path
  */
 export function resolve(...pathSegments) {
     let resolvedDevice = "";
@@ -22,13 +33,13 @@ export function resolve(...pathSegments) {
         }
         else if (!resolvedDevice) {
             if (typeof Deno?.cwd !== "function") {
-                throw new TypeError("Resolved a drive-letter-less path without a CWD.");
+                throw new TypeError("Resolved a drive-letter-less path without a current working directory (CWD)");
             }
             path = Deno.cwd();
         }
         else {
             if (typeof Deno?.env?.get !== "function" || typeof Deno?.cwd !== "function") {
-                throw new TypeError("Resolved a relative path without a CWD.");
+                throw new TypeError("Resolved a relative path without a current working directory (CWD)");
             }
             path = Deno.cwd();
             // Verify that a cwd was found and that it actually points

package/esm/deps/jsr.io/@std/path/1.0.8/windows/to_file_url.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts a path string to a file URL.
+ *
+ * @example Usage
+ * ```ts
+ * import { toFileUrl } from "@std/path/windows/to-file-url";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toFileUrl("\\home\\foo"), new URL("file:///home/foo"));
+ * assertEquals(toFileUrl("C:\\Users\\foo"), new URL("file:///C:/Users/foo"));
+ * assertEquals(toFileUrl("\\\\127.0.0.1\\home\\foo"), new URL("file://127.0.0.1/home/foo"));
+ * ```
+ * @param path The path to convert.
+ * @returns The file URL.
+ */
+export declare function toFileUrl(path: string): URL;
+//# sourceMappingURL=to_file_url.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.8/windows/to_file_url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_file_url.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/to_file_url.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAgB3C"}