@cloudcome/utils-core 1.19.1 → 1.20.0

package/dist/path.cjs

@@ -1,76 +1,164 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const array = require("./array.cjs");
+const require_array = require("./array.cjs");
+//#region src/path.ts
+/**
+* 判断是否是当前目录标记
+* @param {string} slice - 路径片段
+* @returns {boolean} - 如果是当前目录标记'.'则返回true，否则返回false
+*/
 function _isCurrentSlice(slice) {
-  return slice === ".";
+	return slice === ".";
 }
+/**
+* 判断是否是上级目录标记
+* @param {string} slice - 路径片段
+* @returns {boolean} - 如果是上级目录标记'..'则返回true，否则返回false
+*/
 function _isParentSlice(slice) {
-  return slice === "..";
+	return slice === "..";
 }
+/**
+* 判断是否是绝对路径
+* @param {string} path - 路径字符串
+* @returns {boolean} - 如果是绝对路径则返回true，否则返回false
+* @example
+* ```typescript
+* const isAbs = isAbsolutePath('/path/to/file');
+* console.log(isAbs); // 输出: true
+* ```
+*/
 function isAbsolutePath(path) {
-  return path.startsWith("/");
+	return path.startsWith("/");
 }
+/**
+* 判断是否是相对路径
+* @param {string} path - 路径字符串
+* @returns {boolean} - 如果是相对路径则返回true，否则返回false
+* @example
+* ```typescript
+* const isRel = isRelativePath('path/to/file');
+* console.log(isRel); // 输出: true
+* ```
+*/
 function isRelativePath(path) {
-  return !isAbsolutePath(path);
+	return !isAbsolutePath(path);
 }
+/**
+* 标准化路径
+* @param {string} path - 要标准化的路径字符串。
+* @returns {string} - 标准化后的路径字符串。
+* @example
+* ```typescript
+* const normalizedPath = pathNormalize('/path///to///file');
+* console.log(normalizedPath); // 输出: '/path/to/file'
+* ```
+*/
 function pathNormalize(path) {
-  const slices = path.replace(/\\/g, "/").replace(/\/{2,}/g, "/").replace(/\.{3,}/g, "..").replace(/\/\.\//g, "/").split("/").map((point) => point.trim());
-  const points = [];
-  const isAbs = slices[0] === "";
-  const push = (point) => {
-    points.push(point);
-  };
-  const back = () => {
-    if (points.length === 1 && isAbs) return;
-    if (points.length === 0 || points.at(-1) === "..") {
-      points.push("..");
-    } else {
-      points.pop();
-    }
-  };
-  for (const slice of slices) {
-    const isCurrent = _isCurrentSlice(slice);
-    const isParent = _isParentSlice(slice);
-    if (isCurrent) {
-      continue;
-    }
-    if (isParent) {
-      back();
-      continue;
-    }
-    push(slice);
-  }
-  return points.join("/") || (isAbs ? "/" : ".");
+	const slices = path.replace(/\\/g, "/").replace(/\/{2,}/g, "/").replace(/\.{3,}/g, "..").replace(/\/\.\//g, "/").split("/").map((point) => point.trim());
+	const points = [];
+	const isAbs = slices[0] === "";
+	const push = (point) => {
+		points.push(point);
+	};
+	const back = () => {
+		if (points.length === 1 && isAbs) return;
+		if (points.length === 0 || points.at(-1) === "..") points.push("..");
+		else points.pop();
+	};
+	for (const slice of slices) {
+		const isCurrent = _isCurrentSlice(slice);
+		const isParent = _isParentSlice(slice);
+		if (isCurrent) continue;
+		if (isParent) {
+			back();
+			continue;
+		}
+		push(slice);
+	}
+	return points.join("/") || (isAbs ? "/" : ".");
 }
+/**
+* 路径合并
+* @param {string} from - 起始路径。
+* @param {...string[]} to - 要合并的路径片段。
+* @returns {string} - 合并后的路径字符串。
+* @example
+* ```typescript
+* const fullPath = pathJoin('/path', '/to', 'file');
+* console.log(fullPath); // 输出: '/path/to/file'
+* ```
+*/
 function pathJoin(from, ...to) {
-  return pathNormalize([from, ...to].join("/"));
+	return pathNormalize([from, ...to].join("/"));
 }
+/**
+* 解析路径
+* @param {string} from - 起始路径
+* @param {...string[]} to - 要解析的路径片段
+* @returns {string} - 解析后的绝对路径
+* @example
+* ```typescript
+* const resolvedPath = pathResolve('/path', '/to', 'file');
+* console.log(resolvedPath); // 输出: '/to/file'
+* ```
+*/
 function pathResolve(from, ...to) {
-  const paths = [from, ...to].map(pathNormalize);
-  let lastStartPath = from;
-  let lastStartIndex = 0;
-  array.arrayEach(
-    paths,
-    (path, index) => {
-      if (isAbsolutePath(path)) {
-        lastStartPath = path;
-        lastStartIndex = index;
-        return false;
-      }
-    },
-    true
-  );
-  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));
+	const paths = [from, ...to].map(pathNormalize);
+	let lastStartPath = from;
+	let lastStartIndex = 0;
+	require_array.arrayEach(paths, (path, index) => {
+		if (isAbsolutePath(path)) {
+			lastStartPath = path;
+			lastStartIndex = index;
+			return false;
+		}
+	}, true);
+	return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));
 }
+/**
+* 将相对路径转换为标准的相对路径格式(添加'./'前缀)
+*
+* @param {string} path - 要处理的路径字符串
+* @returns {string} 处理后的路径字符串
+*
+* @example <caption>处理绝对路径</caption>
+* ```typescript
+* const result = pathRelativize('/path/to/file');
+* console.log(result); // 输出: '/path/to/file'
+* ```
+*
+* @example <caption>处理已带'./'前缀的相对路径</caption>
+* ```typescript
+* const result = pathRelativize('./path/to/file');
+* console.log(result); // 输出: './path/to/file'
+* ```
+*
+* @example <caption>处理不带'./'前缀的相对路径</caption>
+* ```typescript
+* const result = pathRelativize('path/to/file');
+* console.log(result); // 输出: './path/to/file'
+* ```
+*/
 function pathRelativize(path) {
-  if (isAbsolutePath(path)) return path;
-  if (path.startsWith("./")) return path;
-  if (path.startsWith("../")) return path;
-  return `./${path}`;
+	if (isAbsolutePath(path)) return path;
+	if (path.startsWith("./")) return path;
+	if (path.startsWith("../")) return path;
+	return `./${path}`;
 }
