windmill-cli 1.641.0 → 1.643.0

package/types/deps/jsr.io/@std/log/0.224.14/mod.d.ts

@@ -1,394 +0,0 @@
-/**
- * Logging library with support for terminal and file outputs. Also provides
- * interfaces for building custom loggers.
- *
- * > [!IMPORTANT]
- * > @std/log is [likely to be removed in the future](https://github.com/denoland/std/issues/6124).
- * > Consider using [Open Telemetry](https://docs.deno.com/runtime/fundamentals/open_telemetry/).
- *
- * ## Loggers
- *
- * Loggers are objects that you interact with. When you use a logger method it
- * constructs a `LogRecord` and passes it down to its handlers for output. To
- * create custom loggers, specify them in `loggers` when calling `log.setup`.
- *
- * ## Custom message format
- *
- * If you want to override default format of message you can define `formatter`
- * option for handler. It can a function that takes `LogRecord`
- * as argument and outputs string.
- *
- * The default log format is `{levelName} {msg}`.
- *
- * ### Logging Structured JSON Lines
- *
- * To output logs in a structured JSON format you can configure most handlers
- * with a formatter that produces a JSON string. Either use the premade
- * `log.formatters.jsonFormatter` or write your own function that takes a
- * {@linkcode LogRecord} and returns a JSON.stringify'd object.
- * If you want the log to go to stdout then use {@linkcode ConsoleHandler} with
- * the configuration `useColors: false` to turn off the ANSI terminal colors.
- *
- * ```ts
- * import * as log from "@std/log";
- *
- * log.setup({
- *   handlers: {
- *     default: new log.ConsoleHandler("DEBUG", {
- *       formatter: log.formatters.jsonFormatter,
- *       useColors: false,
- *     }),
- *   },
- * });
- * ```
- *
- * The first argument passed to a log function is always treated as the
- * message and will be stringified differently. To have arguments JSON.stringify'd
- * you must pass them after the first.
- *
- * ```ts
- * import * as log from "@std/log";
- *
- * log.info("This is the message", { thisWillBe: "JSON.stringify'd"});
- * // {"level":"INFO","datetime":1702501580505,"message":"This is the message","args":{"thisWillBe":"JSON.stringify'd"}}
- *
- * log.info({ thisWontBe: "JSON.stringify'd"}, "This is an argument");
- * // {"level":"INFO","datetime":1702501580505,"message":"{\"thisWontBe\":\"JSON.stringify'd\"}","args":"This is an argument"}
- * ```
- *
- * ## Inline Logging
- *
- * Log functions return the data passed in the `msg` parameter. Data is returned
- * regardless if the logger actually logs it.
- *
- * ## Lazy Log Evaluation
- *
- * Some log statements are expensive to compute. In these cases, you can use
- * lazy log evaluation to prevent the computation taking place if the logger
- * won't log the message.
- *
- * > NOTE: When using lazy log evaluation, `undefined` will be returned if the
- * > resolver function is not called because the logger won't log it. It is an
- * > antipattern use lazy evaluation with inline logging because the return value
- * > depends on the current log level.
- *
- * ## For module authors
- *
- * The authors of public modules can let the users display the internal logs of the
- * module by using a custom logger:
- *
- * ```ts
- * import { getLogger } from "@std/log";
- *
- * function logger() {
- *   return getLogger("my-awesome-module");
- * }
- *
- * function sum(a: number, b: number) {
- *   logger().debug(`running ${a} + ${b}`);
- *   return a + b;
- * }
- *
- * function mult(a: number, b: number) {
- *   logger().debug(`running ${a} * ${b}`);
- *   return a * b;
- * }
- * ```
- *
- * The user of the module can then display the internal logs with:
- *
- * ```ts, ignore
- * import * as log from "@std/log";
- * import { sum } from "<the-awesome-module>/mod.ts";
- *
- * log.setup({
- *   handlers: {
- *     console: new log.ConsoleHandler("DEBUG"),
- *   },
- *
- *   loggers: {
- *     "my-awesome-module": {
- *       level: "DEBUG",
- *       handlers: ["console"],
- *     },
- *   },
- * });
- *
- * sum(1, 2); // prints "running 1 + 2" to the console
- * ```
- *
- * Please note that, due to the order of initialization of the loggers, the
- * following won't work:
- *
- * ```ts
- * import { getLogger } from "@std/log";
- *
- * const logger = getLogger("my-awesome-module");
- *
- * function sum(a: number, b: number) {
- *   logger.debug(`running ${a} + ${b}`); // no message will be logged, because getLogger() was called before log.setup()
- *   return a + b;
- * }
- * ```
- *
- * @example
- * ```ts ignore
- * import * as log from "@std/log";
- *
- * // Simple default logger out of the box. You can customize it
- * // by overriding logger and handler named "default", or providing
- * // additional logger configurations. You can log any data type.
- * log.debug("Hello world");
- * log.info(123456);
- * log.warn(true);
- * log.error({ foo: "bar", fizz: "bazz" });
- * log.critical("500 Internal server error");
- *
- * // custom configuration with 2 loggers (the default and `tasks` loggers).
- * log.setup({
- *   handlers: {
- *     console: new log.ConsoleHandler("DEBUG"),
- *
- *     file: new log.FileHandler("WARN", {
- *       filename: "./log.txt",
- *       // you can change format of output message using any keys in `LogRecord`.
- *       formatter: (record) => `${record.levelName} ${record.msg}`,
- *     }),
- *   },
- *
- *   loggers: {
- *     // configure default logger available via short-hand methods above.
- *     default: {
- *       level: "DEBUG",
- *       handlers: ["console", "file"],
- *     },
- *
- *     tasks: {
- *       level: "ERROR",
- *       handlers: ["console"],
- *     },
- *   },
- * });
- *
- * let logger;
- *
- * // get default logger.
- * logger = log.getLogger();
- * logger.debug("fizz"); // logs to `console`, because `file` handler requires "WARN" level.
- * logger.warn(41256); // logs to both `console` and `file` handlers.
- *
- * // get custom logger
- * logger = log.getLogger("tasks");
- * logger.debug("fizz"); // won't get output because this logger has "ERROR" level.
- * logger.error({ productType: "book", value: "126.11" }); // log to `console`.
- *
- * // if you try to use a logger that hasn't been configured
- * // you're good to go, it gets created automatically with level set to 0
- * // so no message is logged.
- * const unknownLogger = log.getLogger("mystery");
- * unknownLogger.info("foobar"); // no-op
- * ```
- *
- * @example
- * Custom message format example
- * ```ts
- * import * as log from "@std/log";
- *
- * log.setup({
- *   handlers: {
- *     stringFmt: new log.ConsoleHandler("DEBUG", {
- *       formatter: (record) => `[${record.levelName}] ${record.msg}`,
- *     }),
- *
- *     functionFmt: new log.ConsoleHandler("DEBUG", {
- *       formatter: (logRecord) => {
- *         let msg = `${logRecord.level} ${logRecord.msg}`;
- *
- *         logRecord.args.forEach((arg, index) => {
- *           msg += `, arg${index}: ${arg}`;
- *         });
- *
- *         return msg;
- *       },
- *     }),
- *
- *     anotherFmt: new log.ConsoleHandler("DEBUG", {
- *       formatter: (record) => `[${record.loggerName}] - ${record.levelName} ${record.msg}`,
- *     }),
- *   },
- *
- *   loggers: {
- *     default: {
- *       level: "DEBUG",
- *       handlers: ["stringFmt", "functionFmt"],
- *     },
- *     dataLogger: {
- *       level: "INFO",
- *       handlers: ["anotherFmt"],
- *     },
- *   },
- * });
- *
- * // calling:
- * log.debug("Hello, world!", 1, "two", [3, 4, 5]);
- * // results in: [DEBUG] Hello, world!
- * // output from "stringFmt" handler.
- * // 10 Hello, world!, arg0: 1, arg1: two, arg3: [3, 4, 5] // output from "functionFmt" formatter.
- *
- * // calling:
- * log.getLogger("dataLogger").error("oh no!");
- * // results in:
- * // [dataLogger] - ERROR oh no! // output from anotherFmt handler.
- * ```
-
- *
- * @example
- * JSON to stdout with no color example
- * ```ts
- * import * as log from "@std/log";
- *
- * log.setup({
- *   handlers: {
- *     jsonStdout: new log.ConsoleHandler("DEBUG", {
- *       formatter: log.formatters.jsonFormatter,
- *       useColors: false,
- *     }),
- *   },
- *
- *   loggers: {
- *     default: {
- *       level: "DEBUG",
- *       handlers: ["jsonStdout"],
- *     },
- *   },
- * });
- *
- * // calling:
- * log.info("Hey");
- * // results in:
- * // {"level":"INFO","datetime":1702481922294,"message":"Hey"}
- *
- * // calling:
- * log.info("Hey", { product: "nail" });
- * // results in:
- * // {"level":"INFO","datetime":1702484111115,"message":"Hey","args":{"product":"nail"}}
- *
- * // calling:
- * log.info("Hey", 1, "two", [3, 4, 5]);
- * // results in:
- * // {"level":"INFO","datetime":1702481922294,"message":"Hey","args":[1,"two",[3,4,5]]}
- * ```
- *
- * @example
- * Custom JSON example
- * ```ts
- * import * as log from "@std/log";
- *
- * log.setup({
- *   handlers: {
- *     customJsonFmt: new log.ConsoleHandler("DEBUG", {
- *       formatter: (record) => JSON.stringify({
- *         lvl: record.level,
- *         msg: record.msg,
- *         time: record.datetime.toISOString(),
- *         name: record.loggerName,
- *       }),
- *       useColors: false,
- *     }),
- *   },
- *
- *   loggers: {
- *     default: {
- *       level: "DEBUG",
- *       handlers: ["customJsonFmt"],
- *     },
- *   },
- * });
- *
- * // calling:
- * log.info("complete");
- * // results in:
- * // {"lvl":20,"msg":"complete","time":"2023-12-13T16:38:27.328Z","name":"default"}
- * ```
- *
- * @example
- * Inline Logging
- * ```ts
- * import * as logger from "@std/log";
- *
- * const stringData: string = logger.debug("hello world");
- * const booleanData: boolean = logger.debug(true, 1, "abc");
- * const fn = (): number => {
- *   return 123;
- * };
- * const resolvedFunctionData: number = logger.debug(fn());
- * console.log(stringData); // 'hello world'
- * console.log(booleanData); // true
- * console.log(resolvedFunctionData); // 123
- * ```
- *
- * @example
- * Lazy Log Evaluation
- * ```ts
- * import * as log from "@std/log";
- *
- * log.setup({
- *   handlers: {
- *     console: new log.ConsoleHandler("DEBUG"),
- *   },
- *
- *   loggers: {
- *     tasks: {
- *       level: "ERROR",
- *       handlers: ["console"],
- *     },
- *   },
- * });
- *
- * function someExpensiveFn(num: number, bool: boolean) {
- *   // do some expensive computation
- * }
- *
- * // not logged, as debug < error.
- * const data = log.debug(() => someExpensiveFn(5, true));
- * console.log(data); // undefined
- * ```
- *
- * Handlers are responsible for actual output of log messages. When a handler is
- * called by a logger, it firstly checks that {@linkcode LogRecord}'s level is
- * not lower than level of the handler. If level check passes, handlers formats
- * log record into string and outputs it to target.
- *
- * ## Custom handlers
- *
- * Custom handlers can be implemented by subclassing {@linkcode BaseHandler} or
- * {@linkcode WriterHandler}.
- *
- * {@linkcode BaseHandler} is bare-bones handler that has no output logic at all,
- *
- * {@linkcode WriterHandler} is an abstract class that supports any target with
- * `Writer` interface.
- *
- * During setup async hooks `setup` and `destroy` are called, you can use them
- * to open and close file/HTTP connection or any other action you might need.
- *
- * For examples check source code of {@linkcode FileHandler}`
- * and {@linkcode TestHandler}.
- *
- * @module
- */
-export * from "./base_handler.js";
-export * from "./console_handler.js";
-export * from "./file_handler.js";
-export * from "./rotating_file_handler.js";
-export * from "./levels.js";
-export * from "./logger.js";
-export * from "./formatters.js";
-export * from "./critical.js";
-export * from "./debug.js";
-export * from "./error.js";
-export * from "./get_logger.js";
-export * from "./info.js";
-export * from "./setup.js";
-export * from "./warn.js";
-//# sourceMappingURL=mod.d.ts.map

