@pawover/kit 0.2.1 → 0.3.0

package/packages/utils/dist/index.d.ts

@@ -615,7 +615,6 @@ type AnyAsyncFunction<P extends any[] = any[], R = any> = (...args: P) => Promis
 type AnyGeneratorFunction<P extends any[] = any[], T = any, R = any, N = any> = (...args: P) => Generator<T, R, N>;
 /** 描述异步生成器函数类型 */
 type AnyAsyncGeneratorFunction<P extends any[] = any[], T = any, R = any, N = any> = (...args: P) => AsyncGenerator<T, R, N>;
-/** 描述无返回值函数 */
 //#endregion
 //#region src/function/functionUtil.d.ts
 /**
@@ -695,97 +694,225 @@ declare class FunctionUtil {
  */
 declare class MimeUtil {
   /**
-   * 标准 MIME 类型常量，用于文件类型标识和 HTTP Content-Type 头部
-   * 基于 IANA 注册标准和浏览器兼容性验证
-   */
-  static readonly MIME: {
-    /** 普通文本文件 */readonly TEXT: "text/plain"; /** 超文本标记语言文档 */
-    readonly HTML: "text/html"; /** 层叠样式表文件 */
-    readonly CSS: "text/css"; /** 逗号分隔值文件（表格数据） */
-    readonly CSV: "text/csv"; /** 制表符分隔值文件 */
-    readonly TSV: "text/tab-separated-values"; /** XML 文档 */
-    readonly XML: "text/xml"; /** XHTML 文档（XML 严格格式的 HTML） */
-    readonly XHTML: "application/xhtml+xml"; /** JavaScript 文件 */
-    readonly JS: "text/javascript"; /** TypeScript 文件 */
-    readonly TS: "text/typescript"; /** Python 文件 */
-    readonly PY: "text/x-python"; /** Shell 脚本 (.sh) */
-    readonly SH: "text/x-sh"; /** C 语言源文件 */
-    readonly C: "text/x-c"; /** C++ 源文件 */
-    readonly CPP: "text/x-c++"; /** C# 源文件 */
-    readonly CSHARP: "text/x-csharp"; /** Java 源文件 */
-    readonly JAVA: "text/x-java"; /** Go 源文件 */
-    readonly GO: "text/x-go"; /** Rust 源文件 */
-    readonly RUST: "text/x-rust"; /** PHP 文件 */
-    readonly PHP: "text/x-php"; /** Ruby 文件 */
-    readonly RUBY: "text/x-ruby"; /** Swift 源文件 */
-    readonly SWIFT: "text/x-swift"; /** YAML 文档 */
-    readonly YAML: "text/vnd.yaml"; /** TOML 文档 */
-    readonly TOML: "text/x-toml"; /** SQL 脚本 */
-    readonly SQL: "text/x-sql"; /** Markdown 格式文档 */
-    readonly MARKDOWN: "text/markdown"; /** 富文本格式文档（.rtf） */
-    readonly RTF: "application/rtf"; /** iCalendar 日历格式（.ics） */
-    readonly CALENDAR: "text/calendar"; /** JPEG 图像（.jpg/.jpeg） */
-    readonly JPEG: "image/jpeg"; /** PNG 图像（无损压缩，支持透明） */
-    readonly PNG: "image/png"; /** GIF 图像（支持动画） */
-    readonly GIF: "image/gif"; /** Windows 位图（.bmp） */
-    readonly BMP: "image/bmp"; /** SVG 向量图形（.svg） */
-    readonly SVG: "image/svg+xml"; /** APNG 动态图像（.apng） */
-    readonly APNG: "image/apng"; /** AVIF 图像（高效压缩） */
-    readonly AVIF: "image/avif"; /** 图标文件格式（.ico） */
-    readonly ICO: "image/vnd.microsoft.icon"; /** WebP 图像（高效压缩） */
-    readonly WEBP: "image/webp"; /** TIFF 图像（.tif/.tiff） */
-    readonly TIFF: "image/tiff"; /** HEIC 图像（高效编码） */
-    readonly HEIC: "image/heic"; /** Adobe Photoshop 文件（.psd） */
-    readonly PSD: "image/vnd.adobe.photoshop"; /** MP3 音频（.mp3） */
-    readonly MP3: "audio/mpeg"; /** AAC 音频（.aac） */
-    readonly AAC: "audio/aac"; /** MIDI 音乐文件（.mid/.midi） */
-    readonly MIDI: "audio/midi"; /** OGG 音频（.oga） */
-    readonly OGG_AUDIO: "audio/ogg"; /** Opus 音频（.opus） */
-    readonly OPUS: "audio/opus"; /** WAV 音频（.wav） */
-    readonly WAV: "audio/wav"; /** RealAudio 音频（.ra/.ram） */
-    readonly REAL_AUDIO: "audio/x-pn-realaudio"; /** MP4 视频（.mp4） */
-    readonly MP4: "video/mp4"; /** MPEG 视频（.mpeg/.mpg） */
-    readonly MPEG: "video/mpeg"; /** OGG 视频（.ogv） */
-    readonly OGG_VIDEO: "video/ogg"; /** AVI 视频（.avi） */
-    readonly AVI: "video/x-msvideo"; /** 3GPP 视频（.3gp） */
-    readonly THREE_GPP: "video/3gpp"; /** 3GPP2 视频（.3g2） */
-    readonly THREE_GPP2: "video/3gpp2"; /** WebM 视频（.webm） */
-    readonly WEBM: "video/webm"; /** PDF 文档 */
-    readonly PDF: "application/pdf"; /** Word 97-2003 文档（.doc） */
-    readonly DOC: "application/msword"; /** Word 2007+ 文档（.docx） */
-    readonly DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"; /** Excel 2007+ 工作簿（.xlsx） */
-    readonly XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"; /** 启用宏的Excel工作簿（.xlsm） */
-    readonly XLSM: "application/vnd.ms-excel.sheet.macroEnabled.12"; /** Excel模板文件（.xltx） */
-    readonly XLTX: "application/vnd.openxmlformats-officedocument.spreadsheetml.template"; /** PowerPoint 2007+ 演示文稿（.pptx） */
-    readonly PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation"; /** PowerPoint 97-2003 演示文稿（.ppt） */
-    readonly PPT: "application/vnd.ms-powerpoint"; /** OpenDocument 文本文档（.odt） */
-    readonly ODT: "application/vnd.oasis.opendocument.text"; /** OpenDocument 表格文档（.ods） */
-    readonly ODS: "application/vnd.oasis.opendocument.spreadsheet"; /** OpenDocument 演示文稿（.odp） */
-    readonly ODP: "application/vnd.oasis.opendocument.presentation"; /** EPUB 电子书（.epub） */
-    readonly EPUB: "application/epub+zip"; /** Kindle 电子书（.azw） */
-    readonly AZW: "application/vnd.amazon.ebook"; /** ZIP 压缩文件（.zip） */
-    readonly ZIP: "application/zip"; /** GZIP 压缩文件（.gz） */
-    readonly GZIP: "application/gzip"; /** GZIP 压缩文件（旧格式） */
-    readonly X_GZIP: "application/x-gzip"; /** TAR 归档文件（.tar） */
-    readonly TAR: "application/x-tar"; /** BZip 归档（.bz） */
-    readonly BZIP: "application/x-bzip"; /** BZip2 归档（.bz2） */
-    readonly BZIP2: "application/x-bzip2"; /** 7-Zip 压缩文件（.7z） */
-    readonly SEVEN_Z: "application/x-7z-compressed"; /** RAR 压缩文件（.rar） */
-    readonly RAR: "application/vnd.rar"; /** 通用二进制数据（默认类型） */
-    readonly OCTET_STREAM: "application/octet-stream"; /** JSON 数据格式（.json） */
-    readonly JSON: "application/json"; /** JSON-LD 格式（.jsonld） */
-    readonly LD_JSON: "application/ld+json"; /** Java 归档文件（.jar） */
-    readonly JAR: "application/java-archive"; /** WebAssembly 二进制指令格式（.wasm） */
-    readonly WASM: "application/wasm"; /** MS 嵌入式 OpenType 字体（.eot） */
-    readonly EOT: "application/vnd.ms-fontobject"; /** OpenType 字体（.otf） */
-    readonly OTF: "font/otf"; /** WOFF 字体（.woff） */
-    readonly WOFF: "font/woff"; /** WOFF2 字体（.woff2） */
-    readonly WOFF2: "font/woff2"; /** TrueType 字体（.ttf） */
-    readonly TTF: "font/ttf"; /** Excel 97-2003 工作簿（.xls） */
-    readonly XLS: "application/vnd.ms-excel"; /** Microsoft XPS 文档（.xps） */
-    readonly XPS: "application/vnd.ms-xpsdocument"; /** Word 启用宏文档（.docm） */
+   * 文件类型 MIME 常量
+   * - 每个类型对应具体的文件扩展名
+   */
+  static readonly FILE_MIME: {
+    /** 普通文本文件（.txt） */
+    readonly TEXT: "text/plain";
+    /** 超文本标记语言文档（.html/.htm） */
+    readonly HTML: "text/html";
+    /** 层叠样式表文件（.css） */
+    readonly CSS: "text/css";
+    /** 逗号分隔值文件/表格数据（.csv） */
+    readonly CSV: "text/csv";
+    /** 制表符分隔值文件（.tsv） */
+    readonly TSV: "text/tab-separated-values";
+    /** XML 文档（.xml） */
+    readonly XML: "application/xml";
+    /** XML 文档/兼容值 */
+    readonly XML_TEXT: "text/xml";
+    /** XHTML 文档（.xhtml/.xht） */
+    readonly XHTML: "application/xhtml+xml";
+    /** JavaScript 文件（.js） */
+    readonly JS: "text/javascript";
+    /** TypeScript 文件（.ts） */
+    readonly TS: "text/typescript";
+    /** Python 文件（.py） */
+    readonly PY: "text/x-python";
+    /** Shell 脚本 (.sh) */
+    readonly SH: "text/x-sh";
+    /** C 语言源文件（.c） */
+    readonly C: "text/x-c";
+    /** C++ 源文件（.cpp/.cc/.cxx） */
+    readonly CPP: "text/x-c++";
+    /** C# 源文件（.cs） */
+    readonly CSHARP: "text/x-csharp";
+    /** Java 源文件（.java） */
+    readonly JAVA: "text/x-java";
+    /** Go 源文件（.go） */
+    readonly GO: "text/x-go";
+    /** Rust 源文件（.rs） */
+    readonly RUST: "text/x-rust";
+    /** PHP 文件（.php） */
+    readonly PHP: "text/x-php";
+    /** Ruby 文件（.rb） */
+    readonly RUBY: "text/x-ruby";
+    /** Swift 源文件（.swift） */
+    readonly SWIFT: "text/x-swift";
+    /** YAML 文档（.yaml/.yml） */
+    readonly YAML: "application/yaml";
+    /** YAML 文档/兼容值 */
+    readonly YAML_TEXT: "text/vnd.yaml";
+    /** TOML 文档（.toml） */
+    readonly TOML: "application/toml";
+    /** TOML 文档/兼容值 */
+    readonly TOML_TEXT: "text/x-toml";
+    /** SQL 脚本（.sql） */
+    readonly SQL: "application/sql";
+    /** SQL 脚本/兼容值 */
+    readonly SQL_TEXT: "text/x-sql";
+    /** Markdown 格式文档（.md/.markdown） */
+    readonly MARKDOWN: "text/markdown";
+    /** 富文本格式文档（.rtf） */
+    readonly RTF: "application/rtf";
+    /** iCalendar 日历格式（.ics） */
+    readonly CALENDAR: "text/calendar";
+    /** JPEG 图像（.jpg/.jpeg） */
+    readonly JPEG: "image/jpeg";
+    /** JPG 图像（JPEG 别名，.jpg） */
+    readonly JPG: "image/jpeg";
+    /** PNG 图像/无损压缩，支持透明（.png） */
+    readonly PNG: "image/png";
+    /** GIF 图像/支持动画（.gif） */
+    readonly GIF: "image/gif";
+    /** Windows 位图（.bmp） */
+    readonly BMP: "image/bmp";
+    /** SVG 向量图形（.svg） */
+    readonly SVG: "image/svg+xml";
+    /** APNG 动态图像（.apng） */
+    readonly APNG: "image/apng";
+    /** AVIF 图像/高效压缩（.avif） */
+    readonly AVIF: "image/avif";
+    /** 图标文件格式（.ico） */
+    readonly ICO: "image/vnd.microsoft.icon";
+    /** WebP 图像/高效压缩（.webp） */
+    readonly WEBP: "image/webp";
+    /** TIFF 图像（.tif/.tiff） */
+    readonly TIFF: "image/tiff";
+    /** HEIC 图像/高效编码（.heic） */
+    readonly HEIC: "image/heic";
+    /** HEIF 图像/高效编码（.heif） */
+    readonly HEIF: "image/heif";
+    /** Adobe Photoshop 文件（.psd） */
+    readonly PSD: "image/vnd.adobe.photoshop";
+    /** MP3 音频（.mp3） */
+    readonly MP3: "audio/mpeg";
+    /** AAC 音频（.aac） */
+    readonly AAC: "audio/aac";
+    /** MIDI 音乐文件（.mid/.midi） */
+    readonly MIDI: "audio/midi";
+    /** OGG 音频（.oga） */
+    readonly OGG_AUDIO: "audio/ogg";
+    /** Opus 音频（.opus） */
+    readonly OPUS: "audio/opus";
+    /** FLAC 无损音频（.flac） */
+    readonly FLAC: "audio/flac";
+    /** WAV 音频（.wav） */
+    readonly WAV: "audio/wav";
+    /** WebM 音频（.weba） */
+    readonly WEBM_AUDIO: "audio/webm";
+    /** RealAudio 音频（.ra/.ram） */
+    readonly REAL_AUDIO: "audio/x-pn-realaudio";
+    /** MP4 视频（.mp4） */
+    readonly MP4: "video/mp4";
+    /** MPEG 视频（.mpeg/.mpg） */
+    readonly MPEG: "video/mpeg";
+    /** OGG 视频（.ogv） */
+    readonly OGG_VIDEO: "video/ogg";
+    /** AVI 视频（.avi） */
+    readonly AVI: "video/x-msvideo";
+    /** 3GPP 视频（.3gp） */
+    readonly THREE_GPP: "video/3gpp";
+    /** 3GPP2 视频（.3g2） */
+    readonly THREE_GPP2: "video/3gpp2";
+    /** WebM 视频（.webm） */
+    readonly WEBM: "video/webm";
+    /** QuickTime 视频（.mov） */
+    readonly QUICKTIME: "video/quicktime";
+    /** PDF 文档（.pdf） */
+    readonly PDF: "application/pdf";
+    /** Word 97-2003 文档（.doc） */
+    readonly DOC: "application/msword";
+    /** Word 2007+ 文档（.docx） */
+    readonly DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    /** Excel 2007+ 工作簿（.xlsx） */
+    readonly XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    /** 启用宏的Excel工作簿（.xlsm） */
+    readonly XLSM: "application/vnd.ms-excel.sheet.macroEnabled.12";
+    /** Excel模板文件（.xltx） */
+    readonly XLTX: "application/vnd.openxmlformats-officedocument.spreadsheetml.template";
+    /** PowerPoint 2007+ 演示文稿（.pptx） */
+    readonly PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    /** PowerPoint 97-2003 演示文稿（.ppt） */
+    readonly PPT: "application/vnd.ms-powerpoint";
+    /** OpenDocument 文本文档（.odt） */
+    readonly ODT: "application/vnd.oasis.opendocument.text";
+    /** OpenDocument 表格文档（.ods） */
+    readonly ODS: "application/vnd.oasis.opendocument.spreadsheet";
+    /** OpenDocument 演示文稿（.odp） */
+    readonly ODP: "application/vnd.oasis.opendocument.presentation";
+    /** EPUB 电子书（.epub） */
+    readonly EPUB: "application/epub+zip";
+    /** Kindle 电子书（.azw） */
+    readonly AZW: "application/vnd.amazon.ebook";
+    /** ZIP 压缩文件（.zip） */
+    readonly ZIP: "application/zip";
+    /** GZIP 压缩文件（.gz） */
+    readonly GZIP: "application/gzip";
+    /** TAR 归档文件（.tar） */
+    readonly TAR: "application/x-tar";
+    /** BZip 归档（.bz） */
+    readonly BZIP: "application/x-bzip";
+    /** BZip2 归档（.bz2） */
+    readonly BZIP2: "application/x-bzip2";
+    /** 7-Zip 压缩文件（.7z） */
+    readonly SEVEN_Z: "application/x-7z-compressed";
+    /** RAR 压缩文件（.rar） */
+    readonly RAR: "application/vnd.rar";
+    /** XZ 压缩文件（.xz） */
+    readonly XZ: "application/x-xz";
+    /** Zstandard 压缩文件（.zst） */
+    readonly ZSTD: "application/zstd";
+    /** ISO 光盘镜像（.iso） */
+    readonly ISO9660_IMAGE: "application/x-iso9660-image";
+    /** JSON 数据格式（.json） */
+    readonly JSON: "application/json";
+    /** JSON-LD 格式（.jsonld） */
+    readonly LD_JSON: "application/ld+json";
+    /** Web App Manifest（.webmanifest） */
+    readonly MANIFEST: "application/manifest+json";
+    /** Java 归档文件（.jar） */
+    readonly JAR: "application/java-archive";
+    /** WebAssembly 二进制指令格式（.wasm） */
+    readonly WASM: "application/wasm";
+    /** MS 嵌入式 OpenType 字体（.eot） */
+    readonly EOT: "application/vnd.ms-fontobject";
+    /** OpenType 字体（.otf） */
+    readonly OTF: "font/otf";
+    /** WOFF 字体（.woff） */
+    readonly WOFF: "font/woff";
+    /** WOFF2 字体（.woff2） */
+    readonly WOFF2: "font/woff2";
+    /** TrueType 字体（.ttf） */
+    readonly TTF: "font/ttf";
+    /** Excel 97-2003 工作簿（.xls） */
+    readonly XLS: "application/vnd.ms-excel";
+    /** Microsoft XPS 文档（.xps） */
+    readonly XPS: "application/vnd.ms-xpsdocument";
+    /** Word 启用宏文档（.docm） */
     readonly DOCM: "application/vnd.ms-word.document.macroEnabled.12";
   };
+  /**
+   * 协议/内容类型 MIME 常量
+   * - 用于 HTTP 请求/响应内容协商，无对应文件扩展名
+   */
+  static readonly PROTOCOL_MIME: {
+    /** 通用二进制数据流 */
+    readonly OCTET_STREAM: "application/octet-stream";
+    /** URL 编码表单 */
+    readonly FORM_URLENCODED: "application/x-www-form-urlencoded";
+    /** multipart 表单 */
+    readonly FORM_DATA: "multipart/form-data";
+    /** Server-Sent Events 数据流 */
+    readonly EVENT_STREAM: "text/event-stream";
+    /** 问题详情 JSON（RFC 9457） */
+    readonly PROBLEM_JSON: "application/problem+json";
+    /** JSON Patch（RFC 6902） */
+    readonly JSON_PATCH: "application/json-patch+json";
+    /** JSON Merge Patch（RFC 7386） */
+    readonly MERGE_PATCH_JSON: "application/merge-patch+json";
+  };
 }
 //#endregion
 //#region src/number/numberUtil.d.ts
@@ -810,7 +937,7 @@ declare class NumberUtil {
   static within(input: number, interval: [number, number], includeLeft?: boolean, includeRight?: boolean): boolean;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/typed-array.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/typed-array.d.ts
 /**
 Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
 
@@ -818,7 +945,7 @@ Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScrip
 */
 type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/characters.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/characters.d.ts
 /**
 Matches any digit as a string ('0'-'9').
 
@@ -835,7 +962,7 @@ const b: DigitCharacter = 0; // Invalid
 */
 type DigitCharacter = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/union-to-intersection.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/union-to-intersection.d.ts
 /**
 Convert a union type to an intersection type.
 
@@ -853,18 +980,23 @@ type Intersection = UnionToIntersection<Union>;
 
 @category Type
 */
-type UnionToIntersection<Union> = (// `extends unknown` is always going to be the case and is used to convert the
+type UnionToIntersection<Union> = (
+// `extends unknown` is always going to be the case and is used to convert the
 // `Union` into a [distributive conditional
 // type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-Union extends unknown // The union type is used as the only argument to a function since the union
+Union extends unknown ?
+// The union type is used as the only argument to a function since the union
 // of function arguments is an intersection.
-? (distributedUnion: Union) => void // This won't happen.
-: never // Infer the `Intersection` type since TypeScript represents the positional
+(distributedUnion: Union) => void :
+// This won't happen.
+never
+// Infer the `Intersection` type since TypeScript represents the positional
 // arguments of unions of functions as an intersection of the union.
-) extends ((mergedIntersection: infer Intersection) => void) // The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
-? Intersection & Union : never;
+) extends ((mergedIntersection: infer Intersection) => void) ?
+// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+Intersection & Union : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/keys-of-union.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/keys-of-union.d.ts
 /**
 Create a union of all keys from a given type, even those exclusive to specific union members.
 
@@ -902,10 +1034,11 @@ type AllKeys = KeysOfUnion<Union>;
 
 @category Object
 */
-type KeysOfUnion<ObjectType> = // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+type KeysOfUnion<ObjectType> =
+// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
 keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-any.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-any.d.ts
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -936,7 +1069,7 @@ const anyA = get(anyObject, 'a');
 */
 type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-optional-key-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-optional-key-of.d.ts
 /**
 Returns a boolean for whether the given key is an optional key of type.
 
@@ -979,7 +1112,7 @@ type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
 */
 type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/optional-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
 
@@ -1014,10 +1147,10 @@ const update2: UpdateOperation<User> = {
 @category Utilities
 */
 type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
-? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
-: never;
+ ? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never; }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+ : never; // Should never happen
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/required-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/required-keys-of.d.ts
 /**
 Extract all required keys from the given type.
 
@@ -1049,9 +1182,9 @@ const validator3 = createValidation<User>('luckyNumber', value => value > 0);
 @category Utilities
 */
 type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
-? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
+ ? Exclude<keyof Type, OptionalKeysOf<Type>> : never; // Should never happen
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-never.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -1107,7 +1240,7 @@ type B = IsTrueFixed<never>;
 */
 type IsNever<T> = [T] extends [never] ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/if.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/if.d.ts
 /**
 An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
 
@@ -1202,7 +1335,7 @@ type Works = IncludesWithoutIf<HundredZeroes, '1'>;
 */
 type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/unknown-array.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/unknown-array.d.ts
 /**
 Represents an array with `unknown` value.
 
@@ -1229,7 +1362,7 @@ type C = IsArray<string>;
 */
 type UnknownArray = readonly unknown[];
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/internal/type.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/type.d.ts
 /**
 Returns a boolean for whether A is false.
 
@@ -1248,16 +1381,16 @@ An if-else-like type that resolves depending on whether the given type is `any`
 
 @example
 ```
-// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
-type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+// When `T` is neither `any` nor `never` (like `string`) => Returns `IfNot` branch
+type A = IfNotAnyOrNever<string, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
 //=> 'VALID'
 
 // When `T` is `any` => Returns `IfAny` branch
-type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+type B = IfNotAnyOrNever<any, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
 //=> 'IS_ANY'
 
 // When `T` is `never` => Returns `IfNever` branch
-type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+type C = IfNotAnyOrNever<never, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
 //=> 'IS_NEVER'
 ```
 
@@ -1270,7 +1403,7 @@ import type {StringRepeat} from 'type-fest';
 type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;
 
 // The following implementation is not tail recursive
-type TrimLeft<S extends string> = IfNotAnyOrNever<S, S extends ` ${infer R}` ? TrimLeft<R> : S>;
+type TrimLeft<S extends string> = IfNotAnyOrNever<S, {ifNot: S extends ` ${infer R}` ? TrimLeft<R> : S}>;
 
 // Hence, instantiations with long strings will fail
 // @ts-expect-error
@@ -1279,7 +1412,7 @@ type T1 = TrimLeft<NineHundredNinetyNineSpaces>;
 // Error: Type instantiation is excessively deep and possibly infinite.
 
 // To fix this, move the recursion into a helper type
-type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, _TrimLeftOptimised<S>>;
+type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, {ifNot: _TrimLeftOptimised<S>}>;
 
 type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;
 
@@ -1287,13 +1420,17 @@ type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
 //=> ''
 ```
 */
-type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;
+type IfNotAnyOrNever<T, Cases extends {
+  ifNot: unknown;
+  ifAny?: unknown;
+  ifNever?: unknown;
+}> = IsAny<T> extends true ? 'ifAny' extends keyof Cases ? Cases['ifAny'] : any : IsNever<T> extends true ? 'ifNever' extends keyof Cases ? Cases['ifNever'] : never : Cases['ifNot'];
 /**
 Indicates the value of `exactOptionalPropertyTypes` compiler option.
 */
 type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extends [string?] ? false : true;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/internal/array.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/array.d.ts
 /**
 Transforms a tuple type by replacing it's rest element with a single element that has the same type as the rest element, while keeping all the non-rest elements intact.
 
@@ -1325,31 +1462,23 @@ type B = CollapseRestElement<[string?, string?, ...number[]]>;
 //=> [string | undefined, string | undefined, number]
 ```
 */
-type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, _CollapseRestElement<TArray>>;
+type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, {
+  ifNot: _CollapseRestElement<TArray>;
+}>;
 type _CollapseRestElement<TArray extends UnknownArray, ForwardAccumulator extends UnknownArray = [], BackwardAccumulator extends UnknownArray = []> = TArray extends UnknownArray // For distributing `TArray`
-? keyof TArray & `${number}` extends never // Enters this branch, if `TArray` is empty (e.g., []),
+ ? keyof TArray & `${number}` extends never ?
+// Enters this branch, if `TArray` is empty (e.g., []),
 // or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-? TArray extends readonly [...infer Rest, infer Last] ? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
-: TArray extends readonly [] ? [...ForwardAccumulator, ...BackwardAccumulator] : [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
-: TArray extends readonly [(infer First)?, ...infer Rest] ? _CollapseRestElement<Rest, [...ForwardAccumulator, '0' extends OptionalKeysOf<TArray> ? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
-: First], BackwardAccumulator> : never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
-: never; // Should never happen
+TArray extends readonly [...infer Rest, infer Last] ? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
+ : TArray extends readonly [] ? [...ForwardAccumulator, ...BackwardAccumulator] : [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
+ : TArray extends readonly [(infer First)?, ...infer Rest] ? _CollapseRestElement<Rest, [...ForwardAccumulator, '0' extends OptionalKeysOf<TArray> ? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+ : First], BackwardAccumulator> : never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+ : never; // Should never happen
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/numeric.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/numeric.d.ts
 type _Numeric = number | bigint;
 type Zero = 0 | 0n;
 /**
-Matches the hidden `Infinity` type.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
-
-@see {@link NegativeInfinity}
-
-@category Numeric
-*/
-// See https://github.com/microsoft/TypeScript/issues/31752
-// eslint-disable-next-line no-loss-of-precision
-/**
 A negative `number`/`bigint` (`-∞ < x < 0`)
 
 Use-case: Validating and documenting parameters.
@@ -1380,12 +1509,12 @@ type IsNegative<T extends _Numeric> = T extends Negative<T> ? true : false;
 //#region ../../node_modules/.pnpm/tagged-tag@1.0.0/node_modules/tagged-tag/index.d.ts
 declare const tag: unique symbol;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/tagged.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/tagged.d.ts
 // eslint-disable-next-line type-fest/require-exported-types
 type TagContainer<Token> = {
   readonly [tag]: Token;
 };
-type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{ [K in Token]: TagMetadata }>;
+type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{ [K in Token]: TagMetadata; }>;
 /**
 Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf).
 
@@ -1476,83 +1605,9 @@ type WontWork = UnwrapTagged<string>;
 @category Type
 */
 type UnwrapTagged<TaggedType extends Tag<PropertyKey, any>> = RemoveAllTags<TaggedType>;
-type RemoveAllTags<T> = T extends Tag<PropertyKey, any> ? { [ThisTag in keyof T[typeof tag]]: T extends Tagged<infer Type, ThisTag, T[typeof tag][ThisTag]> ? RemoveAllTags<Type> : never }[keyof T[typeof tag]] : T;
-/**
-Note: The `Opaque` type is deprecated in favor of `Tagged`.
-
-Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for runtime values that would otherwise have the same type. (See examples.)
-
-The generic type parameters can be anything.
-
-Note that `Opaque` is somewhat of a misnomer here, in that, unlike [some alternative implementations](https://github.com/microsoft/TypeScript/issues/4895#issuecomment-425132582), the original, untagged type is not actually hidden. (E.g., functions that accept the untagged type can still be called with the "opaque" version -- but not vice-versa.)
-
-Also note that this implementation is limited to a single tag. If you want to allow multiple tags, use `Tagged` instead.
-
-[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
-
-There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
-	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
-	- [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
-	- [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
-
-@example
-```
-import type {Opaque} from 'type-fest';
-
-type AccountNumber = Opaque<number, 'AccountNumber'>;
-type AccountBalance = Opaque<number, 'AccountBalance'>;
-
-// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
-type ThingOne = Opaque<string>;
-type ThingTwo = Opaque<string>;
-
-// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
-// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
-type NewThingOne = Opaque<string, 'ThingOne'>;
-type NewThingTwo = Opaque<string, 'ThingTwo'>;
-
-// Now they're completely separate types, so the following will fail to compile.
-function createNewThingOne(): NewThingOne {
-	// As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
-	return 'new thing one' as NewThingOne;
-}
-
-// This will fail to compile, as they are fundamentally different types.
-// @ts-expect-error
-const thingTwo = createNewThingOne() as NewThingTwo;
-
-// Here's another example of opaque typing.
-function createAccountNumber(): AccountNumber {
-	return 2 as AccountNumber;
-}
-
-declare function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance;
-
-// This will compile successfully.
-getMoneyForAccount(createAccountNumber());
-
-// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
-// @ts-expect-error
-getMoneyForAccount(2);
-
-// You can use opaque values like they aren't opaque too.
-const accountNumber = createAccountNumber();
-
-// This will compile successfully.
-const newAccountNumber = accountNumber + 2;
-
-// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
-type Person = {
-	id: Opaque<number, Person>;
-	name: string;
-};
-```
-
-@category Type
-@deprecated Use {@link Tagged} instead
-*/
+type RemoveAllTags<T> = T extends Tag<PropertyKey, any> ? { [ThisTag in keyof T[typeof tag]]: T extends Tagged<infer Type, ThisTag, T[typeof tag][ThisTag]> ? RemoveAllTags<Type> : never; }[keyof T[typeof tag]] : T;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-literal.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-literal.d.ts
 /**
 Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 
@@ -1609,12 +1664,17 @@ type L2 = Length<`${number}`>;
 @category Type Guard
 @category Utilities
 */
-type IsStringLiteral<S> = IfNotAnyOrNever<S, _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>, false, false>;
-type _IsStringLiteral<S> = // If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
+type IsStringLiteral<S> = IfNotAnyOrNever<S, {
+  ifNot: _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>;
+  ifAny: false;
+  ifNever: false;
+}>;
+type _IsStringLiteral<S> =
+// If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
 // and since `{}` extends index signatures, the result becomes `false`.
 S extends string ? {} extends Record<S, never> ? false : true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/tuple-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/tuple-of.d.ts
 /**
 Create a tuple type of the specified length with elements of the specified type.
 
@@ -1689,13 +1749,17 @@ Note: If you need a readonly tuple, simply wrap this type with `Readonly`, for e
 
 @category Array
 */
-type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, _TupleOf<If<IsNegative<Length>, 0, Length>, Fill>, Fill[], []>;
+type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, {
+  ifNot: _TupleOf<If<IsNegative<Length>, 0, Length>, Fill>;
+  ifAny: Fill[];
+  ifNever: [];
+}>;
 type _TupleOf<Length extends number, Fill> = number extends Length ? Fill[] : BuildTupleDigitByDigit<`${Length}`, Fill>;
 type BuildTupleDigitByDigit<Length extends string, Fill, Accumulator extends UnknownArray = []> = Length extends `${infer First extends DigitCharacter}${infer Rest}` ? BuildTupleDigitByDigit<Rest, Fill, [...RepeatTupleTenTimes<Accumulator>, ...DigitTupleOf<First, Fill>]> : Accumulator;
 type RepeatTupleTenTimes<Tuple extends UnknownArray> = [...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple, ...Tuple];
 type DigitTupleOf<Digit extends DigitCharacter, Fill> = [[], [Fill], [Fill, Fill], [Fill, Fill, Fill], [Fill, Fill, Fill, Fill], [Fill, Fill, Fill, Fill, Fill], [Fill, Fill, Fill, Fill, Fill, Fill], [Fill, Fill, Fill, Fill, Fill, Fill, Fill], [Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill], [Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill, Fill]][Digit];
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/simplify.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/simplify.d.ts
 /**
 Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 
@@ -1754,9 +1818,9 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @see {@link SimplifyDeep}
 @category Object
 */
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-equal.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-equal.d.ts
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -1787,7 +1851,7 @@ type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false
 // This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
 type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/omit-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/omit-index-signature.d.ts
 /**
 Omit any index signatures from the given object type, leaving only explicitly defined properties.
 
@@ -1879,9 +1943,9 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 @see {@link PickIndexSignature}
 @category Object
 */
-type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType]; };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/pick-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/pick-index-signature.d.ts
 /**
 Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 
@@ -1927,11 +1991,11 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 @see {@link OmitIndexSignature}
 @category Object
 */
-type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
+type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType]; };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/merge.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/merge.d.ts
 // Merges two objects without worrying about index signatures.