+/**
+* 获取路径的目录部分
+* @param {string} path - 输入的路径字符串
+* @returns {string} - 返回路径的目录部分
+* @example
+* ```typescript
+* const dir = pathDirname('/path/to/file.txt');
+* console.log(dir); // 输出: '/path/to'
+* ```
+*/
 function pathDirname(path) {
-  return pathJoin(path, "..");
+	return pathJoin(path, "..");
 }
+//#endregion
 exports.isAbsolutePath = isAbsolutePath;
 exports.isRelativePath = isRelativePath;
 exports.pathDirname = pathDirname;
@@ -78,4 +166,5 @@ exports.pathJoin = pathJoin;
 exports.pathNormalize = pathNormalize;
 exports.pathRelativize = pathRelativize;
 exports.pathResolve = pathResolve;
-//# sourceMappingURL=path.cjs.map
+
+//# sourceMappingURL=path.cjs.map

package/dist/path.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"path.cjs","sources":["../src/path.ts"],"sourcesContent":["import { arrayEach } from './array';\n\n/**\n * 判断是否是当前目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是当前目录标记'.'则返回true，否则返回false\n */\nfunction _isCurrentSlice(slice: string): boolean {\n  return slice === '.';\n}\n\n/**\n * 判断是否是上级目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是上级目录标记'..'则返回true，否则返回false\n */\nfunction _isParentSlice(slice: string): boolean {\n  return slice === '..';\n}\n\n/**\n * 判断是否是绝对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是绝对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isAbs = isAbsolutePath('/path/to/file');\n * console.log(isAbs); // 输出: true\n * ```\n */\nexport function isAbsolutePath(path: string): boolean {\n  return path.startsWith('/');\n}\n\n/**\n * 判断是否是相对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是相对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isRel = isRelativePath('path/to/file');\n * console.log(isRel); // 输出: true\n * ```\n */\nexport function isRelativePath(path: string): boolean {\n  return !isAbsolutePath(path);\n}\n\n/**\n * 标准化路径\n * @param {string} path - 要标准化的路径字符串。\n * @returns {string} - 标准化后的路径字符串。\n * @example\n * ```typescript\n * const normalizedPath = pathNormalize('/path///to///file');\n * console.log(normalizedPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathNormalize(path: string): string {\n  const slices = path\n    .replace(/\\\\/g, '/')\n    .replace(/\\/{2,}/g, '/')\n    .replace(/\\.{3,}/g, '..')\n    .replace(/\\/\\.\\//g, '/')\n    .split('/')\n    .map((point) => point.trim());\n  const points: string[] = [];\n  const isAbs = slices[0] === '';\n\n  const push = (point: string) => {\n    points.push(point);\n  };\n\n  const back = () => {\n    // 绝对路径不能退到根目录\n    if (points.length === 1 && isAbs) return;\n\n    //\n    if (points.length === 0 || points.at(-1) === '..') {\n      points.push('..');\n    } else {\n      points.pop();\n    }\n  };\n\n  for (const slice of slices) {\n    const isCurrent = _isCurrentSlice(slice);\n    const isParent = _isParentSlice(slice);\n\n    // // 未进入实际路径\n    // if (!inPoints) {\n    //   push(slice);\n    //   inPoints = !isCurrent && !isParent;\n    //   continue;\n    // }\n\n    if (isCurrent) {\n      continue;\n    }\n\n    if (isParent) {\n      back();\n      continue;\n    }\n\n    push(slice);\n  }\n\n  return points.join('/') || (isAbs ? '/' : '.');\n}\n\n/**\n * 路径合并\n * @param {string} from - 起始路径。\n * @param {...string[]} to - 要合并的路径片段。\n * @returns {string} - 合并后的路径字符串。\n * @example\n * ```typescript\n * const fullPath = pathJoin('/path', '/to', 'file');\n * console.log(fullPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathJoin(from: string, ...to: string[]): string {\n  return pathNormalize([from, ...to].join('/'));\n}\n\n/**\n * 解析路径\n * @param {string} from - 起始路径\n * @param {...string[]} to - 要解析的路径片段\n * @returns {string} - 解析后的绝对路径\n * @example\n * ```typescript\n * const resolvedPath = pathResolve('/path', '/to', 'file');\n * console.log(resolvedPath); // 输出: '/to/file'\n * ```\n */\nexport function pathResolve(from: string, ...to: string[]): string {\n  const paths = [from, ...to].map(pathNormalize);\n\n  let lastStartPath = from;\n  let lastStartIndex = 0;\n\n  arrayEach(\n    paths,\n    (path, index) => {\n      if (isAbsolutePath(path)) {\n        lastStartPath = path;\n        lastStartIndex = index;\n        return false;\n      }\n    },\n    true,\n  );\n\n  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));\n}\n\n/**\n * 将相对路径转换为标准的相对路径格式(添加'./'前缀)\n *\n * @param {string} path - 要处理的路径字符串\n * @returns {string} 处理后的路径字符串\n *\n * @example <caption>处理绝对路径</caption>\n * ```typescript\n * const result = pathRelativize('/path/to/file');\n * console.log(result); // 输出: '/path/to/file'\n * ```\n *\n * @example <caption>处理已带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('./path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n *\n * @example <caption>处理不带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n */\nexport function pathRelativize(path: string): string {\n  if (isAbsolutePath(path)) return path;\n  if (path.startsWith('./')) return path;\n  if (path.startsWith('../')) return path;\n  return `./${path}`;\n}\n\n/**\n * 获取路径的目录部分\n * @param {string} path - 输入的路径字符串\n * @returns {string} - 返回路径的目录部分\n * @example\n * ```typescript\n * const dir = pathDirname('/path/to/file.txt');\n * console.log(dir); // 输出: '/path/to'\n * ```\n */\nexport function pathDirname(path: string): string {\n  return pathJoin(path, '..');\n}\n"],"names":["arrayEach"],"mappings":";;;AAOA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,UAAU;AACnB;AAOA,SAAS,eAAe,OAAwB;AAC9C,SAAO,UAAU;AACnB;AAYO,SAAS,eAAe,MAAuB;AAC7C,SAAA,KAAK,WAAW,GAAG;AAC5B;AAYO,SAAS,eAAe,MAAuB;AAC7C,SAAA,CAAC,eAAe,IAAI;AAC7B;AAYO,SAAS,cAAc,MAAsB;AAC5C,QAAA,SAAS,KACZ,QAAQ,OAAO,GAAG,EAClB,QAAQ,WAAW,GAAG,EACtB,QAAQ,WAAW,IAAI,EACvB,QAAQ,WAAW,GAAG,EACtB,MAAM,GAAG,EACT,IAAI,CAAC,UAAU,MAAM,KAAA,CAAM;AAC9B,QAAM,SAAmB,CAAC;AACpB,QAAA,QAAQ,OAAO,CAAC,MAAM;AAEtB,QAAA,OAAO,CAAC,UAAkB;AAC9B,WAAO,KAAK,KAAK;AAAA,EACnB;AAEA,QAAM,OAAO,MAAM;AAEb,QAAA,OAAO,WAAW,KAAK,MAAO;AAGlC,QAAI,OAAO,WAAW,KAAK,OAAO,GAAG,EAAE,MAAM,MAAM;AACjD,aAAO,KAAK,IAAI;AAAA,IAAA,OACX;AACL,aAAO,IAAI;AAAA,IAAA;AAAA,EAEf;AAEA,aAAW,SAAS,QAAQ;AACpB,UAAA,YAAY,gBAAgB,KAAK;AACjC,UAAA,WAAW,eAAe,KAAK;AASrC,QAAI,WAAW;AACb;AAAA,IAAA;AAGF,QAAI,UAAU;AACP,WAAA;AACL;AAAA,IAAA;AAGF,SAAK,KAAK;AAAA,EAAA;AAGZ,SAAO,OAAO,KAAK,GAAG,MAAM,QAAQ,MAAM;AAC5C;AAagB,SAAA,SAAS,SAAiB,IAAsB;AACvD,SAAA,cAAc,CAAC,MAAM,GAAG,EAAE,EAAE,KAAK,GAAG,CAAC;AAC9C;AAagB,SAAA,YAAY,SAAiB,IAAsB;AACjE,QAAM,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,IAAI,aAAa;AAE7C,MAAI,gBAAgB;AACpB,MAAI,iBAAiB;AAErBA,QAAA;AAAA,IACE;AAAA,IACA,CAAC,MAAM,UAAU;AACX,UAAA,eAAe,IAAI,GAAG;AACR,wBAAA;AACC,yBAAA;AACV,eAAA;AAAA,MAAA;AAAA,IAEX;AAAA,IACA;AAAA,EACF;AAEA,SAAO,SAAS,eAAe,GAAG,MAAM,MAAM,iBAAiB,CAAC,CAAC;AACnE;AA0BO,SAAS,eAAe,MAAsB;AAC/C,MAAA,eAAe,IAAI,EAAU,QAAA;AACjC,MAAI,KAAK,WAAW,IAAI,EAAU,QAAA;AAClC,MAAI,KAAK,WAAW,KAAK,EAAU,QAAA;AACnC,SAAO,KAAK,IAAI;AAClB;AAYO,SAAS,YAAY,MAAsB;AACzC,SAAA,SAAS,MAAM,IAAI;AAC5B;;;;;;;;"}
+{"version":3,"file":"path.cjs","names":[],"sources":["../src/path.ts"],"sourcesContent":["import { arrayEach } from './array';\n\n/**\n * 判断是否是当前目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是当前目录标记'.'则返回true，否则返回false\n */\nfunction _isCurrentSlice(slice: string): boolean {\n  return slice === '.';\n}\n\n/**\n * 判断是否是上级目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是上级目录标记'..'则返回true，否则返回false\n */\nfunction _isParentSlice(slice: string): boolean {\n  return slice === '..';\n}\n\n/**\n * 判断是否是绝对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是绝对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isAbs = isAbsolutePath('/path/to/file');\n * console.log(isAbs); // 输出: true\n * ```\n */\nexport function isAbsolutePath(path: string): boolean {\n  return path.startsWith('/');\n}\n\n/**\n * 判断是否是相对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是相对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isRel = isRelativePath('path/to/file');\n * console.log(isRel); // 输出: true\n * ```\n */\nexport function isRelativePath(path: string): boolean {\n  return !isAbsolutePath(path);\n}\n\n/**\n * 标准化路径\n * @param {string} path - 要标准化的路径字符串。\n * @returns {string} - 标准化后的路径字符串。\n * @example\n * ```typescript\n * const normalizedPath = pathNormalize('/path///to///file');\n * console.log(normalizedPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathNormalize(path: string): string {\n  const slices = path\n    .replace(/\\\\/g, '/')\n    .replace(/\\/{2,}/g, '/')\n    .replace(/\\.{3,}/g, '..')\n    .replace(/\\/\\.\\//g, '/')\n    .split('/')\n    .map((point) => point.trim());\n  const points: string[] = [];\n  const isAbs = slices[0] === '';\n\n  const push = (point: string) => {\n    points.push(point);\n  };\n\n  const back = () => {\n    // 绝对路径不能退到根目录\n    if (points.length === 1 && isAbs) return;\n\n    //\n    if (points.length === 0 || points.at(-1) === '..') {\n      points.push('..');\n    } else {\n      points.pop();\n    }\n  };\n\n  for (const slice of slices) {\n    const isCurrent = _isCurrentSlice(slice);\n    const isParent = _isParentSlice(slice);\n\n    // // 未进入实际路径\n    // if (!inPoints) {\n    //   push(slice);\n    //   inPoints = !isCurrent && !isParent;\n    //   continue;\n    // }\n\n    if (isCurrent) {\n      continue;\n    }\n\n    if (isParent) {\n      back();\n      continue;\n    }\n\n    push(slice);\n  }\n\n  return points.join('/') || (isAbs ? '/' : '.');\n}\n\n/**\n * 路径合并\n * @param {string} from - 起始路径。\n * @param {...string[]} to - 要合并的路径片段。\n * @returns {string} - 合并后的路径字符串。\n * @example\n * ```typescript\n * const fullPath = pathJoin('/path', '/to', 'file');\n * console.log(fullPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathJoin(from: string, ...to: string[]): string {\n  return pathNormalize([from, ...to].join('/'));\n}\n\n/**\n * 解析路径\n * @param {string} from - 起始路径\n * @param {...string[]} to - 要解析的路径片段\n * @returns {string} - 解析后的绝对路径\n * @example\n * ```typescript\n * const resolvedPath = pathResolve('/path', '/to', 'file');\n * console.log(resolvedPath); // 输出: '/to/file'\n * ```\n */\nexport function pathResolve(from: string, ...to: string[]): string {\n  const paths = [from, ...to].map(pathNormalize);\n\n  let lastStartPath = from;\n  let lastStartIndex = 0;\n\n  arrayEach(\n    paths,\n    (path, index) => {\n      if (isAbsolutePath(path)) {\n        lastStartPath = path;\n        lastStartIndex = index;\n        return false;\n      }\n    },\n    true,\n  );\n\n  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));\n}\n\n/**\n * 将相对路径转换为标准的相对路径格式(添加'./'前缀)\n *\n * @param {string} path - 要处理的路径字符串\n * @returns {string} 处理后的路径字符串\n *\n * @example <caption>处理绝对路径</caption>\n * ```typescript\n * const result = pathRelativize('/path/to/file');\n * console.log(result); // 输出: '/path/to/file'\n * ```\n *\n * @example <caption>处理已带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('./path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n *\n * @example <caption>处理不带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n */\nexport function pathRelativize(path: string): string {\n  if (isAbsolutePath(path)) return path;\n  if (path.startsWith('./')) return path;\n  if (path.startsWith('../')) return path;\n  return `./${path}`;\n}\n\n/**\n * 获取路径的目录部分\n * @param {string} path - 输入的路径字符串\n * @returns {string} - 返回路径的目录部分\n * @example\n * ```typescript\n * const dir = pathDirname('/path/to/file.txt');\n * console.log(dir); // 输出: '/path/to'\n * ```\n */\nexport function pathDirname(path: string): string {\n  return pathJoin(path, '..');\n}\n"],"mappings":";;;;;;;;AAOA,SAAS,gBAAgB,OAAwB;CAC/C,OAAO,UAAU;;;;;;;AAQnB,SAAS,eAAe,OAAwB;CAC9C,OAAO,UAAU;;;;;;;;;;;;AAanB,SAAgB,eAAe,MAAuB;CACpD,OAAO,KAAK,WAAW,IAAI;;;;;;;;;;;;AAa7B,SAAgB,eAAe,MAAuB;CACpD,OAAO,CAAC,eAAe,KAAK;;;;;;;;;;;;AAa9B,SAAgB,cAAc,MAAsB;CAClD,MAAM,SAAS,KACZ,QAAQ,OAAO,IAAI,CACnB,QAAQ,WAAW,IAAI,CACvB,QAAQ,WAAW,KAAK,CACxB,QAAQ,WAAW,IAAI,CACvB,MAAM,IAAI,CACV,KAAK,UAAU,MAAM,MAAM,CAAC;CAC/B,MAAM,SAAmB,EAAE;CAC3B,MAAM,QAAQ,OAAO,OAAO;CAE5B,MAAM,QAAQ,UAAkB;EAC9B,OAAO,KAAK,MAAM;;CAGpB,MAAM,aAAa;EAEjB,IAAI,OAAO,WAAW,KAAK,OAAO;EAGlC,IAAI,OAAO,WAAW,KAAK,OAAO,GAAG,GAAG,KAAK,MAC3C,OAAO,KAAK,KAAK;OAEjB,OAAO,KAAK;;CAIhB,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,YAAY,gBAAgB,MAAM;EACxC,MAAM,WAAW,eAAe,MAAM;EAStC,IAAI,WACF;EAGF,IAAI,UAAU;GACZ,MAAM;GACN;;EAGF,KAAK,MAAM;;CAGb,OAAO,OAAO,KAAK,IAAI,KAAK,QAAQ,MAAM;;;;;;;;;;;;;AAc5C,SAAgB,SAAS,MAAc,GAAG,IAAsB;CAC9D,OAAO,cAAc,CAAC,MAAM,GAAG,GAAG,CAAC,KAAK,IAAI,CAAC;;;;;;;;;;;;;AAc/C,SAAgB,YAAY,MAAc,GAAG,IAAsB;CACjE,MAAM,QAAQ,CAAC,MAAM,GAAG,GAAG,CAAC,IAAI,cAAc;CAE9C,IAAI,gBAAgB;CACpB,IAAI,iBAAiB;CAErB,cAAA,UACE,QACC,MAAM,UAAU;EACf,IAAI,eAAe,KAAK,EAAE;GACxB,gBAAgB;GAChB,iBAAiB;GACjB,OAAO;;IAGX,KACD;CAED,OAAO,SAAS,eAAe,GAAG,MAAM,MAAM,iBAAiB,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BpE,SAAgB,eAAe,MAAsB;CACnD,IAAI,eAAe,KAAK,EAAE,OAAO;CACjC,IAAI,KAAK,WAAW,KAAK,EAAE,OAAO;CAClC,IAAI,KAAK,WAAW,MAAM,EAAE,OAAO;CACnC,OAAO,KAAK;;;;;;;;;;;;AAad,SAAgB,YAAY,MAAsB;CAChD,OAAO,SAAS,MAAM,KAAK"}