package/types/deps/jsr.io/@std/log/0.224.14/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/mod.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0XG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.14/rotating_file_handler.d.ts

@@ -1,53 +0,0 @@
-import type { LevelName } from "./levels.js";
-import { FileHandler, type FileHandlerOptions } from "./file_handler.js";
-interface RotatingFileHandlerOptions extends FileHandlerOptions {
-    maxBytes: number;
-    maxBackupCount: number;
-}
-/**
- * This handler extends the functionality of the {@linkcode FileHandler} by
- * "rotating" the log file when it reaches a certain size. `maxBytes` specifies
- * the maximum size in bytes that the log file can grow to before rolling over
- * to a new one. If the size of the new log message plus the current log file
- * size exceeds `maxBytes` then a roll-over is triggered. When a roll-over
- * occurs, before the log message is written, the log file is renamed and
- * appended with `.1`. If a `.1` version already existed, it would have been
- * renamed `.2` first and so on. The maximum number of log files to keep is
- * specified by `maxBackupCount`. After the renames are complete the log message
- * is written to the original, now blank, file.
- *
- * Example: Given `log.txt`, `log.txt.1`, `log.txt.2` and `log.txt.3`, a
- * `maxBackupCount` of 3 and a new log message which would cause `log.txt` to
- * exceed `maxBytes`, then `log.txt.2` would be renamed to `log.txt.3` (thereby
- * discarding the original contents of `log.txt.3` since 3 is the maximum number
- * of backups to keep), `log.txt.1` would be renamed to `log.txt.2`, `log.txt`
- * would be renamed to `log.txt.1` and finally `log.txt` would be created from
- * scratch where the new log message would be written.
- *
- * This handler uses a buffer for writing log messages to file. Logs can be
- * manually flushed with `fileHandler.flush()`. Log messages with a log level
- * greater than ERROR are immediately flushed. Logs are also flushed on process
- * completion.
- *
- * Additional notes on `mode` as described above:
- *
- * - `'a'` Default mode. As above, this will pick up where the logs left off in
- *   rotation, or create a new log file if it doesn't exist.
- * - `'w'` in addition to starting with a clean `filename`, this mode will also
- *   cause any existing backups (up to `maxBackupCount`) to be deleted on setup
- *   giving a fully clean slate.
- * - `'x'` requires that neither `filename`, nor any backups (up to
- *   `maxBackupCount`), exist before setup.
- *
- * This handler requires both `--allow-read` and `--allow-write` permissions on
- * the log files.
- */
-export declare class RotatingFileHandler extends FileHandler {
-    #private;
-    constructor(levelName: LevelName, options: RotatingFileHandlerOptions);
-    setup(): void;
-    log(msg: string): void;
-    rotateLogFiles(): void;
-}
-export {};
-//# sourceMappingURL=rotating_file_handler.d.ts.map