-type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;
+type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key]; } & Source>;
 /**
 Merge two types into a new type. Keys of the second type overrides keys of the first type.
 
@@ -1995,13 +2059,12 @@ Note: If you want a merge type that more accurately reflects the runtime behavio
 @category Object
 */
 type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
-? Source extends unknown // For distributing `Source`
-? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
-: never;
-// Should never happen
+ ? Source extends unknown // For distributing `Source`
+ ? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
+ : never; // Should never happen
 type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/internal/object.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/object.d.ts
 /**
 Works similar to the built-in `Pick` utility type, except for the following differences:
 - Distributes over union types and allows picking keys from any member of the union type.
@@ -2039,7 +2102,7 @@ type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
 type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
 //=> {}
 */
-type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = { [P in keyof T as Extract<P, Keys>]: T[P] };
+type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = { [P in keyof T as Extract<P, Keys>]: T[P]; };
 /**
 Merges user specified options with default options.
 
@@ -2092,9 +2155,9 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
 ```
 */
-type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
-? Result : never;
-type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key] }>>>;
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends (infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+) ? Result : never;
+type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key]; }>>>;
 /**
 Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
 
@@ -2122,35 +2185,44 @@ type E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined
 //=> string | null | undefined
 ```
 */
-type CollapseLiterals<T> = {} extends T ? T : T extends infer U & {} ? U : T;
+type CollapseLiterals<T> = {} extends T ? T : T extends (infer U) & {} ? U : T;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/some-extend.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/some-extend.d.ts
 /**
 @see {@link SomeExtend}
 */
 type SomeExtendOptions = {
   /**
-  Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
-  	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
-  - When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
-  	@default true
-  	@example
-  ```
-  import type {SomeExtend} from 'type-fest';
-  	type A = SomeExtend<[1, 2, never], string, {strictNever: true}>;
-  //=> false
-  	type B = SomeExtend<[1, 2, never], string, {strictNever: false}>;
-  //=> true
-  	type C = SomeExtend<[1, never], never, {strictNever: true}>;
-  //=> true
-  	type D = SomeExtend<[1, never], never, {strictNever: false}>;
-  //=> true
-  	type E = SomeExtend<[never], any, {strictNever: true}>;
-  //=> true
-  	type F = SomeExtend<[never], any, {strictNever: false}>;
-  //=> true
-  ```
-  */
+	Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+
+	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+	- When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+
+	@default true
+
+	@example
+	```
+	import type {SomeExtend} from 'type-fest';
+
+	type A = SomeExtend<[1, 2, never], string, {strictNever: true}>;
+	//=> false
+
+	type B = SomeExtend<[1, 2, never], string, {strictNever: false}>;
+	//=> true
+
+	type C = SomeExtend<[1, never], never, {strictNever: true}>;
+	//=> true
+
+	type D = SomeExtend<[1, never], never, {strictNever: false}>;
+	//=> true
+
+	type E = SomeExtend<[never], any, {strictNever: true}>;
+	//=> true
+
+	type F = SomeExtend<[never], any, {strictNever: false}>;
+	//=> true
+	```
+	*/
   strictNever?: boolean;
 };
 type DefaultSomeExtendOptions = {
@@ -2203,10 +2275,15 @@ type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
 @category Array
 */
 type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> = _SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
-type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
-? true : _SomeExtend<Rest, Type, Options> : First extends Type ? true : _SomeExtend<Rest, Type, Options> : false, false, false>;
+type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, {
+  ifNot: TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true ?
+  // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
+  true : _SomeExtend<Rest, Type, Options> : First extends Type ? true : _SomeExtend<Rest, Type, Options> : false;
+  ifAny: false;
+  ifNever: false;
+}>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/or-all.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/or-all.d.ts
 /**
 Returns a boolean for whether any of the given elements is `true`.
 
@@ -2277,7 +2354,7 @@ Note: `OrAll<[]>` evaluates to `false` because there are no `true` elements in a
 */
 type OrAll<T extends readonly boolean[]> = SomeExtend<T, true>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/or.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/or.d.ts
 /**
 Returns a boolean for whether either of two given types is `true`.
 
@@ -2357,37 +2434,48 @@ type G = Or<never, never>;
 */
 type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/all-extend.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/all-extend.d.ts
 /**
 @see {@link AllExtend}
 */
 type AllExtendOptions = {
   /**
-  Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
-  	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
-  - When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
-  	@default true
-  	@example
-  ```
-  import type {AllExtend} from 'type-fest';
-  	type A = AllExtend<[1, 2, never], number, {strictNever: true}>;
-  //=> false
-  	type B = AllExtend<[1, 2, never], number, {strictNever: false}>;
-  //=> true
-  	type C = AllExtend<[never, never], never, {strictNever: true}>;
-  //=> true
-  	type D = AllExtend<[never, never], never, {strictNever: false}>;
-  //=> true
-  	type E = AllExtend<['a', 'b', never], any, {strictNever: true}>;
-  //=> true
-  	type F = AllExtend<['a', 'b', never], any, {strictNever: false}>;
-  //=> true
-  	type G = AllExtend<[never, 1], never, {strictNever: true}>;
-  //=> false
-  	type H = AllExtend<[never, 1], never, {strictNever: false}>;
-  //=> false
-  ```
-  */
+	Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+
+	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+	- When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+
+	@default true
+
+	@example
+	```
+	import type {AllExtend} from 'type-fest';
+
+	type A = AllExtend<[1, 2, never], number, {strictNever: true}>;
+	//=> false
+
+	type B = AllExtend<[1, 2, never], number, {strictNever: false}>;
+	//=> true
+
+	type C = AllExtend<[never, never], never, {strictNever: true}>;
+	//=> true
+
+	type D = AllExtend<[never, never], never, {strictNever: false}>;
+	//=> true
+
+	type E = AllExtend<['a', 'b', never], any, {strictNever: true}>;
+	//=> true
+
+	type F = AllExtend<['a', 'b', never], any, {strictNever: false}>;
+	//=> true
+
+	type G = AllExtend<[never, 1], never, {strictNever: true}>;
+	//=> false
+
+	type H = AllExtend<[never, 1], never, {strictNever: false}>;
+	//=> false
+	```
+	*/
   strictNever?: boolean;
 };
 type DefaultAllExtendOptions = {
@@ -2440,10 +2528,15 @@ type B = AllExtend<[1?, 2?, 3?], number | undefined>;
 @category Array
 */
 type AllExtend<TArray extends UnknownArray, Type, Options extends AllExtendOptions = {}> = _AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
-type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, recurse further.
-? _AllExtend<Rest, Type, Options> : false : First extends Type ? _AllExtend<Rest, Type, Options> : false : true, false, false>;
+type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, {
+  ifNot: TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true ?
+  // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, recurse further.
+  _AllExtend<Rest, Type, Options> : false : First extends Type ? _AllExtend<Rest, Type, Options> : false : true;
+  ifAny: false;
+  ifNever: false;
+}>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/and-all.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/and-all.d.ts
 /**
 Returns a boolean for whether all of the given elements are `true`.
 
@@ -2517,7 +2610,7 @@ Note: `AndAll<[]>` evaluates to `true` due to the concept of [vacuous truth](htt
 */
 type AndAll<T extends readonly boolean[]> = AllExtend<T, true>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/and.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/and.d.ts
 /**
 Returns a boolean for whether two given types are both `true`.
 
@@ -2597,7 +2690,7 @@ type G = And<never, never>;
 */
 type And<A extends boolean, B extends boolean> = AndAll<[A, B]>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/except.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/except.d.ts
 /**
 Filter out keys from an object.
 
@@ -2628,10 +2721,12 @@ type Filtered = Filter<'bar', 'foo'>;
 type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
 type ExceptOptions = {
   /**
-  Disallow assigning non-specified properties.
-  	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
-  	@default false
-  */
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
   requireExactProps?: boolean;
 };
 type DefaultExceptOptions = {
@@ -2693,9 +2788,9 @@ type PostPayloadFixed = Except<UserData, 'email'>;
 @category Object
 */
 type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
-type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType]; } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/exclude-exactly.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/exclude-exactly.d.ts
 /**
 A stricter version of `Exclude<T, U>` that excludes types only when they are exactly identical.
 
@@ -2724,16 +2819,24 @@ type TestExcludeExactly3 = ExcludeExactly<{a: string} | {a: string; b: string},
 
 @category Improved Built-in
 */