package/dist/path.mjs

@@ -1,81 +1,163 @@
 import { arrayEach } from "./array.mjs";
+//#region src/path.ts
+/**
+* 判断是否是当前目录标记
+* @param {string} slice - 路径片段
+* @returns {boolean} - 如果是当前目录标记'.'则返回true，否则返回false
+*/
 function _isCurrentSlice(slice) {
-  return slice === ".";
+	return slice === ".";
 }
+/**
+* 判断是否是上级目录标记
+* @param {string} slice - 路径片段
+* @returns {boolean} - 如果是上级目录标记'..'则返回true，否则返回false
+*/
 function _isParentSlice(slice) {
-  return slice === "..";
+	return slice === "..";
 }
+/**
+* 判断是否是绝对路径
+* @param {string} path - 路径字符串
+* @returns {boolean} - 如果是绝对路径则返回true，否则返回false
+* @example
+* ```typescript
+* const isAbs = isAbsolutePath('/path/to/file');
+* console.log(isAbs); // 输出: true
+* ```
+*/
 function isAbsolutePath(path) {
-  return path.startsWith("/");
+	return path.startsWith("/");
 }
+/**
+* 判断是否是相对路径
+* @param {string} path - 路径字符串
+* @returns {boolean} - 如果是相对路径则返回true，否则返回false
+* @example
+* ```typescript
+* const isRel = isRelativePath('path/to/file');
+* console.log(isRel); // 输出: true
+* ```
+*/
 function isRelativePath(path) {
-  return !isAbsolutePath(path);
+	return !isAbsolutePath(path);
 }