package/types/deps/jsr.io/@std/log/0.224.14/rotating_file_handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rotating_file_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/rotating_file_handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AASzE,UAAU,0BAA2B,SAAQ,kBAAkB;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;;gBAKtC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,0BAA0B;IAM5D,KAAK;IAyCL,GAAG,CAAC,GAAG,EAAE,MAAM;IAaxB,cAAc;CAkBf"}

package/types/deps/jsr.io/@std/log/0.224.14/setup.d.ts

@@ -1,4 +0,0 @@
-import { type LogConfig } from "./logger.js";
-/** Setup logger config. */
-export declare function setup(config: LogConfig): void;
-//# sourceMappingURL=setup.d.ts.map

package/types/deps/jsr.io/@std/log/0.224.14/setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/setup.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,SAAS,EAAU,MAAM,aAAa,CAAC;AAGrD,2BAA2B;AAC3B,wBAAgB,KAAK,CAAC,MAAM,EAAE,SAAS,QAwCtC"}

package/types/deps/jsr.io/@std/log/0.224.14/warn.d.ts

@@ -1,53 +0,0 @@
-import type { GenericFunction } from "./logger.js";
-import "./setup.js";
-export type { GenericFunction };
-/**
- * Log at the warning level.
- *
- * This function is a pass-through to the default logger's `warn` method. By
- * default, the default logger is configured to use {@linkcode console.log} and
- * print in yellow text.
- *
- * @template T The type of the message to log.
- * @param msg The message to log.
- * @param args Arguments to be formatted into the message.
- * @returns The message that was logged.
- *
- * @example Usage
- * ```ts
- * import { warn } from "@std/log/warn";
- * import { assertEquals } from "@std/assert/equals";
- *
- * assertEquals(warn("This is a warning message."), "This is a warning message.");
- * // Prints: "WARN This is a warning message."
- *
- * assertEquals(warn(() => "This is a warning message."), "This is a warning message.");
- * // Prints: "WARN This is a warning message."
- * ```
- */
-export declare function warn<T>(msg: () => T, ...args: unknown[]): T | undefined;
-/**
- * Log at the warning level.
- *
- * This function is a pass-through to the default logger's `warn` method. By
- * default, the default logger is configured to use {@linkcode console.log}.
- *
- * @template T The type of the message to log.
- * @param msg The message to log.
- * @param args Arguments to be formatted into the message.
- * @returns The message that was logged.
- *
- * @example Usage
- * ```ts
- * import { warn } from "@std/log/warn";
- * import { assertEquals } from "@std/assert/equals";
- *
- * assertEquals(warn("This is a warning message."), "This is a warning message.");
- * // Prints: "WARN This is a warning message."
- *
- * assertEquals(warn(() => "This is a warning message."), "This is a warning message.");
- * // Prints: "WARN This is a warning message."
- * ```
- */
-export declare function warn<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
-//# sourceMappingURL=warn.d.ts.map