-type ExcludeExactly<Union, Delete> = IfNotAnyOrNever<Union, _ExcludeExactly<Union, Delete>, // If `Union` is `any`, then if `Delete` is `any`, return `never`, else return `Union`.
-If<IsAny<Delete>, never, Union>, // If `Union` is `never`, then if `Delete` is `never`, return `never`, else return `Union`.
-If<IsNever<Delete>, never, Union>>;
-type _ExcludeExactly<Union, Delete> = IfNotAnyOrNever<Delete, Union extends unknown // For distributing `Union`
-? [Delete extends unknown // For distributing `Delete`
-? If<IsEqual<Union, Delete>, true, never> : never] extends [never] ? Union : never : never, // If `Delete` is `any` or `never`, then return `Union`,
-// because `Union` cannot be `any` or `never` here.
-Union, Union>;
+type ExcludeExactly<Union, Delete> = IfNotAnyOrNever<Union, {
+  ifNot: _ExcludeExactly<Union, Delete>;
+  // If `Union` is `any`, then if `Delete` is `any`, return `never`, else return `Union`.
+  ifAny: If<IsAny<Delete>, never, Union>;
+  // If `Union` is `never`, then if `Delete` is `never`, return `never`, else return `Union`.
+  ifNever: If<IsNever<Delete>, never, Union>;
+}>;
+type _ExcludeExactly<Union, Delete> = IfNotAnyOrNever<Delete, {
+  ifNot: Union extends unknown // For distributing `Union`
+   ? [Delete extends unknown // For distributing `Delete`
+   ? If<IsEqual<Union, Delete>, true, never> : never] extends [never] ? Union : never : never;
+  // If `Delete` is `any` or `never`, then return `Union`,
+  // because `Union` cannot be `any` or `never` here.
+  ifAny: Union;
+  ifNever: Union;
+}>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/union-member.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/union-member.d.ts
 /**
 Returns an arbitrary member of a union type.
 
@@ -2790,7 +2893,7 @@ type LastNever = UnionMember<never>;
 */
 type UnionMember<T> = IsNever<T> extends true ? never : UnionToIntersection<T extends any ? () => T : never> extends (() => (infer R)) ? R : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/union-to-tuple.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/union-to-tuple.d.ts
 /**
 Convert a union type into an unordered tuple type of its elements.
 
@@ -2826,11 +2929,10 @@ const petList = Object.keys(pets) as UnionToTuple<Pet>;
 
 @category Array
 */
