fontconv 0.0.3 → 0.0.5

package/script/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/script/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/from_file_url.js

@@ -2,19 +2,23 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromFileUrl = void 0;
+exports.fromFileUrl = fromFileUrl;
 const from_file_url_js_1 = require("../_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.
  */
 function fromFileUrl(url) {
     url = (0, from_file_url_js_1.assertArg)(url);
@@ -27,4 +31,3 @@ function fromFileUrl(url) {
     }
     return path;
 }
-exports.fromFileUrl = fromFileUrl;

package/{esm/deps/deno.land/std@0.224.0/path/posix → script/deps/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/script/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/script/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/glob_to_regexp.js

@@ -2,7 +2,7 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.globToRegExp = void 0;
+exports.globToRegExp = globToRegExp;
 const glob_to_reg_exp_js_1 = require("../_common/glob_to_reg_exp.js");
 const constants = {
     sep: "(?:\\\\|/)+",
@@ -66,8 +66,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.
+ */
 function globToRegExp(glob, options = {}) {
     return (0, glob_to_reg_exp_js_1._globToRegExp)(constants, glob, options);
 }
-exports.globToRegExp = globToRegExp;

package/script/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/script/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/script/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/is_absolute.js

@@ -2,13 +2,24 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAbsolute = void 0;
+exports.isAbsolute = isAbsolute;
 const constants_js_1 = require("../_common/constants.js");
 const assert_path_js_1 = require("../_common/assert_path.js");
 const _util_js_1 = require("./_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.
  */
 function isAbsolute(path) {
     (0, assert_path_js_1.assertPath)(path);
@@ -28,4 +39,3 @@ function isAbsolute(path) {
     }
     return false;
 }
-exports.isAbsolute = isAbsolute;

package/script/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/script/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/script/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/join.js

@@ -2,32 +2,33 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.join = void 0;
-const assert_js_1 = require("../../assert/assert.js");
+exports.join = join;
 const assert_path_js_1 = require("../_common/assert_path.js");
 const _util_js_1 = require("./_util.js");
 const normalize_js_1 = require("./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.
  */
 function join(...paths) {
+    paths.forEach((path) => (0, assert_path_js_1.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];
-        (0, assert_path_js_1.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.
     //
@@ -40,10 +41,10 @@ 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;
-    (0, assert_js_1.assert)(firstPart !== null);
+    const firstPart = paths[0];
     if ((0, _util_js_1.isPathSeparator)(firstPart.charCodeAt(0))) {
         ++slashCount;
         const firstLen = firstPart.length;
@@ -61,6 +62,7 @@ function join(...paths) {
             }
         }
     }
+    let joined = paths.join("\\");
     if (needsReplace) {
         // Find any more consecutive slashes we need to replace
         for (; slashCount < joined.length; ++slashCount) {
@@ -73,4 +75,3 @@ function join(...paths) {
     }
     return (0, normalize_js_1.normalize)(joined);
 }
-exports.join = join;

package/script/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/script/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/script/deps/{deno.land/std@0.224.0/path/posix → jsr.io/@std/path/1.0.8/windows}/join_globs.js

@@ -2,17 +2,32 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.joinGlobs = void 0;
+exports.joinGlobs = joinGlobs;
 const join_js_1 = require("./join.js");
 const constants_js_1 = require("./constants.js");
 const normalize_glob_js_1 = require("./normalize_glob.js");
-/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
-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.
+ */
+function joinGlobs(globs, options = {}) {
+    const { globstar = false } = options;
     if (!globstar || globs.length === 0) {
         return (0, join_js_1.join)(...globs);
     }
-    if (globs.length === 0)
-        return ".";
     let joined;
     for (const glob of globs) {
         const path = glob;
@@ -25,6 +40,5 @@ function joinGlobs(globs, { extended = true, globstar = false } = {}) {
     }
     if (!joined)
         return ".";
-    return (0, normalize_glob_js_1.normalizeGlob)(joined, { extended, globstar });
+    return (0, normalize_glob_js_1.normalizeGlob)(joined, { globstar });
 }
-exports.joinGlobs = joinGlobs;

package/script/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/script/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/script/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/normalize.js

@@ -2,7 +2,7 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalize = void 0;
+exports.normalize = normalize;
 const normalize_js_1 = require("../_common/normalize.js");
 const constants_js_1 = require("../_common/constants.js");
 const normalize_string_js_1 = require("../_common/normalize_string.js");
@@ -11,7 +11,21 @@ const _util_js_1 = require("./_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
  */
 function normalize(path) {
     (0, normalize_js_1.assertArg)(path);
@@ -111,12 +125,7 @@ function normalize(path) {
             else
                 return "\\";
         }
-        else if (tail.length > 0) {
-            return tail;
-        }
-        else {
-            return "";
-        }
+        return tail;
     }
     else if (isAbsolute) {
         if (tail.length > 0)
@@ -124,11 +133,5 @@ function normalize(path) {
         else
             return `${device}\\`;
     }
-    else if (tail.length > 0) {
-        return device + tail;
-    }
-    else {
-        return device;
-    }
+    return device + tail;
 }
-exports.normalize = normalize;

package/script/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/script/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/script/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/normalize_glob.js

@@ -2,11 +2,27 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeGlob = void 0;
+exports.normalizeGlob = normalizeGlob;
 const normalize_js_1 = require("./normalize.js");
 const constants_js_1 = require("./constants.js");
-/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
-function normalizeGlob(glob, { globstar = false } = {}) {
+/**
+ * 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.
+ */
+function normalizeGlob(glob, options = {}) {
+    const { globstar = false } = options;
     if (glob.match(/\0/g)) {
         throw new Error(`Glob contains invalid characters: "${glob}"`);
     }
@@ -17,4 +33,3 @@ function normalizeGlob(glob, { globstar = false } = {}) {
     const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g");
     return (0, normalize_js_1.normalize)(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
 }
-exports.normalizeGlob = normalizeGlob;

package/script/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/script/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/script/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/parse.js

@@ -2,13 +2,30 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = void 0;
+exports.parse = parse;
 const constants_js_1 = require("../_common/constants.js");
 const assert_path_js_1 = require("../_common/assert_path.js");
 const _util_js_1 = require("./_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.
  */
 function parse(path) {
     (0, assert_path_js_1.assertPath)(path);
@@ -160,4 +177,3 @@ function parse(path) {
         ret.dir = ret.root;
     return ret;
 }
-exports.parse = parse;

package/script/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/script/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/script/deps/{deno.land/std@0.224.0/path → jsr.io/@std/path/1.0.8}/windows/relative.js

@@ -2,7 +2,7 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.relative = void 0;
+exports.relative = relative;
 const constants_js_1 = require("../_common/constants.js");
 const resolve_js_1 = require("./resolve.js");
 const relative_js_1 = require("../_common/relative.js");
@@ -14,8 +14,18 @@ const relative_js_1 = require("../_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`
  */
 function relative(from, to) {
     (0, relative_js_1.assertArgs)(from, to);
@@ -122,4 +132,3 @@ function relative(from, to) {
         return toOrig.slice(toStart, toEnd);
     }
 }
-exports.relative = relative;

package/script/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/script/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"}