+/**
+* 标准化路径
+* @param {string} path - 要标准化的路径字符串。
+* @returns {string} - 标准化后的路径字符串。
+* @example
+* ```typescript
+* const normalizedPath = pathNormalize('/path///to///file');
+* console.log(normalizedPath); // 输出: '/path/to/file'
+* ```
+*/
 function pathNormalize(path) {
-  const slices = path.replace(/\\/g, "/").replace(/\/{2,}/g, "/").replace(/\.{3,}/g, "..").replace(/\/\.\//g, "/").split("/").map((point) => point.trim());
-  const points = [];
-  const isAbs = slices[0] === "";
-  const push = (point) => {
-    points.push(point);
-  };
-  const back = () => {
-    if (points.length === 1 && isAbs) return;
-    if (points.length === 0 || points.at(-1) === "..") {
-      points.push("..");
-    } else {
-      points.pop();
-    }
-  };
-  for (const slice of slices) {
-    const isCurrent = _isCurrentSlice(slice);
-    const isParent = _isParentSlice(slice);
-    if (isCurrent) {
-      continue;
-    }
-    if (isParent) {
-      back();
-      continue;
-    }
-    push(slice);
-  }
-  return points.join("/") || (isAbs ? "/" : ".");
+	const slices = path.replace(/\\/g, "/").replace(/\/{2,}/g, "/").replace(/\.{3,}/g, "..").replace(/\/\.\//g, "/").split("/").map((point) => point.trim());
+	const points = [];
+	const isAbs = slices[0] === "";
+	const push = (point) => {
+		points.push(point);
+	};
+	const back = () => {
+		if (points.length === 1 && isAbs) return;
+		if (points.length === 0 || points.at(-1) === "..") points.push("..");
+		else points.pop();
+	};
+	for (const slice of slices) {
+		const isCurrent = _isCurrentSlice(slice);
+		const isParent = _isParentSlice(slice);
+		if (isCurrent) continue;
+		if (isParent) {
+			back();
+			continue;
+		}
+		push(slice);
+	}
+	return points.join("/") || (isAbs ? "/" : ".");
 }
+/**
+* 路径合并
+* @param {string} from - 起始路径。
+* @param {...string[]} to - 要合并的路径片段。
+* @returns {string} - 合并后的路径字符串。
+* @example
+* ```typescript
+* const fullPath = pathJoin('/path', '/to', 'file');
+* console.log(fullPath); // 输出: '/path/to/file'
+* ```
+*/
 function pathJoin(from, ...to) {
-  return pathNormalize([from, ...to].join("/"));
+	return pathNormalize([from, ...to].join("/"));
 }
+/**
+* 解析路径
+* @param {string} from - 起始路径
+* @param {...string[]} to - 要解析的路径片段
+* @returns {string} - 解析后的绝对路径
+* @example
+* ```typescript
+* const resolvedPath = pathResolve('/path', '/to', 'file');
+* console.log(resolvedPath); // 输出: '/to/file'
+* ```
+*/
 function pathResolve(from, ...to) {
-  const paths = [from, ...to].map(pathNormalize);
-  let lastStartPath = from;
-  let lastStartIndex = 0;
-  arrayEach(
-    paths,
-    (path, index) => {
-      if (isAbsolutePath(path)) {
-        lastStartPath = path;
-        lastStartIndex = index;
-        return false;
-      }
-    },
-    true
-  );
-  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));
+	const paths = [from, ...to].map(pathNormalize);
+	let lastStartPath = from;
+	let lastStartIndex = 0;
+	arrayEach(paths, (path, index) => {
+		if (isAbsolutePath(path)) {
+			lastStartPath = path;
+			lastStartIndex = index;
+			return false;
+		}
+	}, true);
+	return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));
 }