-type UnionToTuple<Union> = _UnionToTuple<Union> extends infer Result extends UnknownArray ? Result : never;
-// Nudges the compiler that `UnionToTuple` always yields an array.
+type UnionToTuple<Union> = _UnionToTuple<Union> extends (infer Result extends UnknownArray) ? Result : never; // Nudges the compiler that `UnionToTuple` always yields an array.
 type _UnionToTuple<Union, Accumulator extends UnknownArray = [], Member = UnionMember<Union>> = IsNever<Union> extends true ? Accumulator : _UnionToTuple<ExcludeExactly<Union, Member>, [Member, ...Accumulator]>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/set-optional.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/set-optional.d.ts
 /**
 Create a type that makes the given keys optional, while keeping the remaining keys as is.
 
@@ -2854,11 +2956,13 @@ type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
 */
 type SetOptional<BaseType, Keys extends keyof BaseType> = (BaseType extends ((...arguments_: never) => any) ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetOptional<BaseType, Keys>;
 type _SetOptional<BaseType, Keys extends keyof BaseType> = BaseType extends unknown // To distribute `BaseType` when it's a union type.
-? Simplify< // Pick just the keys that are readonly from the base type.
-Except<BaseType, Keys> // Pick the keys that should be mutable from the base type and make them mutable.
-& Partial<HomomorphicPick<BaseType, Keys>>> : never;
+ ? Simplify<
+// Pick just the keys that are readonly from the base type.
+Except<BaseType, Keys> &
+// Pick the keys that should be mutable from the base type and make them mutable.
+Partial<HomomorphicPick<BaseType, Keys>>> : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/value-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/value-of.d.ts
 /**
 Create a union of the given object's values, and optionally specify which keys to get the values from.
 
@@ -2882,7 +2986,7 @@ type C = ValueOf<{id: number; name: string; active: boolean}, 'id' | 'name'>;
 */
 type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/split.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/split.d.ts
 /**
 Split options.
 
@@ -2890,21 +2994,27 @@ Split options.
 */
 type SplitOptions = {
   /**
-  When enabled, instantiations with non-literal string types (e.g., `string`, `Uppercase<string>`, `on${string}`) simply return back `string[]` without performing any splitting, as the exact structure cannot be statically determined.
-  	@default true
-  	@example
-  ```ts
-  import type {Split} from 'type-fest';
-  	type Example1 = Split<`foo.${string}.bar`, '.', {strictLiteralChecks: false}>;
-  //=> ['foo', string, 'bar']
-  	type Example2 = Split<`foo.${string}`, '.', {strictLiteralChecks: true}>;
-  //=> string[]
-  	type Example3 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: false}>;
-  //=> ['foo', 'r', 'z']
-  	type Example4 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: true}>;
-  //=> string[]
-  ```
-  */
+	When enabled, instantiations with non-literal string types (e.g., `string`, `Uppercase<string>`, `on${string}`) simply return back `string[]` without performing any splitting, as the exact structure cannot be statically determined.
+
+	@default true
+
+	@example
+	```ts
+	import type {Split} from 'type-fest';
+
+	type Example1 = Split<`foo.${string}.bar`, '.', {strictLiteralChecks: false}>;
+	//=> ['foo', string, 'bar']
+
+	type Example2 = Split<`foo.${string}`, '.', {strictLiteralChecks: true}>;
+	//=> string[]
+
+	type Example3 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: false}>;
+	//=> ['foo', 'r', 'z']
+
+	type Example4 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: true}>;
+	//=> string[]
+	```
+	*/
   strictLiteralChecks?: boolean;
 };
 type DefaultSplitOptions = {
@@ -2933,13 +3043,15 @@ const array: Item[] = split(items, ',');
 */
 type Split<S extends string, Delimiter extends string, Options extends SplitOptions = {}> = SplitHelper<S, Delimiter, ApplyDefaultOptions<SplitOptions, DefaultSplitOptions, Options>>;
 type SplitHelper<S extends string, Delimiter extends string, Options extends Required<SplitOptions>, Accumulator extends string[] = []> = S extends string // For distributing `S`
-? Delimiter extends string // For distributing `Delimiter`
+ ? Delimiter extends string // For distributing `Delimiter`
+ ?
 // If `strictLiteralChecks` is `false` OR `S` and `Delimiter` both are string literals, then perform the split
-? Or<Not<Options['strictLiteralChecks']>, And<IsStringLiteral<S>, IsStringLiteral<Delimiter>>> extends true ? S extends `${infer Head}${Delimiter}${infer Tail}` ? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]> : Delimiter extends '' ? S extends '' ? Accumulator : [...Accumulator, S] : [...Accumulator, S] // Otherwise, return `string[]`
-: string[] : never // Should never happen
-: never; // Should never happen
+Or<Not<Options['strictLiteralChecks']>, And<IsStringLiteral<S>, IsStringLiteral<Delimiter>>> extends true ? S extends `${infer Head}${Delimiter}${infer Tail}` ? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]> : Delimiter extends '' ? S extends '' ? Accumulator : [...Accumulator, S] : [...Accumulator, S] :
+// Otherwise, return `string[]`
+string[] : never // Should never happen
+ : never; // Should never happen
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/replace.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/replace.d.ts
 type ReplaceOptions = {
   all?: boolean;
 };