package/types/deps/jsr.io/@std/log/0.224.14/warn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"warn.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.14/warn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AACzE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,GAAG,EAAE,CAAC,SAAS,eAAe,GAAG,KAAK,GAAG,CAAC,EAC1C,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,CAAC,CAAC"}

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/assert_path.d.ts

@@ -1,2 +0,0 @@
-export declare function assertPath(path?: string): void;
-//# sourceMappingURL=assert_path.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/assert_path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.0-rc.2/_common/assert_path.ts"],"names":[],"mappings":"AAGA,wBAAgB,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,QAMvC"}

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/basename.d.ts

@@ -1,4 +0,0 @@
-export declare function stripSuffix(name: string, suffix: string): string;
-export declare function lastPathSegment(path: string, isSep: (char: number) => boolean, start?: number): string;
-export declare function assertArgs(path: string, suffix: string): string | undefined;
-//# sourceMappingURL=basename.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/basename.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"basename.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.0-rc.2/_common/basename.ts"],"names":[],"mappings":"AAKA,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAchE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAChC,KAAK,SAAI,GACR,MAAM,CAiBR;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,sBAQtD"}

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/common.d.ts

@@ -1,2 +0,0 @@
-export declare function common(paths: string[], sep: string): string;
-//# sourceMappingURL=common.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/common.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.0-rc.2/_common/common.ts"],"names":[],"mappings":"AAGA,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAsB3D"}

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/constants.d.ts

