structured-outputs 0.1.0-beta.11 → 0.1.0-beta.14

package/types/deps/jsr.io/@std/path/1.0.8/posix/relative.d.ts

@@ -1,20 +0,0 @@
-/**
- * Return the relative path from `from` to `to` based on current working directory.
- *
- * If `from` and `to` are the same, return an empty string.
- *
- * @example Usage
- * ```ts
- * import { relative } from "@std/path/posix/relative";
- * import { assertEquals } from "@std/assert";
- *
- * const path = relative("/data/orandea/test/aaa", "/data/orandea/impl/bbb");
- * assertEquals(path, "../../impl/bbb");
- * ```
- *
- * @param from The path to start from.
- * @param to The path to reach.
- * @returns The relative path.
- */
-export declare function relative(from: string, to: string): string;
-//# sourceMappingURL=relative.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.8/posix/relative.d.ts.map

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

package/types/deps/jsr.io/@std/path/1.0.8/posix/resolve.d.ts

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

package/types/deps/jsr.io/@std/path/1.0.8/posix/resolve.d.ts.map

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

package/types/deps/jsr.io/@std/path/1.0.8/posix/to_file_url.d.ts

@@ -1,17 +0,0 @@
-/**
- * Converts a path string to a file URL.
- *
- * @example Usage
- * ```ts
- * import { toFileUrl } from "@std/path/posix/to-file-url";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(toFileUrl("/home/foo"), new URL("file:///home/foo"));
- * assertEquals(toFileUrl("/home/foo bar"), new URL("file:///home/foo%20bar"));
- * ```
- *
- * @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/types/deps/jsr.io/@std/path/1.0.8/posix/to_file_url.d.ts.map

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

package/types/deps/jsr.io/@std/path/1.0.8/posix/to_namespaced_path.d.ts

@@ -1,16 +0,0 @@
-/**
- * Converts a path to a namespaced path. This function returns the path as is on posix.
- *
- * @example Usage
- * ```ts
- * import { toNamespacedPath } from "@std/path/posix/to-namespaced-path";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(toNamespacedPath("/home/foo"), "/home/foo");
- * ```
- *
- * @param path The path.
- * @returns The namespaced path.
- */
-export declare function toNamespacedPath(path: string): string;
-//# sourceMappingURL=to_namespaced_path.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.8/posix/to_namespaced_path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"to_namespaced_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/posix/to_namespaced_path.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGrD"}

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

@@ -1,24 +0,0 @@
-/**
- * Return the relative path from `from` to `to` based on current working
- * directory.
- *
- * @example Usage
- * ```ts
- * import { relative } from "@std/path/relative";
- * import { assertEquals } from "@std/assert";
- *
- * if (Deno.build.os === "windows") {
- *   const path = relative("C:\\foobar\\test\\aaa", "C:\\foobar\\impl\\bbb");
- *   assertEquals(path, "..\\..\\impl\\bbb");
- * } else {
- *   const path = relative("/data/foobar/test/aaa", "/data/foobar/impl/bbb");
- *   assertEquals(path, "../../impl/bbb");
- * }
- * ```
- *
- * @param from Path in current working directory.
- * @param to Path in current working directory.
- * @returns The relative path from `from` to `to`.
- */
-export declare function relative(from: string, to: string): string;
-//# sourceMappingURL=relative.d.ts.map

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

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

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

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

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

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

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

@@ -1,22 +0,0 @@
-/**
- * Converts a path string to a file URL.
- *
- * @example Usage
- * ```ts
- * import { toFileUrl } from "@std/path/to-file-url";
- * import { assertEquals } from "@std/assert";
- *
- * if (Deno.build.os === "windows") {
- *   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"));
- * } else {
- *   assertEquals(toFileUrl("/home/foo"), new URL("file:///home/foo"));
- * }
- * ```
- *
- * @param path Path to convert to file URL.
- * @returns The file URL equivalent to the path.
- */
-export declare function toFileUrl(path: string): URL;
-//# sourceMappingURL=to_file_url.d.ts.map

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

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

package/types/deps/jsr.io/@std/path/1.0.8/to_namespaced_path.d.ts

@@ -1,21 +0,0 @@
-/**
- * Resolves path to a namespace path.  This is a no-op on
- * non-windows systems.
- *
- * @example Usage
- * ```ts
- * import { toNamespacedPath } from "@std/path/to-namespaced-path";
- * import { assertEquals } from "@std/assert";
- *
- * if (Deno.build.os === "windows") {
- *   assertEquals(toNamespacedPath("C:\\foo\\bar"), "\\\\?\\C:\\foo\\bar");
- * } else {
- *   assertEquals(toNamespacedPath("/foo/bar"), "/foo/bar");
- * }
- * ```
- *
- * @param path Path to resolve to namespace.
- * @returns The resolved namespace path.
- */
-export declare function toNamespacedPath(path: string): string;
-//# sourceMappingURL=to_namespaced_path.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.8/to_namespaced_path.d.ts.map

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