@@ -3001,8 +3113,8 @@ replaceAll('My Cool Title', ' ', '');
 */
 type Replace<Input extends string, Search extends string, Replacement extends string, Options extends ReplaceOptions = {}> = _Replace<Input, Search, Replacement, ApplyDefaultOptions<ReplaceOptions, DefaultReplaceOptions, Options>>;
 type _Replace<Input extends string, Search extends string, Replacement extends string, Options extends Required<ReplaceOptions>, Accumulator extends string = ''> = Search extends string // For distributing `Search`
-? Replacement extends string // For distributing `Replacement`
-? Input extends `${infer Head}${Search}${infer Tail}` ? Options['all'] extends true ? _Replace<Tail, Search, Replacement, Options, `${Accumulator}${Head}${Replacement}`> : `${Head}${Replacement}${Tail}` : `${Accumulator}${Input}` : never : never;
+ ? Replacement extends string // For distributing `Replacement`
+ ? Input extends `${infer Head}${Search}${infer Tail}` ? Options['all'] extends true ? _Replace<Tail, Search, Replacement, Options, `${Accumulator}${Head}${Replacement}`> : `${Head}${Replacement}${Tail}` : `${Accumulator}${Input}` : never : never;
 //#endregion
 //#region ../../node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/List.d.ts
 /**
@@ -3345,7 +3457,7 @@ declare type Tail$1<L extends List> = L extends readonly [] ? L : L extends read
  * ```ts
  * ```
  */