@@ -1,40 +0,0 @@
-export declare const CHAR_UPPERCASE_A = 65;
-export declare const CHAR_LOWERCASE_A = 97;
-export declare const CHAR_UPPERCASE_Z = 90;
-export declare const CHAR_LOWERCASE_Z = 122;
-export declare const CHAR_DOT = 46;
-export declare const CHAR_FORWARD_SLASH = 47;
-export declare const CHAR_BACKWARD_SLASH = 92;
-export declare const CHAR_VERTICAL_LINE = 124;
-export declare const CHAR_COLON = 58;
-export declare const CHAR_QUESTION_MARK = 63;
-export declare const CHAR_UNDERSCORE = 95;
-export declare const CHAR_LINE_FEED = 10;
-export declare const CHAR_CARRIAGE_RETURN = 13;
-export declare const CHAR_TAB = 9;
-export declare const CHAR_FORM_FEED = 12;
-export declare const CHAR_EXCLAMATION_MARK = 33;
-export declare const CHAR_HASH = 35;
-export declare const CHAR_SPACE = 32;
-export declare const CHAR_NO_BREAK_SPACE = 160;
-export declare const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279;
-export declare const CHAR_LEFT_SQUARE_BRACKET = 91;
-export declare const CHAR_RIGHT_SQUARE_BRACKET = 93;
-export declare const CHAR_LEFT_ANGLE_BRACKET = 60;
-export declare const CHAR_RIGHT_ANGLE_BRACKET = 62;
-export declare const CHAR_LEFT_CURLY_BRACKET = 123;
-export declare const CHAR_RIGHT_CURLY_BRACKET = 125;
-export declare const CHAR_HYPHEN_MINUS = 45;
-export declare const CHAR_PLUS = 43;
-export declare const CHAR_DOUBLE_QUOTE = 34;
-export declare const CHAR_SINGLE_QUOTE = 39;
-export declare const CHAR_PERCENT = 37;
-export declare const CHAR_SEMICOLON = 59;
-export declare const CHAR_CIRCUMFLEX_ACCENT = 94;
-export declare const CHAR_GRAVE_ACCENT = 96;
-export declare const CHAR_AT = 64;
-export declare const CHAR_AMPERSAND = 38;
-export declare const CHAR_EQUAL = 61;
-export declare const CHAR_0 = 48;
-export declare const CHAR_9 = 57;
-//# sourceMappingURL=constants.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.0-rc.2/_common/constants.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAGpC,eAAO,MAAM,QAAQ,KAAK,CAAC;AAC3B,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,6BAA6B,QAAQ,CAAC;AACnD,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAC5C,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,OAAO,KAAK,CAAC;AAC1B,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,UAAU,KAAK,CAAC;AAG7B,eAAO,MAAM,MAAM,KAAK,CAAC;AACzB,eAAO,MAAM,MAAM,KAAK,CAAC"}

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/dirname.d.ts