package/types/deps/jsr.io/@std/path/1.0.8/types.d.ts

@@ -1,38 +0,0 @@
-/**
- * A parsed path object generated by path.parse() or consumed by path.format().
- *
- * @example
- * ```ts
- * import { parse } from "@std/path";
- *
- * const parsedPathObj = parse("c:\\path\\dir\\index.html");
- * parsedPathObj.root; // "c:\\"
- * parsedPathObj.dir; // "c:\\path\\dir"
- * parsedPathObj.base; // "index.html"
- * parsedPathObj.ext; // ".html"
- * parsedPathObj.name; // "index"
- * ```
- */
-export interface ParsedPath {
-    /**
-     * The root of the path such as '/' or 'c:\'
-     */
-    root: string;
-    /**
-     * The full directory path of the parent such as '/home/user/dir' or 'c:\path\dir'
-     */
-    dir: string;
-    /**
-     * The file name including extension (if any) such as 'index.html'
-     */
-    base: string;
-    /**
-     * The file extension (if any) such as '.html'
-     */
-    ext: string;
-    /**
-     * The file name without extension (if any) such as 'index'
-     */
-    name: string;
-}
-//# sourceMappingURL=types.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.8/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/path/1.0.8/types.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CACd"}

package/types/deps/jsr.io/@std/path/1.0.8/windows/_util.d.ts

@@ -1,4 +0,0 @@
-export declare function isPosixPathSeparator(code: number): boolean;
-export declare function isPathSeparator(code: number): boolean;
-export declare function isWindowsDeviceRoot(code: number): boolean;
-//# sourceMappingURL=_util.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.8/windows/_util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/_util.ts"],"names":[],"mappings":"AAcA,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKzD"}

package/types/deps/jsr.io/@std/path/1.0.8/windows/basename.d.ts

@@ -1,23 +0,0 @@
-/**
- * Return the last portion of a `path`.
- * Trailing directory separators are ignored, and optional suffix is removed.
- *
- * @example Usage
- * ```ts
- * import { basename } from "@std/path/windows/basename";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(basename("C:\\user\\Documents\\"), "Documents");
- * assertEquals(basename("C:\\user\\Documents\\image.png"), "image.png");
- * assertEquals(basename("C:\\user\\Documents\\image.png", ".png"), "image");
- * ```
- *
- * Note: If you are working with file URLs,
- * use the new version of `basename` from `@std/path/windows/unstable-basename`.
- *
- * @param path The path to extract the name from.
- * @param suffix The suffix to remove from extracted name.
- * @returns The extracted name.
- */
-export declare function basename(path: string, suffix?: string): string;
-//# sourceMappingURL=basename.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.8/windows/basename.d.ts.map

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

package/types/deps/jsr.io/@std/path/1.0.8/windows/constants.d.ts

@@ -1,13 +0,0 @@
-/**
- * The character used to separate entries in the PATH environment variable.
- */
-export declare const DELIMITER: ";";
-/**
- * The character used to separate components of a file path.
- */
-export declare const SEPARATOR: "\\";
-/**
- * A regular expression that matches one or more path separators.
- */
-export declare const SEPARATOR_PATTERN: RegExp;
-//# sourceMappingURL=constants.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.8/windows/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/windows/constants.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,SAAS,KAAe,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,SAAS,MAAgB,CAAC;AACvC;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAW,CAAC"}

package/types/deps/jsr.io/@std/path/1.0.8/windows/dirname.d.ts

@@ -1,20 +0,0 @@
-/**
- * Return the directory path of a `path`.
- *
- * @example Usage
- * ```ts
- * import { dirname } from "@std/path/windows/dirname";
- * import { assertEquals } from "@std/assert";
- *
- * const dir = dirname("C:\\foo\\bar\\baz.ext");
- * assertEquals(dir, "C:\\foo\\bar");
- * ```
- *
- * Note: If you are working with file URLs,
- * use the new version of `dirname` from `@std/path/windows/unstable-dirname`.
- *
- * @param path The path to get the directory from.
- * @returns The directory path.
- */
-export declare function dirname(path: string): string;
-//# sourceMappingURL=dirname.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.8/windows/dirname.d.ts.map

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

package/types/deps/jsr.io/@std/path/1.0.8/windows/extname.d.ts

@@ -1,20 +0,0 @@
-/**
- * Return the extension of the `path` with leading period.
- *
- * @example Usage
- * ```ts
- * import { extname } from "@std/path/windows/extname";
- * import { assertEquals } from "@std/assert";
- *
- * const ext = extname("file.ts");
- * assertEquals(ext, ".ts");
- * ```
- *
- * Note: If you are working with file URLs,
- * use the new version of `extname` from `@std/path/windows/unstable-extname`.
- *
- * @param path The path to get the extension from.
- * @returns The extension of the `path`.
- */
-export declare function extname(path: string): string;
-//# sourceMappingURL=extname.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.8/windows/extname.d.ts.map

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

package/types/deps/jsr.io/@std/path/1.0.8/windows/format.d.ts

