@logtape/file 1.4.0-dev.444 → 1.4.0-dev.446

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/_util.cjs

@@ -0,0 +1,13 @@
+const require_constants = require('../_common/constants.cjs');
+
+//#region ../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/_util.js
+function isPathSeparator(code) {
+	return code === require_constants.CHAR_FORWARD_SLASH || code === require_constants.CHAR_BACKWARD_SLASH;
+}
+function isWindowsDeviceRoot(code) {
+	return code >= require_constants.CHAR_LOWERCASE_A && code <= require_constants.CHAR_LOWERCASE_Z || code >= require_constants.CHAR_UPPERCASE_A && code <= require_constants.CHAR_UPPERCASE_Z;
+}
+
+//#endregion
+exports.isPathSeparator = isPathSeparator;
+exports.isWindowsDeviceRoot = isWindowsDeviceRoot;

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/_util.js

@@ -0,0 +1,13 @@
+import { CHAR_BACKWARD_SLASH, CHAR_FORWARD_SLASH, CHAR_LOWERCASE_A, CHAR_LOWERCASE_Z, CHAR_UPPERCASE_A, CHAR_UPPERCASE_Z } from "../_common/constants.js";
+
+//#region ../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/_util.js
+function isPathSeparator(code) {
+	return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+function isWindowsDeviceRoot(code) {
+	return code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z || code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z;
+}
+
+//#endregion
+export { isPathSeparator, isWindowsDeviceRoot };
+//# sourceMappingURL=_util.js.map

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/_util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_util.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/_util.js"],"sourcesContent":["// Copyright 2018-2025 the Deno authors. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\nimport { CHAR_BACKWARD_SLASH, CHAR_FORWARD_SLASH, CHAR_LOWERCASE_A, CHAR_LOWERCASE_Z, CHAR_UPPERCASE_A, CHAR_UPPERCASE_Z } from \"../_common/constants.js\";\nexport function isPosixPathSeparator(code) {\n  return code === CHAR_FORWARD_SLASH;\n}\nexport function isPathSeparator(code) {\n  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;\n}\nexport function isWindowsDeviceRoot(code) {\n  return code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z || code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z;\n}\n//# sourceMappingURL=_util.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAQA,SAAgB,gBAAgB,MAAM;AACpC,QAAO,SAAS,sBAAsB,SAAS;AAChD;AACD,SAAgB,oBAAoB,MAAM;AACxC,QAAO,QAAQ,oBAAoB,QAAQ,oBAAoB,QAAQ,oBAAoB,QAAQ;AACpG"}

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/from_file_url.cjs

@@ -0,0 +1,27 @@
+const require_from_file_url = require('../_common/from_file_url.cjs');
+
+//#region ../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/from_file_url.js
+/**
+* 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.
+*/ function fromFileUrl(url) {
+	url = require_from_file_url.assertArg(url);
+	let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\");
+	if (url.hostname !== "") path = `\\\\${url.hostname}${path}`;
+	return path;
+}
+
+//#endregion
+exports.fromFileUrl = fromFileUrl;

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/from_file_url.js

@@ -0,0 +1,28 @@
+import { assertArg } from "../_common/from_file_url.js";
+
+//#region ../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/from_file_url.js
+/**
+* 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.
+*/ function fromFileUrl(url) {
+	url = assertArg(url);
+	let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\");
+	if (url.hostname !== "") path = `\\\\${url.hostname}${path}`;
+	return path;
+}
+
+//#endregion
+export { fromFileUrl };
+//# sourceMappingURL=from_file_url.js.map

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/from_file_url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"from_file_url.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/from_file_url.js"],"sourcesContent":["// Copyright 2018-2025 the Deno authors. MIT license.\n// This module is browser compatible.\nimport { assertArg } from \"../_common/from_file_url.js\";\n/**\n * Converts a file URL to a path string.\n *\n * @example Usage\n * ```ts\n * import { fromFileUrl } from \"@std/path/windows/from-file-url\";\n * import { assertEquals } from \"@std/assert\";\n *\n * assertEquals(fromFileUrl(\"file:///home/foo\"), \"\\\\home\\\\foo\");\n * assertEquals(fromFileUrl(\"file:///C:/Users/foo\"), \"C:\\\\Users\\\\foo\");\n * assertEquals(fromFileUrl(\"file://localhost/home/foo\"), \"\\\\home\\\\foo\");\n * ```\n *\n * @param url The file URL to convert.\n * @returns The path string.\n */ export function fromFileUrl(url) {\n  url = assertArg(url);\n  let path = decodeURIComponent(url.pathname.replace(/\\//g, \"\\\\\").replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\")).replace(/^\\\\*([A-Za-z]:)(\\\\|$)/, \"$1\\\\\");\n  if (url.hostname !== \"\") {\n    // Note: The `URL` implementation guarantees that the drive letter and\n    // hostname are mutually exclusive. Otherwise it would not have been valid\n    // to append the hostname and path like this.\n    path = `\\\\\\\\${url.hostname}${path}`;\n  }\n  return path;\n}\n//# sourceMappingURL=from_file_url.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;GAkBI,SAAgB,YAAY,KAAK;AACnC,OAAM,UAAU,IAAI;CACpB,IAAI,OAAO,mBAAmB,IAAI,SAAS,QAAQ,OAAO,KAAK,CAAC,QAAQ,wBAAwB,MAAM,CAAC,CAAC,QAAQ,yBAAyB,OAAO;AAChJ,KAAI,IAAI,aAAa,GAInB,SAAQ,MAAM,IAAI,SAAS,EAAE,KAAK;AAEpC,QAAO;AACR"}

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/join.cjs