+/**
+* 将相对路径转换为标准的相对路径格式(添加'./'前缀)
+*
+* @param {string} path - 要处理的路径字符串
+* @returns {string} 处理后的路径字符串
+*
+* @example <caption>处理绝对路径</caption>
+* ```typescript
+* const result = pathRelativize('/path/to/file');
+* console.log(result); // 输出: '/path/to/file'
+* ```
+*
+* @example <caption>处理已带'./'前缀的相对路径</caption>
+* ```typescript
+* const result = pathRelativize('./path/to/file');
+* console.log(result); // 输出: './path/to/file'
+* ```
+*
+* @example <caption>处理不带'./'前缀的相对路径</caption>
+* ```typescript
+* const result = pathRelativize('path/to/file');
+* console.log(result); // 输出: './path/to/file'
+* ```
+*/
 function pathRelativize(path) {
-  if (isAbsolutePath(path)) return path;
-  if (path.startsWith("./")) return path;
-  if (path.startsWith("../")) return path;
-  return `./${path}`;
+	if (isAbsolutePath(path)) return path;
+	if (path.startsWith("./")) return path;
+	if (path.startsWith("../")) return path;
+	return `./${path}`;
 }
+/**
+* 获取路径的目录部分
+* @param {string} path - 输入的路径字符串
+* @returns {string} - 返回路径的目录部分
+* @example
+* ```typescript
+* const dir = pathDirname('/path/to/file.txt');
+* console.log(dir); // 输出: '/path/to'
+* ```
+*/
 function pathDirname(path) {
-  return pathJoin(path, "..");
+	return pathJoin(path, "..");
 }