@@ -1,24 +0,0 @@
-import type { ParsedPath } from "../types.js";
-/**
- * Generate a path from `ParsedPath` object.
- *
- * @example Usage
- * ```ts
- * import { format } from "@std/path/windows/format";
- * import { assertEquals } from "@std/assert";
- *
- * const path = format({
- *   root: "C:\\",
- *   dir: "C:\\path\\dir",
- *   base: "file.txt",
- *   ext: ".txt",
- *   name: "file"
- * });
- * assertEquals(path, "C:\\path\\dir\\file.txt");
- * ```
- *
- * @param pathObject The path object to format.
- * @returns The formatted path.
- */
-export declare function format(pathObject: Partial<ParsedPath>): string;
-//# sourceMappingURL=format.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.8/windows/format.d.ts.map

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

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

@@ -1,18 +0,0 @@
-/**
- * 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/types/deps/jsr.io/@std/path/1.0.8/windows/from_file_url.d.ts.map

@@ -1 +0,0 @@
-{"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/types/deps/jsr.io/@std/path/1.0.8/windows/glob_to_regexp.d.ts

@@ -1,71 +0,0 @@
-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.
- *
- * Basic glob syntax:
- * - `*` - Matches everything without leaving the path segment.
- * - `?` - Matches any single character.
- * - `{foo,bar}` - Matches `foo` or `bar`.
- * - `[abcd]` - Matches `a`, `b`, `c` or `d`.
- * - `[a-d]` - Matches `a`, `b`, `c` or `d`.
- * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.
- * - `[[:<class>:]]` - Matches any character belonging to `<class>`.
- *     - `[[:alnum:]]` - Matches any digit or letter.
- *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.
- *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes
- *       for a complete list of supported character classes.
- * - `\` - Escapes the next character for an `os` other than `"windows"`.
- * - \` - Escapes the next character for `os` set to `"windows"`.
- * - `/` - Path separator.
- * - `\` - Additional path separator only for `os` set to `"windows"`.
- *
- * Extended syntax:
- * - Requires `{ extended: true }`.
- * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.
- * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.
- * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.
- * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.
- * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.
- * - See https://www.linuxjournal.com/content/bash-extended-globbing.
- *
- * Globstar syntax:
- * - Requires `{ globstar: true }`.
- * - `**` - Matches any number of any path segments.
- *     - Must comprise its entire path segment in the provided glob.
- * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
- *
- * Note the following properties:
- * - The generated `RegExp` is anchored at both start and end.
- * - Repeating and trailing separators are tolerated. Trailing separators in the
- *   provided glob have no meaning and are discarded.
- * - Absolute globs will only match absolute paths, etc.
- * - Empty globs will match nothing.
- * - Any special glob syntax must be contained to one path segment. For example,
- *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the
- *   first segment ends with an unclosed group.
- * - If a path segment ends with unclosed groups or a dangling escape prefix, a
- *   parse error has occurred. Every character for that segment is taken
- *   literally in this event.
- *
- * Limitations:
- * - A negative group like `!(foo|bar)` will wrongly be converted to a negative
- *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly
- *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,
- *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if
- *   the group occurs not nested at the end of the segment.
- *
- * @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/types/deps/jsr.io/@std/path/1.0.8/windows/glob_to_regexp.d.ts.map

@@ -1 +0,0 @@
-{"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/types/deps/jsr.io/@std/path/1.0.8/windows/is_absolute.d.ts

@@ -1,17 +0,0 @@
-/**
- * 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/types/deps/jsr.io/@std/path/1.0.8/windows/is_absolute.d.ts.map

@@ -1 +0,0 @@
-{"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/types/deps/jsr.io/@std/path/1.0.8/windows/join.d.ts

@@ -1,20 +0,0 @@
-/**
- * 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/types/deps/jsr.io/@std/path/1.0.8/windows/join.d.ts.map

@@ -1 +0,0 @@
-{"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/types/deps/jsr.io/@std/path/1.0.8/windows/join_globs.d.ts

@@ -1,21 +0,0 @@
-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/types/deps/jsr.io/@std/path/1.0.8/windows/join_globs.d.ts.map

@@ -1 +0,0 @@
-{"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/types/deps/jsr.io/@std/path/1.0.8/windows/normalize.d.ts

@@ -1,22 +0,0 @@
-/**
- * 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/types/deps/jsr.io/@std/path/1.0.8/windows/normalize.d.ts.map

@@ -1 +0,0 @@
-{"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/types/deps/jsr.io/@std/path/1.0.8/windows/normalize_glob.d.ts

@@ -1,20 +0,0 @@
-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/types/deps/jsr.io/@std/path/1.0.8/windows/normalize_glob.d.ts.map

@@ -1 +0,0 @@
-{"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/types/deps/jsr.io/@std/path/1.0.8/windows/parse.d.ts

@@ -1,25 +0,0 @@
-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/types/deps/jsr.io/@std/path/1.0.8/windows/parse.d.ts.map

@@ -1 +0,0 @@
-{"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"}