@@ -0,0 +1,51 @@
+const require_assert_path = require('../_common/assert_path.cjs');
+const require__util = require('./_util.cjs');
+const require_from_file_url = require('./from_file_url.cjs');
+const require_normalize = require('./normalize.cjs');
+
+//#region ../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/join.js
+/**
+* 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";
+*
+* assertEquals(join("C:\\foo", "bar", "baz\\.."), "C:\\foo\\bar");
+* assertEquals(join(new URL("file:///C:/foo"), "bar", "baz\\.."), "C:\\foo\\bar");
+* ```
+*
+* @param path The path to join. This can be string or file URL.
+* @param paths The paths to join.
+* @returns The joined path.
+*/ function join(path, ...paths) {
+	if (path instanceof URL) path = require_from_file_url.fromFileUrl(path);
+	paths = path ? [path, ...paths] : paths;
+	paths.forEach((path$1) => require_assert_path.assertPath(path$1));
+	paths = paths.filter((path$1) => path$1.length > 0);
+	if (paths.length === 0) return ".";
+	let needsReplace = true;
+	let slashCount = 0;
+	const firstPart = paths[0];
+	if (require__util.isPathSeparator(firstPart.charCodeAt(0))) {
+		++slashCount;
+		const firstLen = firstPart.length;
+		if (firstLen > 1) {
+			if (require__util.isPathSeparator(firstPart.charCodeAt(1))) {
+				++slashCount;
+				if (firstLen > 2) if (require__util.isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;
+				else needsReplace = false;
+			}
+		}
+	}
+	let joined = paths.join("\\");
+	if (needsReplace) {
+		for (; slashCount < joined.length; ++slashCount) if (!require__util.isPathSeparator(joined.charCodeAt(slashCount))) break;
+		if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`;
+	}
+	return require_normalize.normalize(joined);
+}
+
+//#endregion
+exports.join = join;

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/join.js

@@ -0,0 +1,52 @@
+import { assertPath } from "../_common/assert_path.js";
+import { isPathSeparator } from "./_util.js";
+import { fromFileUrl } from "./from_file_url.js";
+import { normalize } from "./normalize.js";
+
+//#region ../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/join.js
+/**
+* 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";
+*
+* assertEquals(join("C:\\foo", "bar", "baz\\.."), "C:\\foo\\bar");
+* assertEquals(join(new URL("file:///C:/foo"), "bar", "baz\\.."), "C:\\foo\\bar");
+* ```
+*
+* @param path The path to join. This can be string or file URL.
+* @param paths The paths to join.
+* @returns The joined path.
+*/ function join(path, ...paths) {
+	if (path instanceof URL) path = fromFileUrl(path);
+	paths = path ? [path, ...paths] : paths;
+	paths.forEach((path$1) => assertPath(path$1));
+	paths = paths.filter((path$1) => path$1.length > 0);
+	if (paths.length === 0) return ".";
+	let needsReplace = true;
+	let slashCount = 0;
+	const firstPart = paths[0];
+	if (isPathSeparator(firstPart.charCodeAt(0))) {
+		++slashCount;
+		const firstLen = firstPart.length;
+		if (firstLen > 1) {
+			if (isPathSeparator(firstPart.charCodeAt(1))) {
+				++slashCount;
+				if (firstLen > 2) if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;
+				else needsReplace = false;
+			}
+		}
+	}
+	let joined = paths.join("\\");
+	if (needsReplace) {
+		for (; slashCount < joined.length; ++slashCount) if (!isPathSeparator(joined.charCodeAt(slashCount))) break;
+		if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`;
+	}
+	return normalize(joined);
+}
+
+//#endregion
+export { join };
+//# sourceMappingURL=join.js.map

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/join.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.js","names":["path"],"sources":["../../../../../../../../../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/join.js"],"sourcesContent":["// Copyright 2018-2025 the Deno authors. MIT license.\n// This module is browser compatible.\nimport { assertPath } from \"../_common/assert_path.js\";\nimport { isPathSeparator } from \"./_util.js\";\nimport { normalize } from \"./normalize.js\";\nimport { fromFileUrl } from \"./from_file_url.js\";\n/**\n * Join all given a sequence of `paths`,then normalizes the resulting path.\n *\n * @example Usage\n * ```ts\n * import { join } from \"@std/path/windows/join\";\n * import { assertEquals } from \"@std/assert\";\n *\n * assertEquals(join(\"C:\\\\foo\", \"bar\", \"baz\\\\..\"), \"C:\\\\foo\\\\bar\");\n * assertEquals(join(new URL(\"file:///C:/foo\"), \"bar\", \"baz\\\\..\"), \"C:\\\\foo\\\\bar\");\n * ```\n *\n * @param path The path to join. This can be string or file URL.\n * @param paths The paths to join.\n * @returns The joined path.\n */ export function join(path, ...paths) {\n  if (path instanceof URL) {\n    path = fromFileUrl(path);\n  }\n  paths = path ? [\n    path,\n    ...paths\n  ] : paths;\n  paths.forEach((path)=>assertPath(path));\n  paths = paths.filter((path)=>path.length > 0);\n  if (paths.length === 0) return \".\";\n  // Make sure that the joined path doesn't start with two slashes, because\n  // normalize() will mistake it for an UNC path then.\n  //\n  // This step is skipped when it is very clear that the user actually\n  // intended to point at an UNC path. This is assumed when the first\n  // non-empty string arguments starts with exactly two slashes followed by\n  // at least one more non-slash character.\n  //\n  // Note that for normalize() to treat a path as an UNC path it needs to\n  // have at least 2 components, so we don't filter for that here.\n  // This means that the user can use join to construct UNC paths from\n  // a server name and a share name; for example:\n  //   path.join('//server', 'share') -> '\\\\\\\\server\\\\share\\\\'\n  let needsReplace = true;\n  let slashCount = 0;\n  const firstPart = paths[0];\n  if (isPathSeparator(firstPart.charCodeAt(0))) {\n    ++slashCount;\n    const firstLen = firstPart.length;\n    if (firstLen > 1) {\n      if (isPathSeparator(firstPart.charCodeAt(1))) {\n        ++slashCount;\n        if (firstLen > 2) {\n          if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;\n          else {\n            // We matched a UNC path in the first part\n            needsReplace = false;\n          }\n        }\n      }\n    }\n  }\n  let joined = paths.join(\"\\\\\");\n  if (needsReplace) {\n    // Find any more consecutive slashes we need to replace\n    for(; slashCount < joined.length; ++slashCount){\n      if (!isPathSeparator(joined.charCodeAt(slashCount))) break;\n    }\n    // Replace the slashes if needed\n    if (slashCount >= 2) joined = `\\\\${joined.slice(slashCount)}`;\n  }\n  return normalize(joined);\n}\n//# sourceMappingURL=join.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;GAqBI,SAAgB,KAAK,MAAM,GAAG,OAAO;AACvC,KAAI,gBAAgB,IAClB,QAAO,YAAY,KAAK;AAE1B,SAAQ,OAAO,CACb,MACA,GAAG,KACJ,IAAG;AACJ,OAAM,QAAQ,CAACA,WAAO,WAAWA,OAAK,CAAC;AACvC,SAAQ,MAAM,OAAO,CAACA,WAAOA,OAAK,SAAS,EAAE;AAC7C,KAAI,MAAM,WAAW,EAAG,QAAO;CAc/B,IAAI,eAAe;CACnB,IAAI,aAAa;CACjB,MAAM,YAAY,MAAM;AACxB,KAAI,gBAAgB,UAAU,WAAW,EAAE,CAAC,EAAE;AAC5C,IAAE;EACF,MAAM,WAAW,UAAU;AAC3B,MAAI,WAAW,GACb;OAAI,gBAAgB,UAAU,WAAW,EAAE,CAAC,EAAE;AAC5C,MAAE;AACF,QAAI,WAAW,EACb,KAAI,gBAAgB,UAAU,WAAW,EAAE,CAAC,CAAE,GAAE;QAG9C,gBAAe;GAGpB;;CAEJ;CACD,IAAI,SAAS,MAAM,KAAK,KAAK;AAC7B,KAAI,cAAc;AAEhB,SAAM,aAAa,OAAO,QAAQ,EAAE,WAClC,MAAK,gBAAgB,OAAO,WAAW,WAAW,CAAC,CAAE;AAGvD,MAAI,cAAc,EAAG,WAAU,IAAI,OAAO,MAAM,WAAW,CAAC;CAC7D;AACD,QAAO,UAAU,OAAO;AACzB"}

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/normalize.cjs

@@ -0,0 +1,82 @@
+const require_normalize = require('../_common/normalize.cjs');
+const require_constants = require('../_common/constants.cjs');
+const require_normalize_string = require('../_common/normalize_string.cjs');
+const require__util = require('./_util.cjs');
+const require_from_file_url = require('./from_file_url.cjs');
+
+//#region ../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/normalize.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 `'.'`.
+*
+* @example Usage
+* ```ts
+* import { normalize } from "@std/path/windows/normalize";
+* import { assertEquals } from "@std/assert";
+*
+* assertEquals(normalize("C:\\foo\\..\\bar"), "C:\\bar");
+* assertEquals(normalize(new URL("file:///C:/foo/../bar")), "C:\\bar");
+* ```
+*
+* @param path The path to normalize
+* @returns The normalized path
+*/ function normalize(path) {
+	if (path instanceof URL) path = require_from_file_url.fromFileUrl(path);
+	require_normalize.assertArg(path);
+	const len = path.length;
+	let rootEnd = 0;
+	let device;
+	let isAbsolute = false;
+	const code = path.charCodeAt(0);
+	if (len > 1) {
+		if (require__util.isPathSeparator(code)) {
+			isAbsolute = true;
+			if (require__util.isPathSeparator(path.charCodeAt(1))) {
+				let j = 2;
+				let last = j;
+				for (; j < len; ++j) if (require__util.isPathSeparator(path.charCodeAt(j))) break;
+				if (j < len && j !== last) {
+					const firstPart = path.slice(last, j);
+					last = j;
+					for (; j < len; ++j) if (!require__util.isPathSeparator(path.charCodeAt(j))) break;
+					if (j < len && j !== last) {
+						last = j;
+						for (; j < len; ++j) if (require__util.isPathSeparator(path.charCodeAt(j))) break;
+						if (j === len) return `\\\\${firstPart}\\${path.slice(last)}\\`;
+						else if (j !== last) {
+							device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+							rootEnd = j;
+						}
+					}
+				}
+			} else rootEnd = 1;
+		} else if (require__util.isWindowsDeviceRoot(code)) {
+			if (path.charCodeAt(1) === require_constants.CHAR_COLON) {
+				device = path.slice(0, 2);
+				rootEnd = 2;
+				if (len > 2) {
+					if (require__util.isPathSeparator(path.charCodeAt(2))) {
+						isAbsolute = true;
+						rootEnd = 3;
+					}
+				}
+			}
+		}
+	} else if (require__util.isPathSeparator(code)) return "\\";
+	let tail;
+	if (rootEnd < len) tail = require_normalize_string.normalizeString(path.slice(rootEnd), !isAbsolute, "\\", require__util.isPathSeparator);
+	else tail = "";
+	if (tail.length === 0 && !isAbsolute) tail = ".";
+	if (tail.length > 0 && require__util.isPathSeparator(path.charCodeAt(len - 1))) tail += "\\";
+	if (device === void 0) {
+		if (isAbsolute) if (tail.length > 0) return `\\${tail}`;
+		else return "\\";
+		return tail;
+	} else if (isAbsolute) if (tail.length > 0) return `${device}\\${tail}`;
+	else return `${device}\\`;
+	return device + tail;
+}
+
+//#endregion
+exports.normalize = normalize;

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/normalize.js

@@ -0,0 +1,83 @@
+import { assertArg } from "../_common/normalize.js";
+import { CHAR_COLON } from "../_common/constants.js";
+import { normalizeString } from "../_common/normalize_string.js";
+import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
+import { fromFileUrl } from "./from_file_url.js";
+
+//#region ../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/normalize.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 `'.'`.
+*
+* @example Usage
+* ```ts
+* import { normalize } from "@std/path/windows/normalize";
+* import { assertEquals } from "@std/assert";
+*
+* assertEquals(normalize("C:\\foo\\..\\bar"), "C:\\bar");
+* assertEquals(normalize(new URL("file:///C:/foo/../bar")), "C:\\bar");
+* ```
+*
+* @param path The path to normalize
+* @returns The normalized path
+*/ function normalize(path) {
+	if (path instanceof URL) path = fromFileUrl(path);
+	assertArg(path);
+	const len = path.length;
+	let rootEnd = 0;
+	let device;
+	let isAbsolute = false;
+	const code = path.charCodeAt(0);
+	if (len > 1) {
+		if (isPathSeparator(code)) {
+			isAbsolute = true;
+			if (isPathSeparator(path.charCodeAt(1))) {
+				let j = 2;
+				let last = j;
+				for (; j < len; ++j) if (isPathSeparator(path.charCodeAt(j))) break;
+				if (j < len && j !== last) {
+					const firstPart = path.slice(last, j);
+					last = j;
+					for (; j < len; ++j) if (!isPathSeparator(path.charCodeAt(j))) break;
+					if (j < len && j !== last) {
+						last = j;
+						for (; j < len; ++j) if (isPathSeparator(path.charCodeAt(j))) break;
+						if (j === len) return `\\\\${firstPart}\\${path.slice(last)}\\`;
+						else if (j !== last) {
+							device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+							rootEnd = j;
+						}
+					}
+				}
+			} else rootEnd = 1;
+		} else if (isWindowsDeviceRoot(code)) {
+			if (path.charCodeAt(1) === CHAR_COLON) {
+				device = path.slice(0, 2);
+				rootEnd = 2;
+				if (len > 2) {
+					if (isPathSeparator(path.charCodeAt(2))) {
+						isAbsolute = true;
+						rootEnd = 3;
+					}
+				}
+			}
+		}
+	} else if (isPathSeparator(code)) return "\\";
+	let tail;
+	if (rootEnd < len) tail = normalizeString(path.slice(rootEnd), !isAbsolute, "\\", isPathSeparator);
+	else tail = "";
+	if (tail.length === 0 && !isAbsolute) tail = ".";
+	if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) tail += "\\";
+	if (device === void 0) {
+		if (isAbsolute) if (tail.length > 0) return `\\${tail}`;
+		else return "\\";
+		return tail;
+	} else if (isAbsolute) if (tail.length > 0) return `${device}\\${tail}`;
+	else return `${device}\\`;
+	return device + tail;
+}
+
+//#endregion
+export { normalize };
+//# sourceMappingURL=normalize.js.map

package/dist/node_modules/.pnpm/@jsr_std__path@1.1.0/node_modules/@jsr/std__path/windows/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@jsr+std__path@1.1.0/node_modules/@jsr/std__path/windows/normalize.js"],"sourcesContent":["// Copyright 2018-2025 the Deno authors. MIT license.\n// This module is browser compatible.\nimport { assertArg } from \"../_common/normalize.js\";\nimport { CHAR_COLON } from \"../_common/constants.js\";\nimport { normalizeString } from \"../_common/normalize_string.js\";\nimport { isPathSeparator, isWindowsDeviceRoot } from \"./_util.js\";\nimport { fromFileUrl } from \"./from_file_url.js\";\n/**\n * Normalize the `path`, resolving `'..'` and `'.'` segments.\n * Note that resolving these segments does not necessarily mean that all will be eliminated.\n * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.\n *\n * @example Usage\n * ```ts\n * import { normalize } from \"@std/path/windows/normalize\";\n * import { assertEquals } from \"@std/assert\";\n *\n * assertEquals(normalize(\"C:\\\\foo\\\\..\\\\bar\"), \"C:\\\\bar\");\n * assertEquals(normalize(new URL(\"file:///C:/foo/../bar\")), \"C:\\\\bar\");\n * ```\n *\n * @param path The path to normalize\n * @returns The normalized path\n */ export function normalize(path) {\n  if (path instanceof URL) {\n    path = fromFileUrl(path);\n  }\n  assertArg(path);\n  const len = path.length;\n  let rootEnd = 0;\n  let device;\n  let isAbsolute = false;\n  const code = path.charCodeAt(0);\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n      // If we started with a separator, we know we at least have an absolute\n      // path of some kind (UNC or otherwise)\n      isAbsolute = true;\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for(; j < len; ++j){\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          const firstPart = path.slice(last, j);\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for(; j < len; ++j){\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for(; j < len; ++j){\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              // Return the normalized version of the UNC root since there\n              // is nothing left to process\n              return `\\\\\\\\${firstPart}\\\\${path.slice(last)}\\\\`;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n              device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n              rootEnd = j;\n            }\n          }\n        }\n      } else {\n        rootEnd = 1;\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        device = path.slice(0, 2);\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            // Treat separator following drive name as an absolute path\n            // indicator\n            isAbsolute = true;\n            rootEnd = 3;\n          }\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid unnecessary\n    // work\n    return \"\\\\\";\n  }\n  let tail;\n  if (rootEnd < len) {\n    tail = normalizeString(path.slice(rootEnd), !isAbsolute, \"\\\\\", isPathSeparator);\n  } else {\n    tail = \"\";\n  }\n  if (tail.length === 0 && !isAbsolute) tail = \".\";\n  if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {\n    tail += \"\\\\\";\n  }\n  if (device === undefined) {\n    if (isAbsolute) {\n      if (tail.length > 0) return `\\\\${tail}`;\n      else return \"\\\\\";\n    }\n    return tail;\n  } else if (isAbsolute) {\n    if (tail.length > 0) return `${device}\\\\${tail}`;\n    else return `${device}\\\\`;\n  }\n  return device + tail;\n}\n//# sourceMappingURL=normalize.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;GAuBI,SAAgB,UAAU,MAAM;AAClC,KAAI,gBAAgB,IAClB,QAAO,YAAY,KAAK;AAE1B,WAAU,KAAK;CACf,MAAM,MAAM,KAAK;CACjB,IAAI,UAAU;CACd,IAAI;CACJ,IAAI,aAAa;CACjB,MAAM,OAAO,KAAK,WAAW,EAAE;AAE/B,KAAI,MAAM,GACR;MAAI,gBAAgB,KAAK,EAAE;AAIzB,gBAAa;AACb,OAAI,gBAAgB,KAAK,WAAW,EAAE,CAAC,EAAE;IAEvC,IAAI,IAAI;IACR,IAAI,OAAO;AAEX,WAAM,IAAI,KAAK,EAAE,EACf,KAAI,gBAAgB,KAAK,WAAW,EAAE,CAAC,CAAE;AAE3C,QAAI,IAAI,OAAO,MAAM,MAAM;KACzB,MAAM,YAAY,KAAK,MAAM,MAAM,EAAE;AAErC,YAAO;AAEP,YAAM,IAAI,KAAK,EAAE,EACf,MAAK,gBAAgB,KAAK,WAAW,EAAE,CAAC,CAAE;AAE5C,SAAI,IAAI,OAAO,MAAM,MAAM;AAEzB,aAAO;AAEP,aAAM,IAAI,KAAK,EAAE,EACf,KAAI,gBAAgB,KAAK,WAAW,EAAE,CAAC,CAAE;AAE3C,UAAI,MAAM,IAIR,SAAQ,MAAM,UAAU,IAAI,KAAK,MAAM,KAAK,CAAC;eACpC,MAAM,MAAM;AAErB,iBAAU,MAAM,UAAU,IAAI,KAAK,MAAM,MAAM,EAAE,CAAC;AAClD,iBAAU;MACX;KACF;IACF;GACF,MACC,WAAU;EAEb,WAAU,oBAAoB,KAAK,EAElC;OAAI,KAAK,WAAW,EAAE,KAAK,YAAY;AACrC,aAAS,KAAK,MAAM,GAAG,EAAE;AACzB,cAAU;AACV,QAAI,MAAM,GACR;SAAI,gBAAgB,KAAK,WAAW,EAAE,CAAC,EAAE;AAGvC,mBAAa;AACb,gBAAU;KACX;;GAEJ;;CACF,WACQ,gBAAgB,KAAK,CAG9B,QAAO;CAET,IAAI;AACJ,KAAI,UAAU,IACZ,QAAO,gBAAgB,KAAK,MAAM,QAAQ,GAAG,YAAY,MAAM,gBAAgB;KAE/E,QAAO;AAET,KAAI,KAAK,WAAW,MAAM,WAAY,QAAO;AAC7C,KAAI,KAAK,SAAS,KAAK,gBAAgB,KAAK,WAAW,MAAM,EAAE,CAAC,CAC9D,SAAQ;AAEV,KAAI,mBAAsB;AACxB,MAAI,WACF,KAAI,KAAK,SAAS,EAAG,SAAQ,IAAI,KAAK;MACjC,QAAO;AAEd,SAAO;CACR,WAAU,WACT,KAAI,KAAK,SAAS,EAAG,SAAQ,EAAE,OAAO,IAAI,KAAK;KAC1C,SAAQ,EAAE,OAAO;AAExB,QAAO,SAAS;AACjB"}

package/dist/timefilesink.cjs

@@ -0,0 +1,208 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/timefilesink.ts
+/**
+* Get the ISO week number of a date.
+* @param date The date to get the week number of.
+* @returns The ISO week number (1-53).
+*/
+function getISOWeek(date) {
+	const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+	const dayNum = d.getUTCDay() || 7;
+	d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+	const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+	return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+}
+/**
+* Get the ISO week year of a date.  This may differ from the calendar year
+* for dates near the start or end of a year.
+* @param date The date to get the ISO week year of.
+* @returns The ISO week year.
+*/
+function getISOWeekYear(date) {
+	const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+	const dayNum = d.getUTCDay() || 7;
+	d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+	return d.getUTCFullYear();
+}
+/**
+* Get the default filename generator for the given interval.
+* @param interval The rotation interval.
+* @returns A function that generates a filename for a given date.
+*/
+function getDefaultFilename(interval) {
+	switch (interval) {
+		case "hourly": return (date) => {
+			const yyyy = date.getFullYear();
+			const mm = String(date.getMonth() + 1).padStart(2, "0");
+			const dd = String(date.getDate()).padStart(2, "0");
+			const hh = String(date.getHours()).padStart(2, "0");
+			return `${yyyy}-${mm}-${dd}-${hh}.log`;
+		};
+		case "daily": return (date) => {
+			const yyyy = date.getFullYear();
+			const mm = String(date.getMonth() + 1).padStart(2, "0");
+			const dd = String(date.getDate()).padStart(2, "0");
+			return `${yyyy}-${mm}-${dd}.log`;
+		};
+		case "weekly": return (date) => {
+			const yyyy = getISOWeekYear(date);
+			const week = getISOWeek(date);
+			return `${yyyy}-W${String(week).padStart(2, "0")}.log`;
+		};
+	}
+}
+/**
+* Get the rotation key for the given date and interval.
+* The key is used to determine when to rotate to a new file.
+* @param date The date to get the rotation key of.
+* @param interval The rotation interval.
+* @returns A string key that changes when rotation should occur.
+*/
+function getRotationKey(date, interval) {
+	switch (interval) {
+		case "hourly": return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}-${date.getHours()}`;
+		case "daily": return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;
+		case "weekly": return `${getISOWeekYear(date)}-${getISOWeek(date)}`;
+	}
+}
+function getBaseTimeRotatingFileSink(options) {
+	const formatter = options.formatter ?? __logtape_logtape.defaultTextFormatter;
+	const encoder = options.encoder ?? new TextEncoder();
+	const interval = options.interval ?? "daily";
+	const filenameGenerator = options.filename ?? getDefaultFilename(interval);
+	const maxAgeMs = options.maxAgeMs;
+	const bufferSize = options.bufferSize ?? 1024 * 8;
+	const flushInterval = options.flushInterval ?? 5e3;
+	const directory = options.directory;
+	try {
+		options.mkdirSync(directory, { recursive: true });
+	} catch {}
+	let currentFilename = filenameGenerator(/* @__PURE__ */ new Date());
+	let currentPath = options.joinPath(directory, currentFilename);
+	let currentRotationKey = getRotationKey(/* @__PURE__ */ new Date(), interval);
+	let fd = options.openSync(currentPath);
+	let lastFlushTimestamp = Date.now();
+	let buffer = "";
+	function shouldRotate() {
+		const now = /* @__PURE__ */ new Date();
+		const newKey = getRotationKey(now, interval);
+		return newKey !== currentRotationKey;
+	}
+	function performRotation() {
+		options.closeSync(fd);
+		const now = /* @__PURE__ */ new Date();
+		currentFilename = filenameGenerator(now);
+		currentPath = options.joinPath(directory, currentFilename);
+		currentRotationKey = getRotationKey(now, interval);
+		fd = options.openSync(currentPath);
+	}
+	function cleanupOldFiles() {
+		if (maxAgeMs === void 0) return;
+		const now = Date.now();
+		let files;
+		try {
+			files = options.readdirSync(directory);
+		} catch {
+			return;
+		}
+		for (const file of files) {
+			if (!file.endsWith(".log")) continue;
+			if (file === currentFilename) continue;
+			const filePath = options.joinPath(directory, file);
+			const dateMatch = file.match(/^(\d{4})-(\d{2})-(\d{2})(?:-(\d{2}))?\.log$/);
+			const weekMatch = file.match(/^(\d{4})-W(\d{2})\.log$/);
+			let fileDate = null;
+			if (dateMatch) {
+				const [, year, month, day, hour] = dateMatch;
+				fileDate = new Date(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10), hour ? parseInt(hour, 10) : 0);
+			} else if (weekMatch) {
+				const [, year, week] = weekMatch;
+				const jan4 = new Date(parseInt(year, 10), 0, 4);
+				const dayOfWeek = jan4.getDay() || 7;
+				fileDate = new Date(jan4);
+				fileDate.setDate(jan4.getDate() - dayOfWeek + 1 + (parseInt(week, 10) - 1) * 7);
+			}
+			if (fileDate && now - fileDate.getTime() > maxAgeMs) try {
+				options.unlinkSync(filePath);
+			} catch {}
+		}
+	}
+	if (!options.nonBlocking) {
+		function flushBuffer$1() {
+			if (buffer.length > 0) {
+				if (shouldRotate()) performRotation();
+				const bytes = encoder.encode(buffer);
+				buffer = "";
+				options.writeSync(fd, bytes);
+				options.flushSync(fd);
+				lastFlushTimestamp = Date.now();
+				cleanupOldFiles();
+			}
+		}
+		const sink = (record) => {
+			buffer += formatter(record);
+			const shouldFlushBySize = buffer.length >= bufferSize;
+			const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
+			if (shouldFlushBySize || shouldFlushByTime) flushBuffer$1();
+		};
+		sink[Symbol.dispose] = () => {
+			flushBuffer$1();
+			options.closeSync(fd);
+		};
+		return sink;
+	}
+	const asyncOptions = options;
+	let disposed = false;
+	let activeFlush = null;
+	let flushTimer = null;
+	async function flushBuffer() {
+		if (buffer.length === 0) return;
+		if (shouldRotate()) performRotation();
+		const data = buffer;
+		buffer = "";
+		try {
+			const bytes = encoder.encode(data);
+			asyncOptions.writeSync(fd, bytes);
+			await asyncOptions.flush(fd);
+			lastFlushTimestamp = Date.now();
+			cleanupOldFiles();
+		} catch {}
+	}
+	function scheduleFlush() {
+		if (activeFlush || disposed) return;
+		activeFlush = flushBuffer().finally(() => {
+			activeFlush = null;
+		});
+	}
+	function startFlushTimer() {
+		if (flushTimer !== null || disposed) return;
+		flushTimer = setInterval(() => {
+			scheduleFlush();
+		}, flushInterval);
+	}
+	const nonBlockingSink = (record) => {
+		if (disposed) return;
+		buffer += formatter(record);
+		const shouldFlushBySize = buffer.length >= bufferSize;
+		const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
+		if (shouldFlushBySize || shouldFlushByTime) scheduleFlush();
+		else if (flushTimer === null && flushInterval > 0) startFlushTimer();
+	};
+	nonBlockingSink[Symbol.asyncDispose] = async () => {
+		disposed = true;
+		if (flushTimer !== null) {
+			clearInterval(flushTimer);
+			flushTimer = null;
+		}
+		await flushBuffer();
+		try {
+			await asyncOptions.close(fd);
+		} catch {}
+	};
+	return nonBlockingSink;
+}
+
+//#endregion
+exports.getBaseTimeRotatingFileSink = getBaseTimeRotatingFileSink;