-export {
-  isAbsolutePath,
-  isRelativePath,
-  pathDirname,
-  pathJoin,
-  pathNormalize,
-  pathRelativize,
-  pathResolve
-};
-//# sourceMappingURL=path.mjs.map
+//#endregion
+export { isAbsolutePath, isRelativePath, pathDirname, pathJoin, pathNormalize, pathRelativize, pathResolve };
+
+//# sourceMappingURL=path.mjs.map

package/dist/path.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"path.mjs","sources":["../src/path.ts"],"sourcesContent":["import { arrayEach } from './array';\n\n/**\n * 判断是否是当前目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是当前目录标记'.'则返回true，否则返回false\n */\nfunction _isCurrentSlice(slice: string): boolean {\n  return slice === '.';\n}\n\n/**\n * 判断是否是上级目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是上级目录标记'..'则返回true，否则返回false\n */\nfunction _isParentSlice(slice: string): boolean {\n  return slice === '..';\n}\n\n/**\n * 判断是否是绝对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是绝对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isAbs = isAbsolutePath('/path/to/file');\n * console.log(isAbs); // 输出: true\n * ```\n */\nexport function isAbsolutePath(path: string): boolean {\n  return path.startsWith('/');\n}\n\n/**\n * 判断是否是相对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是相对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isRel = isRelativePath('path/to/file');\n * console.log(isRel); // 输出: true\n * ```\n */\nexport function isRelativePath(path: string): boolean {\n  return !isAbsolutePath(path);\n}\n\n/**\n * 标准化路径\n * @param {string} path - 要标准化的路径字符串。\n * @returns {string} - 标准化后的路径字符串。\n * @example\n * ```typescript\n * const normalizedPath = pathNormalize('/path///to///file');\n * console.log(normalizedPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathNormalize(path: string): string {\n  const slices = path\n    .replace(/\\\\/g, '/')\n    .replace(/\\/{2,}/g, '/')\n    .replace(/\\.{3,}/g, '..')\n    .replace(/\\/\\.\\//g, '/')\n    .split('/')\n    .map((point) => point.trim());\n  const points: string[] = [];\n  const isAbs = slices[0] === '';\n\n  const push = (point: string) => {\n    points.push(point);\n  };\n\n  const back = () => {\n    // 绝对路径不能退到根目录\n    if (points.length === 1 && isAbs) return;\n\n    //\n    if (points.length === 0 || points.at(-1) === '..') {\n      points.push('..');\n    } else {\n      points.pop();\n    }\n  };\n\n  for (const slice of slices) {\n    const isCurrent = _isCurrentSlice(slice);\n    const isParent = _isParentSlice(slice);\n\n    // // 未进入实际路径\n    // if (!inPoints) {\n    //   push(slice);\n    //   inPoints = !isCurrent && !isParent;\n    //   continue;\n    // }\n\n    if (isCurrent) {\n      continue;\n    }\n\n    if (isParent) {\n      back();\n      continue;\n    }\n\n    push(slice);\n  }\n\n  return points.join('/') || (isAbs ? '/' : '.');\n}\n\n/**\n * 路径合并\n * @param {string} from - 起始路径。\n * @param {...string[]} to - 要合并的路径片段。\n * @returns {string} - 合并后的路径字符串。\n * @example\n * ```typescript\n * const fullPath = pathJoin('/path', '/to', 'file');\n * console.log(fullPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathJoin(from: string, ...to: string[]): string {\n  return pathNormalize([from, ...to].join('/'));\n}\n\n/**\n * 解析路径\n * @param {string} from - 起始路径\n * @param {...string[]} to - 要解析的路径片段\n * @returns {string} - 解析后的绝对路径\n * @example\n * ```typescript\n * const resolvedPath = pathResolve('/path', '/to', 'file');\n * console.log(resolvedPath); // 输出: '/to/file'\n * ```\n */\nexport function pathResolve(from: string, ...to: string[]): string {\n  const paths = [from, ...to].map(pathNormalize);\n\n  let lastStartPath = from;\n  let lastStartIndex = 0;\n\n  arrayEach(\n    paths,\n    (path, index) => {\n      if (isAbsolutePath(path)) {\n        lastStartPath = path;\n        lastStartIndex = index;\n        return false;\n      }\n    },\n    true,\n  );\n\n  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));\n}\n\n/**\n * 将相对路径转换为标准的相对路径格式(添加'./'前缀)\n *\n * @param {string} path - 要处理的路径字符串\n * @returns {string} 处理后的路径字符串\n *\n * @example <caption>处理绝对路径</caption>\n * ```typescript\n * const result = pathRelativize('/path/to/file');\n * console.log(result); // 输出: '/path/to/file'\n * ```\n *\n * @example <caption>处理已带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('./path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n *\n * @example <caption>处理不带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n */\nexport function pathRelativize(path: string): string {\n  if (isAbsolutePath(path)) return path;\n  if (path.startsWith('./')) return path;\n  if (path.startsWith('../')) return path;\n  return `./${path}`;\n}\n\n/**\n * 获取路径的目录部分\n * @param {string} path - 输入的路径字符串\n * @returns {string} - 返回路径的目录部分\n * @example\n * ```typescript\n * const dir = pathDirname('/path/to/file.txt');\n * console.log(dir); // 输出: '/path/to'\n * ```\n */\nexport function pathDirname(path: string): string {\n  return pathJoin(path, '..');\n}\n"],"names":[],"mappings":";AAOA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,UAAU;AACnB;AAOA,SAAS,eAAe,OAAwB;AAC9C,SAAO,UAAU;AACnB;AAYO,SAAS,eAAe,MAAuB;AAC7C,SAAA,KAAK,WAAW,GAAG;AAC5B;AAYO,SAAS,eAAe,MAAuB;AAC7C,SAAA,CAAC,eAAe,IAAI;AAC7B;AAYO,SAAS,cAAc,MAAsB;AAC5C,QAAA,SAAS,KACZ,QAAQ,OAAO,GAAG,EAClB,QAAQ,WAAW,GAAG,EACtB,QAAQ,WAAW,IAAI,EACvB,QAAQ,WAAW,GAAG,EACtB,MAAM,GAAG,EACT,IAAI,CAAC,UAAU,MAAM,KAAA,CAAM;AAC9B,QAAM,SAAmB,CAAC;AACpB,QAAA,QAAQ,OAAO,CAAC,MAAM;AAEtB,QAAA,OAAO,CAAC,UAAkB;AAC9B,WAAO,KAAK,KAAK;AAAA,EACnB;AAEA,QAAM,OAAO,MAAM;AAEb,QAAA,OAAO,WAAW,KAAK,MAAO;AAGlC,QAAI,OAAO,WAAW,KAAK,OAAO,GAAG,EAAE,MAAM,MAAM;AACjD,aAAO,KAAK,IAAI;AAAA,IAAA,OACX;AACL,aAAO,IAAI;AAAA,IAAA;AAAA,EAEf;AAEA,aAAW,SAAS,QAAQ;AACpB,UAAA,YAAY,gBAAgB,KAAK;AACjC,UAAA,WAAW,eAAe,KAAK;AASrC,QAAI,WAAW;AACb;AAAA,IAAA;AAGF,QAAI,UAAU;AACP,WAAA;AACL;AAAA,IAAA;AAGF,SAAK,KAAK;AAAA,EAAA;AAGZ,SAAO,OAAO,KAAK,GAAG,MAAM,QAAQ,MAAM;AAC5C;AAagB,SAAA,SAAS,SAAiB,IAAsB;AACvD,SAAA,cAAc,CAAC,MAAM,GAAG,EAAE,EAAE,KAAK,GAAG,CAAC;AAC9C;AAagB,SAAA,YAAY,SAAiB,IAAsB;AACjE,QAAM,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,IAAI,aAAa;AAE7C,MAAI,gBAAgB;AACpB,MAAI,iBAAiB;AAErB;AAAA,IACE;AAAA,IACA,CAAC,MAAM,UAAU;AACX,UAAA,eAAe,IAAI,GAAG;AACR,wBAAA;AACC,yBAAA;AACV,eAAA;AAAA,MAAA;AAAA,IAEX;AAAA,IACA;AAAA,EACF;AAEA,SAAO,SAAS,eAAe,GAAG,MAAM,MAAM,iBAAiB,CAAC,CAAC;AACnE;AA0BO,SAAS,eAAe,MAAsB;AAC/C,MAAA,eAAe,IAAI,EAAU,QAAA;AACjC,MAAI,KAAK,WAAW,IAAI,EAAU,QAAA;AAClC,MAAI,KAAK,WAAW,KAAK,EAAU,QAAA;AACnC,SAAO,KAAK,IAAI;AAClB;AAYO,SAAS,YAAY,MAAsB;AACzC,SAAA,SAAS,MAAM,IAAI;AAC5B;"}
+{"version":3,"file":"path.mjs","names":[],"sources":["../src/path.ts"],"sourcesContent":["import { arrayEach } from './array';\n\n/**\n * 判断是否是当前目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是当前目录标记'.'则返回true，否则返回false\n */\nfunction _isCurrentSlice(slice: string): boolean {\n  return slice === '.';\n}\n\n/**\n * 判断是否是上级目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是上级目录标记'..'则返回true，否则返回false\n */\nfunction _isParentSlice(slice: string): boolean {\n  return slice === '..';\n}\n\n/**\n * 判断是否是绝对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是绝对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isAbs = isAbsolutePath('/path/to/file');\n * console.log(isAbs); // 输出: true\n * ```\n */\nexport function isAbsolutePath(path: string): boolean {\n  return path.startsWith('/');\n}\n\n/**\n * 判断是否是相对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是相对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isRel = isRelativePath('path/to/file');\n * console.log(isRel); // 输出: true\n * ```\n */\nexport function isRelativePath(path: string): boolean {\n  return !isAbsolutePath(path);\n}\n\n/**\n * 标准化路径\n * @param {string} path - 要标准化的路径字符串。\n * @returns {string} - 标准化后的路径字符串。\n * @example\n * ```typescript\n * const normalizedPath = pathNormalize('/path///to///file');\n * console.log(normalizedPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathNormalize(path: string): string {\n  const slices = path\n    .replace(/\\\\/g, '/')\n    .replace(/\\/{2,}/g, '/')\n    .replace(/\\.{3,}/g, '..')\n    .replace(/\\/\\.\\//g, '/')\n    .split('/')\n    .map((point) => point.trim());\n  const points: string[] = [];\n  const isAbs = slices[0] === '';\n\n  const push = (point: string) => {\n    points.push(point);\n  };\n\n  const back = () => {\n    // 绝对路径不能退到根目录\n    if (points.length === 1 && isAbs) return;\n\n    //\n    if (points.length === 0 || points.at(-1) === '..') {\n      points.push('..');\n    } else {\n      points.pop();\n    }\n  };\n\n  for (const slice of slices) {\n    const isCurrent = _isCurrentSlice(slice);\n    const isParent = _isParentSlice(slice);\n\n    // // 未进入实际路径\n    // if (!inPoints) {\n    //   push(slice);\n    //   inPoints = !isCurrent && !isParent;\n    //   continue;\n    // }\n\n    if (isCurrent) {\n      continue;\n    }\n\n    if (isParent) {\n      back();\n      continue;\n    }\n\n    push(slice);\n  }\n\n  return points.join('/') || (isAbs ? '/' : '.');\n}\n\n/**\n * 路径合并\n * @param {string} from - 起始路径。\n * @param {...string[]} to - 要合并的路径片段。\n * @returns {string} - 合并后的路径字符串。\n * @example\n * ```typescript\n * const fullPath = pathJoin('/path', '/to', 'file');\n * console.log(fullPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathJoin(from: string, ...to: string[]): string {\n  return pathNormalize([from, ...to].join('/'));\n}\n\n/**\n * 解析路径\n * @param {string} from - 起始路径\n * @param {...string[]} to - 要解析的路径片段\n * @returns {string} - 解析后的绝对路径\n * @example\n * ```typescript\n * const resolvedPath = pathResolve('/path', '/to', 'file');\n * console.log(resolvedPath); // 输出: '/to/file'\n * ```\n */\nexport function pathResolve(from: string, ...to: string[]): string {\n  const paths = [from, ...to].map(pathNormalize);\n\n  let lastStartPath = from;\n  let lastStartIndex = 0;\n\n  arrayEach(\n    paths,\n    (path, index) => {\n      if (isAbsolutePath(path)) {\n        lastStartPath = path;\n        lastStartIndex = index;\n        return false;\n      }\n    },\n    true,\n  );\n\n  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));\n}\n\n/**\n * 将相对路径转换为标准的相对路径格式(添加'./'前缀)\n *\n * @param {string} path - 要处理的路径字符串\n * @returns {string} 处理后的路径字符串\n *\n * @example <caption>处理绝对路径</caption>\n * ```typescript\n * const result = pathRelativize('/path/to/file');\n * console.log(result); // 输出: '/path/to/file'\n * ```\n *\n * @example <caption>处理已带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('./path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n *\n * @example <caption>处理不带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n */\nexport function pathRelativize(path: string): string {\n  if (isAbsolutePath(path)) return path;\n  if (path.startsWith('./')) return path;\n  if (path.startsWith('../')) return path;\n  return `./${path}`;\n}\n\n/**\n * 获取路径的目录部分\n * @param {string} path - 输入的路径字符串\n * @returns {string} - 返回路径的目录部分\n * @example\n * ```typescript\n * const dir = pathDirname('/path/to/file.txt');\n * console.log(dir); // 输出: '/path/to'\n * ```\n */\nexport function pathDirname(path: string): string {\n  return pathJoin(path, '..');\n}\n"],"mappings":";;;;;;;AAOA,SAAS,gBAAgB,OAAwB;CAC/C,OAAO,UAAU;;;;;;;AAQnB,SAAS,eAAe,OAAwB;CAC9C,OAAO,UAAU;;;;;;;;;;;;AAanB,SAAgB,eAAe,MAAuB;CACpD,OAAO,KAAK,WAAW,IAAI;;;;;;;;;;;;AAa7B,SAAgB,eAAe,MAAuB;CACpD,OAAO,CAAC,eAAe,KAAK;;;;;;;;;;;;AAa9B,SAAgB,cAAc,MAAsB;CAClD,MAAM,SAAS,KACZ,QAAQ,OAAO,IAAI,CACnB,QAAQ,WAAW,IAAI,CACvB,QAAQ,WAAW,KAAK,CACxB,QAAQ,WAAW,IAAI,CACvB,MAAM,IAAI,CACV,KAAK,UAAU,MAAM,MAAM,CAAC;CAC/B,MAAM,SAAmB,EAAE;CAC3B,MAAM,QAAQ,OAAO,OAAO;CAE5B,MAAM,QAAQ,UAAkB;EAC9B,OAAO,KAAK,MAAM;;CAGpB,MAAM,aAAa;EAEjB,IAAI,OAAO,WAAW,KAAK,OAAO;EAGlC,IAAI,OAAO,WAAW,KAAK,OAAO,GAAG,GAAG,KAAK,MAC3C,OAAO,KAAK,KAAK;OAEjB,OAAO,KAAK;;CAIhB,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,YAAY,gBAAgB,MAAM;EACxC,MAAM,WAAW,eAAe,MAAM;EAStC,IAAI,WACF;EAGF,IAAI,UAAU;GACZ,MAAM;GACN;;EAGF,KAAK,MAAM;;CAGb,OAAO,OAAO,KAAK,IAAI,KAAK,QAAQ,MAAM;;;;;;;;;;;;;AAc5C,SAAgB,SAAS,MAAc,GAAG,IAAsB;CAC9D,OAAO,cAAc,CAAC,MAAM,GAAG,GAAG,CAAC,KAAK,IAAI,CAAC;;;;;;;;;;;;;AAc/C,SAAgB,YAAY,MAAc,GAAG,IAAsB;CACjE,MAAM,QAAQ,CAAC,MAAM,GAAG,GAAG,CAAC,IAAI,cAAc;CAE9C,IAAI,gBAAgB;CACpB,IAAI,iBAAiB;CAErB,UACE,QACC,MAAM,UAAU;EACf,IAAI,eAAe,KAAK,EAAE;GACxB,gBAAgB;GAChB,iBAAiB;GACjB,OAAO;;IAGX,KACD;CAED,OAAO,SAAS,eAAe,GAAG,MAAM,MAAM,iBAAiB,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BpE,SAAgB,eAAe,MAAsB;CACnD,IAAI,eAAe,KAAK,EAAE,OAAO;CACjC,IAAI,KAAK,WAAW,KAAK,EAAE,OAAO;CAClC,IAAI,KAAK,WAAW,MAAM,EAAE,OAAO;CACnC,OAAO,KAAK;;;;;;;;;;;;AAad,SAAgB,YAAY,MAAsB;CAChD,OAAO,SAAS,MAAM,KAAK"}