-declare type Overwrite<O extends object, O1 extends object> = { [K in keyof O]: K extends keyof O1 ? O1[K] : O[K] } & {};
+declare type Overwrite<O extends object, O1 extends object> = { [K in keyof O]: K extends keyof O1 ? O1[K] : O[K]; } & {};
 //#endregion
 //#region ../../node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/_Internal.d.ts
 /**
@@ -3414,7 +3526,7 @@ declare type __Drop<L extends List, N extends Iteration, way extends Way> = {
 /**
  * @hidden
  */
-declare type _Drop<L extends List, N extends number, way extends Way = '->'> = __Drop<Naked<L>, IterationOf<N>, way> extends infer X ? Cast<X, List> : never;
+declare type _Drop<L extends List, N extends number, way extends Way = '->'> = __Drop<Naked<L>, IterationOf<N>, way> extends (infer X) ? Cast<X, List> : never;
 /**
  * Remove `N` entries out of `L`
  * @param L to remove from
@@ -3454,7 +3566,7 @@ declare type __Take<L extends List, N extends Iteration, way extends Way> = {
 /**
  * @hidden
  */
-declare type _Take<L extends List, N extends number, way extends Way = '->'> = __Take<L, IterationOf<N>, way> extends infer X ? Cast<X, List> : never;
+declare type _Take<L extends List, N extends number, way extends Way = '->'> = __Take<L, IterationOf<N>, way> extends (infer X) ? Cast<X, List> : never;
 /**
  * Extract `N` entries out of `L`
  * @param L to extract from
@@ -3470,16 +3582,16 @@ declare type Take<L extends List, N extends number, way extends Way = '->'> = L
 //#region src/object/index.type.d.ts
 type Range<Start extends number, End extends number> = Exclude<keyof TupleOf<End>, keyof TupleOf<Start>>;
 type AnyArray<A = any> = readonly A[];
-type TupleToEntries<A extends readonly unknown[]> = If<IsAny<A>, unknown, { [Key in keyof A]: [Key, A[Key]] }>;
+type TupleToEntries<A extends readonly unknown[]> = If<IsAny<A>, unknown, { [Key in keyof A]: [Key, A[Key]]; }>;
 type Groups<L extends AnyArray, LN extends AnyArray = [], D extends number[] = []> = D["length"] extends 40 ? LN : {
   0: Groups<Drop<L, 1>, Append<LN, [`${LN["length"]}`, Take<L, 1>]>, [...D, 0]>;
   1: LN;
 }[Extends<L, AnyArray<never>>];
-type TupleToGroups<L extends AnyArray> = Groups<L> extends infer X ? Cast<X, AnyArray> : never;
-type Crush<T> = T extends readonly (infer U)[] ? Record<string, U extends object ? unknown : U> : Simplify<UnionToIntersection<keyof T extends infer Prop ? Prop extends keyof T ? T[Prop] extends infer Value ? ([Extract<Value, object>] extends [never] ? never : Record<string, unknown>) | ([Exclude<Value, object>] extends [never] ? never : [Extract<Value, object>] extends [never] ? { [P in Prop]: Value } : Record<string, unknown>) : never : never : never>>;
+type TupleToGroups<L extends AnyArray> = Groups<L> extends (infer X) ? Cast<X, AnyArray> : never;
+type Crush<T> = T extends readonly (infer U)[] ? Record<string, U extends object ? unknown : U> : Simplify<UnionToIntersection<keyof T extends (infer Prop) ? Prop extends keyof T ? T[Prop] extends (infer Value) ? ([Extract<Value, object>] extends [never] ? never : Record<string, unknown>) | ([Exclude<Value, object>] extends [never] ? never : [Extract<Value, object>] extends [never] ? { [P in Prop]: Value; } : Record<string, unknown>) : never : never : never>>;
 type IntersectOf<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-type ComputeRaw<A> = A extends AnyFunction ? A : { [K in keyof A]: A[K] } & unknown;
-type _Invert<O extends Record<PropertyKey, PropertyKey>> = ComputeRaw<IntersectOf<{ [K in keyof O]: Record<O[K], K> }[keyof O]>>;
+type ComputeRaw<A> = A extends AnyFunction ? A : { [K in keyof A]: A[K]; } & unknown;
+type _Invert<O extends Record<PropertyKey, PropertyKey>> = ComputeRaw<IntersectOf<{ [K in keyof O]: Record<O[K], K>; }[keyof O]>>;
 type Invert<O extends Record<keyof O, PropertyKey>> = O extends unknown ? _Invert<O> : never;
 //#endregion
 //#region src/object/objectUtil.d.ts