@@ -1,2 +0,0 @@
-export declare function assertArg(path: string): "." | undefined;
-//# sourceMappingURL=dirname.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/dirname.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dirname.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.0-rc.2/_common/dirname.ts"],"names":[],"mappings":"AAKA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,mBAGrC"}

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/format.d.ts

@@ -1,4 +0,0 @@
-import type { FormatInputPathObject } from "../_interface.js";
-export declare function _format(sep: string, pathObject: FormatInputPathObject): string;
-export declare function assertArg(pathObject: FormatInputPathObject): void;
-//# sourceMappingURL=format.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/format.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.0-rc.2/_common/format.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D,wBAAgB,OAAO,CACrB,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAQR;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,qBAAqB,QAM1D"}

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/from_file_url.d.ts

@@ -1,2 +0,0 @@
-export declare function assertArg(url: URL | string): URL;
-//# sourceMappingURL=from_file_url.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/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.0-rc.2/_common/from_file_url.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,OAM1C"}

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/glob_to_reg_exp.d.ts

@@ -1,34 +0,0 @@
-/** Options for {@linkcode globToRegExp}. */
-export interface GlobOptions {
-    /** Extended glob syntax.
-     * See https://www.linuxjournal.com/content/bash-extended-globbing.
-     *
-     * @default {true}
-     */
-    extended?: boolean;
-    /** Globstar syntax.
-     * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
-     * If false, `**` is treated like `*`.
-     *
-     * @default {true}
-     */
-    globstar?: boolean;
-    /**
-     * Whether globstar should be case-insensitive.
-     *
-     * @default {false}
-     */
-    caseInsensitive?: boolean;
-}
-/** Options for {@linkcode globToRegExp}. */
-export type GlobToRegExpOptions = GlobOptions;
-export interface GlobConstants {
-    sep: string;
-    sepMaybe: string;
-    seps: string[];
-    globstar: string;
-    wildcard: string;
-    escapePrefix: string;
-}
-export declare function _globToRegExp(c: GlobConstants, glob: string, { extended, globstar: globstarOption, caseInsensitive, }?: GlobToRegExpOptions): RegExp;
-//# sourceMappingURL=glob_to_reg_exp.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/glob_to_reg_exp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glob_to_reg_exp.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.0-rc.2/_common/glob_to_reg_exp.ts"],"names":[],"mappings":"AAGA,4CAA4C;AAC5C,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,4CAA4C;AAC5C,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC;AAwB9C,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,aAAa,CAC3B,CAAC,EAAE,aAAa,EAChB,IAAI,EAAE,MAAM,EACZ,EACE,QAAe,EACf,QAAQ,EAAE,cAAqB,EAE/B,eAAuB,GACxB,GAAE,mBAAwB,GAC1B,MAAM,CA4NR"}

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/normalize.d.ts

@@ -1,2 +0,0 @@
-export declare function assertArg(path: string): "." | undefined;
-//# sourceMappingURL=normalize.d.ts.map

package/types/deps/jsr.io/@std/path/1.0.0-rc.2/_common/normalize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.0-rc.2/_common/normalize.ts"],"names":[],"mappings":"AAKA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,mBAGrC"}