@esposter/shared 4.1.1 → 4.2.0

package/dist/index.d.ts

@@ -1,2387 +0,0 @@
-import { z } from "zod";
-import { Result, ResultAsync } from "neverthrow";
-import { HTMLElement } from "node-html-parser";
-import { DefaultTreeAdapterTypes, html as html$1 } from "parse5";
-//#region src/models/error/ForbiddenError.d.ts
-export declare class ForbiddenError extends Error {
-  constructor(message: string);
-}
-//#endregion
-//#region src/models/shared/Operation.d.ts
-export declare enum Operation {
-  Create = "Create",
-  Delete = "Delete",
-  Push = "Push",
-  Read = "Read",
-  Unshift = "Unshift",
-  Update = "Update"
-}
-//#endregion
-//#region src/models/error/InvalidOperationError.d.ts
-export declare class InvalidOperationError extends Error {
-  constructor(operation: Operation, name: string, message: string);
-}
-//#endregion
-//#region src/models/error/NotFoundError.d.ts
-export declare class NotFoundError<T extends string = string> extends Error {
-  constructor(name: T, id: string);
-}
-//#endregion
-//#region src/models/error/NotInitializedError.d.ts
-export declare class NotInitializedError<T extends string = string> extends Error {
-  constructor(name: T);
-}
-//#endregion
-//#region src/models/error/WordFilteredError.d.ts
-export declare class WordFilteredError extends Error {
-  constructor(message: string);
-}
-//#endregion
-//#region src/models/eventEmitter/EventListenerEntry.d.ts
-export interface EventListenerEntry<TEventMap> {
-  isOnce: boolean;
-  listener: TEventMap[keyof TEventMap];
-}
-//#endregion
-//#region src/models/eventEmitter/EventListenerMap.d.ts
-export type EventListenerMap<TEventMap> = { [TEvent in keyof TEventMap]: (...args: never[]) => void; };
-//#endregion
-//#region src/models/eventEmitter/TypedEventEmitter.d.ts
-export declare class TypedEventEmitter<TEventMap extends EventListenerMap<TEventMap>> {
-  #private;
-  emit<TEvent extends keyof TEventMap>(event: TEvent, ...args: Parameters<TEventMap[TEvent]>): boolean;
-  off<TEvent extends keyof TEventMap>(event: TEvent, listener: TEventMap[TEvent]): void;
-  on<TEvent extends keyof TEventMap>(event: TEvent, listener: TEventMap[TEvent]): void;
-  once<TEvent extends keyof TEventMap>(event: TEvent, listener: TEventMap[TEvent]): void;
-  removeAllListeners(event?: keyof TEventMap): void;
-}
-//#endregion
-//#region src/models/indexedDb/DatabaseStoreSchema.d.ts
-export interface DatabaseStoreSchema {
-  indexes: Record<string, IDBValidKey>;
-  key: IDBValidKey;
-  value: unknown;
-}
-//#endregion
-//#region src/models/indexedDb/DatabaseSchema.d.ts
-export type DatabaseSchema = Record<string, DatabaseStoreSchema>;
-//#endregion
-//#region src/models/indexedDb/DatabaseStoreName.d.ts
-export type DatabaseStoreName<TSchema extends DatabaseSchema> = [LiteralKeys<TSchema>] extends [never] ? string : LiteralKeys<TSchema>;
-type LiteralKeys<TSchema> = keyof { [TKey in keyof TSchema as string extends TKey ? never : TKey]: TKey; } & string;
-//#endregion
-//#region src/models/indexedDb/DatabaseIndexName.d.ts
-export type DatabaseIndexName<TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>> = string extends keyof TSchema[TStoreName]["indexes"] ? string : keyof TSchema[TStoreName]["indexes"] & string;
-//#endregion
-//#region src/models/indexedDb/DatabaseIndexCreator.d.ts
-export interface DatabaseIndexCreator<TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>> {
-  createIndex: (name: DatabaseIndexName<TSchema, TStoreName>, keyPath: string | string[], options?: IDBIndexParameters) => void;
-}
-//#endregion
-//#region src/models/indexedDb/DatabaseIndexKey.d.ts
-export type DatabaseIndexKey<TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>, TIndexName extends DatabaseIndexName<TSchema, TStoreName>> = TSchema[TStoreName]["indexes"][TIndexName];
-//#endregion
-//#region src/models/indexedDb/DatabaseIndex.d.ts
-export interface DatabaseIndex<TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>, TIndexName extends DatabaseIndexName<TSchema, TStoreName>> {
-  getAll: (query?: DatabaseIndexKey<TSchema, TStoreName, TIndexName> | IDBKeyRange | null, count?: number) => Promise<TSchema[TStoreName]["value"][]>;
-  getAllKeys: (query?: DatabaseIndexKey<TSchema, TStoreName, TIndexName> | IDBKeyRange | null, count?: number) => Promise<TSchema[TStoreName]["key"][]>;
-}
-//#endregion
-//#region src/models/indexedDb/DatabaseObjectStoreReader.d.ts
-export interface DatabaseObjectStoreReader<TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>> {
-  get: (key: TSchema[TStoreName]["key"]) => Promise<TSchema[TStoreName]["value"] | undefined>;
-  getAll: (query?: IDBKeyRange | null | TSchema[TStoreName]["key"], count?: number) => Promise<TSchema[TStoreName]["value"][]>;
-  getAllKeys: (query?: IDBKeyRange | null | TSchema[TStoreName]["key"], count?: number) => Promise<TSchema[TStoreName]["key"][]>;
-  index: <TIndexName extends DatabaseIndexName<TSchema, TStoreName>>(name: TIndexName) => DatabaseIndex<TSchema, TStoreName, TIndexName>;
-}
-//#endregion
-//#region src/models/indexedDb/DatabaseObjectStoreWriter.d.ts
-export interface DatabaseObjectStoreWriter<TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>> {
-  delete: (query: IDBKeyRange | TSchema[TStoreName]["key"]) => Promise<void>;
-  put: (value: TSchema[TStoreName]["value"], key?: TSchema[TStoreName]["key"]) => Promise<TSchema[TStoreName]["key"]>;
-}
-//#endregion
-//#region src/models/indexedDb/DatabaseObjectStore.d.ts
-export type DatabaseObjectStore<TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>, TMode extends IDBTransactionMode> = DatabaseObjectStoreReader<TSchema, TStoreName> & (TMode extends "readonly" ? unknown : DatabaseObjectStoreWriter<TSchema, TStoreName> & (TMode extends "versionchange" ? DatabaseIndexCreator<TSchema, TStoreName> : unknown));
-//#endregion
-//#region src/models/indexedDb/DatabaseTransaction.d.ts
-export interface DatabaseTransaction<TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>, TMode extends IDBTransactionMode> {
-  done: Promise<void>;
-  objectStore: <TName extends TStoreName>(name: TName) => DatabaseObjectStore<TSchema, TName, TMode>;
-}
-//#endregion
-//#region src/models/indexedDb/Database.d.ts
-export interface Database<TSchema extends DatabaseSchema = DatabaseSchema> {
-  close: () => void;
-  delete: <TStoreName extends DatabaseStoreName<TSchema>>(storeName: TStoreName, query: IDBKeyRange | TSchema[TStoreName]["key"]) => Promise<void>;
-  get: <TStoreName extends DatabaseStoreName<TSchema>>(storeName: TStoreName, key: TSchema[TStoreName]["key"]) => Promise<TSchema[TStoreName]["value"] | undefined>;
-  getAll: <TStoreName extends DatabaseStoreName<TSchema>>(storeName: TStoreName, query?: IDBKeyRange | null | TSchema[TStoreName]["key"], count?: number) => Promise<TSchema[TStoreName]["value"][]>;
-  getAllKeys: <TStoreName extends DatabaseStoreName<TSchema>>(storeName: TStoreName, query?: IDBKeyRange | null | TSchema[TStoreName]["key"], count?: number) => Promise<TSchema[TStoreName]["key"][]>;
-  readonly name: string;
-  put: <TStoreName extends DatabaseStoreName<TSchema>>(storeName: TStoreName, value: TSchema[TStoreName]["value"], key?: TSchema[TStoreName]["key"]) => Promise<TSchema[TStoreName]["key"]>;
-  transaction: <TStoreName extends DatabaseStoreName<TSchema>, TMode extends IDBTransactionMode = "readonly">(storeNames: readonly TStoreName[] | TStoreName, mode?: TMode, options?: IDBTransactionOptions) => DatabaseTransaction<TSchema, TStoreName, TMode>;
-}
-//#endregion
-//#region src/models/indexedDb/UpgradeDatabase.d.ts
-export interface UpgradeDatabase<TSchema extends DatabaseSchema = DatabaseSchema> extends Database<TSchema> {
-  createObjectStore: <TStoreName extends DatabaseStoreName<TSchema>>(name: TStoreName, options?: IDBObjectStoreParameters) => DatabaseObjectStore<TSchema, TStoreName, "versionchange">;
-}
-//#endregion
-//#region src/models/indexedDb/DatabaseOpenOptions.d.ts
-export interface DatabaseOpenOptions<TSchema extends DatabaseSchema = DatabaseSchema> {
-  blocked?: (currentVersion: number, blockedVersion: null | number) => void;
-  blocking?: (currentVersion: number, blockedVersion: null | number) => void;
-  terminated?: () => void;
-  upgrade?: (database: UpgradeDatabase<TSchema>, oldVersion: number, newVersion: null | number, transaction: DatabaseTransaction<TSchema, DatabaseStoreName<TSchema>, "versionchange">) => void;
-}
-//#endregion
-//#region src/models/message/MentionType.d.ts
-export declare enum MentionType {
-  Role = "role",
-  User = "user"
-}
-//#endregion
-//#region src/models/mime/MimeDatabaseEntry.d.ts
-export interface MimeDatabaseEntry {
-  charset?: string;
-  compressible?: boolean;
-  extensions?: string[];
-  source?: string;
-}
-//#endregion
-//#region src/models/object/ObjectMethod.d.ts
-export declare enum ObjectMethod {
-  ToString = "toString",
-  ValueOf = "valueOf"
-}
-//#endregion
-//#region src/models/profanity/ProfanityOptions.d.ts
-export interface ProfanityOptions {
-  isWholeWord: boolean;
-}
-//#endregion
-//#region src/models/reactivity/MaybeReactive.d.ts
-export interface MaybeReactive {
-  __v_raw?: unknown;
-}
-//#endregion
-//#region src/models/router/RoutePath.d.ts
-export declare const RoutePath: {
-  readonly About: "/about";
-  readonly Achievements: "/achievements";
-  readonly Anime: "/anime";
-  readonly Calls: (id: string) => string;
-  readonly CallsIndex: "/calls";
-  readonly Clicker: "/clicker";
-  readonly Docs: "/docs";
-  readonly Dungeons: "/dungeons";
-  readonly FluidSimulator: "/fluid-simulator";
-  readonly Genshin: "/genshin";
-  readonly Github: "https://github.com/Esposter/Esposter";
-  readonly Index: "/";
-  readonly Login: "/login";
-  readonly Messages: (id: string) => string;
-  readonly MessagesDraftsAndSent: "/messages/draftsandsent";
-  readonly MessagesFriends: "/messages/friends";
-  readonly MessagesIndex: "/messages";
-  readonly MessagesInvite: (code: string) => string;
-  readonly MessagesMessage: (id: string, rowKey: string) => string;
-  readonly MessagesThread: (id: string, rowKey: string) => string;
-  readonly Post: (id: string) => string;
-  readonly PostCreate: "/post/create";
-  readonly PostUpdate: (id: string) => string;
-  readonly PrivacyPolicy: "/privacy-policy";
-  readonly Resource: (id: string) => string;
-  readonly ResourceExplorer: "/resource-explorer";
-  readonly ResourceExplorerAll: "/resource-explorer/all";
-  readonly ResourceExplorerCreate: "/resource-explorer/create";
-  readonly ResourceExplorerCreateType: (type: string) => string;
-  readonly ResourceExplorerFavorites: "/resource-explorer/favorites";
-  readonly ResourceExplorerRecents: "/resource-explorer/recents";
-  readonly ResourceExplorerRecycleBin: "/resource-explorer/recycle-bin";
-  readonly ResourceExplorerTags: "/resource-explorer/tags";
-  readonly ResourceItems: (id: string) => string;
-  readonly User: (id: string) => string;
-  readonly UserSettings: "/user/settings";
-  readonly View: (type: string, id: string) => string;
-};
-export type RoutePath = typeof RoutePath;
-//#endregion
-//#region src/models/sanitizeHtml/AttributesTransformer.d.ts
-export type AttributesTransformer = (attributes: Record<string, string>) => Record<string, string>;
-//#endregion
-//#region src/models/sanitizeHtml/SanitizeHtmlOptions.d.ts
-export interface SanitizeHtmlOptions {
-  allowedAttributes?: Record<string, string[]>;
-  allowedClasses?: Record<string, string[]>;
-  allowedStyles?: Record<string, Record<string, RegExp[]>>;
-  allowedTags?: string[];
-  transformAttributes?: Record<string, AttributesTransformer>;
-}
-//#endregion
-//#region src/models/sanitizeHtml/SanitizePolicy.d.ts
-export interface SanitizePolicy {
-  allowedAttributes: Record<string, string[]>;
-  allowedClasses: Record<string, string[]>;
-  allowedSchemes: string[];
-  allowedStyles: Record<string, Record<string, RegExp[]>>;
-  allowedTags: string[];
-  transformAttributes: Record<string, AttributesTransformer>;
-}
-//#endregion
-//#region src/models/shared/ItemEntityType.d.ts
-export interface ItemEntityType<T extends string> {
-  type: T;
-}
-export declare const createItemEntityTypeSchema: <T extends z.ZodType<string>>(schema: T) => z.ZodObject<{
-  type: T;
-}>;
-//#endregion
-//#region src/models/shared/ItemMetadata.d.ts
-export declare class ItemMetadata {
-  createdAt: Date;
-  deletedAt: Date | null;
-  updatedAt: Date;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/primitive.d.ts
-/**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-
-@category Type
-*/
-type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/basic.d.ts
-/**
-Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
-
-@category Class
-*/
-type Class<T, Arguments extends unknown[] = any[]> = {
-  prototype: Pick<T, keyof T>;
-  new (...arguments_: Arguments): T;
-};
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/union-to-intersection.d.ts
-/**
-Convert a union type to an intersection type.
-
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
-
-type Intersection = UnionToIntersection<Union>;
-//=> {the(): void} & {great(arg: string): void} & {escape: boolean}
-```
-
-@category Type
-*/
-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
-// of function arguments is an intersection.
-(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;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.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.
-
-Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
-
-@link https://stackoverflow.com/a/49402091
-
-@example
-```
-import type {KeysOfUnion} from 'type-fest';
-
-type A = {
-	common: string;
-	a: number;
-};
-
-type B = {
-	common: string;
-	b: string;
-};
-
-type C = {
-	common: string;
-	c: boolean;
-};
-
-type Union = A | B | C;
-
-type CommonKeys = keyof Union;
-//=> 'common'
-
-type AllKeys = KeysOfUnion<Union>;
-//=> 'common' | 'a' | 'b' | 'c'
-```
-
-@category Object
-*/
-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.10.0/node_modules/type-fest/source/is-any.d.ts
-/**
-Returns a boolean for whether the given type is `any`.
-
-@link https://stackoverflow.com/a/49928360/1490091
-
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
-
-@example
-```
-import type {IsAny} from 'type-fest';
-
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
-
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
-	return object[key];
-}
-
-const typedA = get(typedObject, 'a');
-//=> 1
-
-const anyA = get(anyObject, 'a');
-//=> any
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.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.
-
-This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
-
-@example
-```
-import type {IsOptionalKeyOf} from 'type-fest';
-
-type User = {
-	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-};
-
-type Admin = {
-	name: string;
-	surname?: string;
-};
-
-type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
-//=> true
-
-type T2 = IsOptionalKeyOf<User, 'name'>;
-//=> false
-
-type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
-//=> boolean
-
-type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
-//=> false
-
-type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
-//=> boolean
-```
-
-@category Type Guard
-@category Utilities
-*/
-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.10.0/node_modules/type-fest/source/optional-keys-of.d.ts
-/**
-Extract all optional keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the optional keys only.
-
-@example
-```
-import type {OptionalKeysOf, Except} from 'type-fest';
-
-type User = {
-	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-};
-
-const REMOVE_FIELD = Symbol('remove field symbol');
-type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
-	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
-};
-
-const update1: UpdateOperation<User> = {
-	name: 'Alice',
-};
-
-const update2: UpdateOperation<User> = {
-	name: 'Bob',
-	luckyNumber: REMOVE_FIELD,
-};
-```
-
-@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; // Should never happen
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/required-keys-of.d.ts
-/**
-Extract all required keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
-
-@example
-```
-import type {RequiredKeysOf} from 'type-fest';
-
-declare function createValidation<
-	Entity extends object,
-	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
->(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;
-
-type User = {
-	name: string;
-	surname: string;
-	luckyNumber?: number;
-};
-
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
-
-// @ts-expect-error
-const validator3 = createValidation<User>('luckyNumber', value => value > 0);
-// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
-```
-
-@category Utilities
-*/
-type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
- ? Exclude<keyof Type, OptionalKeysOf<Type>> : never; // Should never happen
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/is-never.d.ts
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-type A = IsNever<never>;
-//=> true
-
-type B = IsNever<any>;
-//=> false
-
-type C = IsNever<unknown>;
-//=> false
-
-type D = IsNever<never[]>;
-//=> false
-
-type E = IsNever<object>;
-//=> false
-
-type F = IsNever<string>;
-//=> false
-```
-
-@example
-```
-import type {IsNever} from 'type-fest';
-
-type IsTrue<T> = T extends true ? true : false;
-
-// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
-type A = IsTrue<never>;
-//=> never
-
-// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
-type IsTrueFixed<T> =
-	IsNever<T> extends true ? false : T extends true ? true : false;
-
-type B = IsTrueFixed<never>;
-//=> false
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNever<T> = [T] extends [never] ? true : false;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.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`.
-
-Use-cases:
-- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
-
-Note:
-- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
-- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
-
-@example
-```
-import type {If} from 'type-fest';
-
-type A = If<true, 'yes', 'no'>;
-//=> 'yes'
-
-type B = If<false, 'yes', 'no'>;
-//=> 'no'
-
-type C = If<boolean, 'yes', 'no'>;
-//=> 'yes' | 'no'
-
-type D = If<any, 'yes', 'no'>;
-//=> 'yes' | 'no'
-
-type E = If<never, 'yes', 'no'>;
-//=> 'no'
-```
-
-@example
-```
-import type {If, IsAny, IsNever} from 'type-fest';
-
-type A = If<IsAny<unknown>, 'is any', 'not any'>;
-//=> 'not any'
-
-type B = If<IsNever<never>, 'is never', 'not never'>;
-//=> 'is never'
-```
-
-@example
-```
-import type {If, IsEqual} from 'type-fest';
-
-type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
-
-type A = IfEqual<string, string, 'equal', 'not equal'>;
-//=> 'equal'
-
-type B = IfEqual<string, number, 'equal', 'not equal'>;
-//=> 'not equal'
-```
-
-Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
-
-@example
-```
-import type {If, IsEqual, StringRepeat} from 'type-fest';
-
-type HundredZeroes = StringRepeat<'0', 100>;
-
-// The following implementation is not tail recursive
-type Includes<S extends string, Char extends string> =
-	S extends `${infer First}${infer Rest}`
-		? If<IsEqual<First, Char>,
-			'found',
-			Includes<Rest, Char>>
-		: 'not found';
-
-// Hence, instantiations with long strings will fail
-// @ts-expect-error
-type Fails = Includes<HundredZeroes, '1'>;
-//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Error: Type instantiation is excessively deep and possibly infinite.
-
-// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
-type IncludesWithoutIf<S extends string, Char extends string> =
-	S extends `${infer First}${infer Rest}`
-		? IsEqual<First, Char> extends true
-			? 'found'
-			: IncludesWithoutIf<Rest, Char>
-		: 'not found';
-
-// Now, instantiations with long strings will work
-type Works = IncludesWithoutIf<HundredZeroes, '1'>;
-//=> 'not found'
-```
-
-@category Type Guard
-@category Utilities
-*/
-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.10.0/node_modules/type-fest/source/unknown-array.d.ts
-/**
-Represents an array with `unknown` value.
-
-Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
-
-@example
-```
-import type {UnknownArray} from 'type-fest';
-
-type IsArray<T> = T extends UnknownArray ? true : false;
-
-type A = IsArray<['foo']>;
-//=> true
-
-type B = IsArray<readonly number[]>;
-//=> true
-
-type C = IsArray<string>;
-//=> false
-```
-
-@category Type
-@category Array
-*/
-type UnknownArray = readonly unknown[];
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/internal/type.d.ts
-/**
-Returns a boolean for whether A is false.
-
-@example
-```
-type A = Not<true>;
-//=> false
-
-type B = Not<false>;
-//=> true
-```
-*/
-type Not<A extends boolean> = A extends true ? false : A extends false ? true : never;
-/**
-An if-else-like type that resolves depending on whether the given type is `any` or `never`.
-
-@example
-```
-// 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, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
-//=> 'IS_ANY'
-
-// When `T` is `never` => Returns `IfNever` branch
-type C = IfNotAnyOrNever<never, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
-//=> 'IS_NEVER'
-```
-
-Note: Wrapping a tail-recursive type with `IfNotAnyOrNever` makes the implementation non-tail-recursive. To fix this, move the recursion into a helper type. Refer to the following example:
-
-@example
-```ts
-import type {StringRepeat} from 'type-fest';
-
-type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;
-
-// The following implementation is not tail recursive
-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
-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, {ifNot: _TrimLeftOptimised<S>}>;
-
-type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;
-
-type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
-//=> ''
-```
-*/
-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.10.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.
-
-@example
-```
-type A = CollapseRestElement<[string, string, ...number[]]>;
-//=> [string, string, number]
-
-type B = CollapseRestElement<[...string[], number, number]>;
-//=> [string, number, number]
-
-type C = CollapseRestElement<[string, string, ...Array<number | bigint>]>;
-//=> [string, string, number | bigint]
-
-type D = CollapseRestElement<[string, number]>;
-//=> [string, number]
-```
-
-Note: Optional modifiers (`?`) are removed from elements unless the `exactOptionalPropertyTypes` compiler option is disabled. When disabled, there's an additional `| undefined` for optional elements.
-
-@example
-```
-// `exactOptionalPropertyTypes` enabled
-type A = CollapseRestElement<[string?, string?, ...number[]]>;
-//=> [string, string, number]
-
-// `exactOptionalPropertyTypes` disabled
-type B = CollapseRestElement<[string?, string?, ...number[]]>;
-//=> [string | undefined, string | undefined, number]
-```
-*/
-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`
- ? '0' extends keyof TArray ?
-// Enters this branch, if `TArray` starts with a non-rest element (e.g., `[string, number]` or `[string, ...number[]]`).
-TArray extends readonly [(infer First)?, ...infer Rest] ? _CollapseRestElement<Rest, [...ForwardAccumulator,
-// A tuple allows fewer than one element only when its first element is optional. Written in exactly this shape because equivalent ones, such as `[] extends TArray`, are several times slower.
-TArray extends readonly [unknown, ...unknown[]] ? First : If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
-], BackwardAccumulator> : never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
- :
-// 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.
- : never; // Should never happen
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/internal/characters.d.ts
-type Whitespace = '\t' // '\t'
- | '\n' // '\n'
- | '\v' // '\v'
- | '\f' // '\f'
- | '\r' // '\r'
- | ' ' // ' '
- | '…' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | '
' | '
' | ' ' | ' ' | '　' | '';
-type WordSeparators = '-' | '_' | Whitespace;
-type AsciiPunctuation = '!' | '"' | '#' | '$' | '%' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | '[' | '\\' | ']' | '^' | '_' | '`' | '{' | '|' | '}' | '~';
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.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.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-type PositionProps = {
-	top: number;
-	left: number;
-};
-
-type SizeProps = {
-	width: number;
-	height: number;
-};
-
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
-```
-
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
-
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-}
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-declare function fn(object: Record<string, unknown>): void;
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-// @ts-expect-error
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see {@link SimplifyDeep}
-@category Object
-*/
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/is-equal.d.ts
-/**
-Returns a boolean for whether the two given types are equal.
-
-@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
-@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
-
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
-
-@example
-```
-import type {IsEqual} from 'type-fest';
-
-// This type returns a boolean for whether the given array includes the given item.
-// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
-type Includes<Value extends readonly any[], Item> =
-	Value extends readonly [Value[0], ...infer rest]
-		? IsEqual<Value[0], Item> extends true
-			? true
-			: Includes<rest, Item>
-		: false;
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : 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.10.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.
-
-This is the counterpart of `PickIndexSignature`.
-
-Use-cases:
-- Remove overly permissive signatures from third-party types.
-
-This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
-
-It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
-
-(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
-
-```
-const indexed: Record<string, unknown> = {}; // Allowed
-
-// @ts-expect-error
-const keyed: Record<'foo', unknown> = {}; // Error
-// TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
-```
-
-Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
-
-```
-type Indexed = {} extends Record<string, unknown>
-	? '✅ `{}` is assignable to `Record<string, unknown>`'
-	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
-
-type IndexedResult = Indexed;
-//=> '✅ `{}` is assignable to `Record<string, unknown>`'
-
-type Keyed = {} extends Record<'foo' | 'bar', unknown>
-	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
-	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
-
-type KeyedResult = Keyed;
-//=> '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`'
-```
-
-Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
-
-```
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
-	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
-};
-```
-
-...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
-
-```
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType
-	// Is `{}` assignable to `Record<KeyType, unknown>`?
-	as {} extends Record<KeyType, unknown>
-		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
-		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
-	]: ObjectType[KeyType];
-};
-```
-
-If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
-
-@example
-```
-import type {OmitIndexSignature} from 'type-fest';
-
-type Example = {
-	// These index signatures will be removed.
-	[x: string]: any;
-	[x: number]: any;
-	[x: symbol]: any;
-	[x: `head-${string}`]: string;
-	[x: `${string}-tail`]: string;
-	[x: `head-${string}-tail`]: string;
-	[x: `${bigint}`]: string;
-	[x: `embedded-${number}`]: string;
-
-	// These explicitly defined keys will remain.
-	foo: 'bar';
-	qux?: 'baz';
-};
-
-type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
-//=> {foo: 'bar'; qux?: 'baz'}
-```
-
-@see {@link PickIndexSignature}
-@category Object
-*/
-type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType]; };
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.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.
-
-This is the counterpart of `OmitIndexSignature`.
-
-@example
-```
-import type {PickIndexSignature} from 'type-fest';
-
-declare const symbolKey: unique symbol;
-
-type Example = {
-	// These index signatures will remain.
-	[x: string]: unknown;
-	[x: number]: unknown;
-	[x: symbol]: unknown;
-	[x: `head-${string}`]: string;
-	[x: `${string}-tail`]: string;
-	[x: `head-${string}-tail`]: string;
-	[x: `${bigint}`]: string;
-	[x: `embedded-${number}`]: string;
-
-	// These explicitly defined keys will be removed.
-	['kebab-case-key']: string;
-	[symbolKey]: string;
-	foo: 'bar';
-	qux?: 'baz';
-};
-
-type ExampleIndexSignature = PickIndexSignature<Example>;
-// {
-// 	[x: string]: unknown;
-// 	[x: number]: unknown;
-// 	[x: symbol]: unknown;
-// 	[x: `head-${string}`]: string;
-// 	[x: `${string}-tail`]: string;
-// 	[x: `head-${string}-tail`]: string;
-// 	[x: `${bigint}`]: string;
-// 	[x: `embedded-${number}`]: string;
-// }
-```
-
-@see {@link OmitIndexSignature}
-@category Object
-*/
-type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType]; };
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.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>;
-/**
-Merge two types into a new type. Keys of the second type overrides keys of the first type.
-
-This is different from the TypeScript `&` (intersection) operator. With `&`, conflicting property types are intersected, which often results in `never`. For example, `{a: string} & {a: number}` makes `a` become `string & number`, which resolves to `never`. With `Merge`, the second type's keys cleanly override the first, so `Merge<{a: string}, {a: number}>` gives `{a: number}` as expected. `Merge` also produces a flattened type (via `Simplify`), making it more readable in IDE tooltips compared to `A & B`.
-
-@example
-```
-import type {Merge} from 'type-fest';
-
-type Foo = {
-	a: string;
-	b: number;
-};
-
-type Bar = {
-	a: number; // Conflicts with Foo['a']
-	c: boolean;
-};
-
-// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
-type WithIntersection = (Foo & Bar)['a'];
-//=> never
-
-// With `Merge`, `a` is cleanly overridden to `number`.
-type WithMerge = Merge<Foo, Bar>['a'];
-//=> number
-```
-
-@example
-```
-import type {Merge} from 'type-fest';
-
-type Foo = {
-	[x: string]: unknown;
-	[x: number]: unknown;
-	foo: string;
-	bar: symbol;
-};
-
-type Bar = {
-	[x: number]: number;
-	[x: symbol]: unknown;
-	bar: Date;
-	baz: boolean;
-};
-
-export type FooBar = Merge<Foo, Bar>;
-//=> {
-// 	[x: string]: unknown;
-// 	[x: number]: number;
-// 	[x: symbol]: unknown;
-// 	foo: string;
-// 	bar: Date;
-// 	baz: boolean;
-// }
-```
-
-Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or `Object.assign`, refer to the {@link ObjectMerge} type.
-
-@see {@link ObjectMerge}
-@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
-type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/trim.d.ts
-/**
-Remove spaces from the left side.
-*/
-type TrimLeft<V extends string> = V extends `${Whitespace}${infer R}` ? TrimLeft<R> : V;
-/**
-Remove spaces from the right side.
-*/
-type TrimRight<V extends string> = V extends `${infer R}${Whitespace}` ? TrimRight<R> : V;
-/**
-Remove leading and trailing spaces from a string.
-
-@example
-```
-import type {Trim} from 'type-fest';
-
-type Example = Trim<' foo '>;
-//=> 'foo'
-```
-
-@category String
-@category Template literal
-*/
-type Trim<V extends string> = TrimLeft<TrimRight<V>>;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.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
-	```
-	*/
-  strictNever?: boolean;
-};
-type DefaultSomeExtendOptions = {
-  strictNever: true;
-};
-/**
-Returns a boolean for whether some element in an array type extends another type.
-
-@example
-```
-import type {SomeExtend} from 'type-fest';
-
-type A = SomeExtend<['1', '2', 3], number>;
-//=> true
-
-type B = SomeExtend<[1, 2, 3], string>;
-//=> false
-
-type C = SomeExtend<[string, number | string], number>;
-//=> boolean
-
-type D = SomeExtend<[true, boolean, true], false>;
-//=> boolean
-```
-
-Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
-
-```
-// @exactOptionalPropertyTypes: true
-import type {SomeExtend} from 'type-fest';
-
-type A = SomeExtend<[1?, 2?, '3'?], string>;
-//=> true
-```
-
-```
-// @exactOptionalPropertyTypes: false
-import type {SomeExtend} from 'type-fest';
-
-type A = SomeExtend<[1?, 2?, '3'?], string>;
-//=> boolean
-
-type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
-//=> true
-```
-
-@see {@link SomeExtendOptions}
-
-@category Utilities
-@category Array
-*/
-type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> = IfNotAnyOrNever<CollapseRestElement<TArray>, {
-  ifNot: _SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
-  ifAny: false;
-  ifNever: false;
-}>;
-// Kept free of `IfNotAnyOrNever` so that it stays tail-recursive, which allows it to handle long arrays.
-type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = 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;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/or-all.d.ts
-/**
-Returns a boolean for whether any of the given elements is `true`.
-
-Use-cases:
-- Check if at least one condition in a list of booleans is met.
-
-@example
-```
-import type {OrAll} from 'type-fest';
-
-type FFT = OrAll<[false, false, true]>;
-//=> true
-
-type FFF = OrAll<[false, false, false]>;
-//=> false
-```
-
-Note: When `boolean` is passed as an element, it is distributed into separate cases, and the final result is a union of those cases.
-For example, `OrAll<[false, boolean]>` expands to `OrAll<[false, true]> | OrAll<[false, false]>`, which simplifies to `true | false` (i.e., `boolean`).
-
-@example
-```
-import type {OrAll} from 'type-fest';
-
-type A = OrAll<[false, boolean]>;
-//=> boolean
-
-type B = OrAll<[true, boolean]>;
-//=> true
-```
-
-Note: If `never` is passed as an element, it is treated as `false` and the result is computed accordingly.
-
-@example
-```
-import type {OrAll} from 'type-fest';
-
-type A = OrAll<[never, never, true]>;
-//=> true
-
-type B = OrAll<[never, never, false]>;
-//=> false
-
-type C = OrAll<[never, never, never]>;
-//=> false
-
-type D = OrAll<[never, never, boolean]>;
-//=> boolean
-```
-
-Note: If `any` is passed as an element, it is treated as `boolean` and the result is computed accordingly.
-
-@example
-```
-import type {OrAll} from 'type-fest';
-
-type A = OrAll<[false, any]>;
-//=> boolean
-
-type B = OrAll<[true, any]>;
-//=> true
-```
-
-Note: `OrAll<[]>` evaluates to `false` because there are no `true` elements in an empty tuple. See [Wikipedia: Clause (logic) > Empty clauses](https://en.wikipedia.org/wiki/Clause_(logic)#Empty_clauses:~:text=The%20truth%20evaluation%20of%20an%20empty%20disjunctive%20clause%20is%20always%20false.).
-
-@see {@link Or}
-@see {@link AndAll}
-*/
-type OrAll<T extends readonly boolean[]> = SomeExtend<T, true>;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/or.d.ts
-/**
-Returns a boolean for whether either of two given types is `true`.
-
-Use-case: Constructing complex conditional types where at least one condition must be satisfied.
-
-@example
-```
-import type {Or} from 'type-fest';
-
-type TT = Or<true, true>;
-//=> true
-
-type TF = Or<true, false>;
-//=> true
-
-type FT = Or<false, true>;
-//=> true
-
-type FF = Or<false, false>;
-//=> false
-```
-
-Note: When `boolean` is passed as an argument, it is distributed into separate cases, and the final result is a union of those cases.
-For example, `Or<false, boolean>` expands to `Or<false, true> | Or<false, false>`, which simplifies to `true | false` (i.e., `boolean`).
-
-@example
-```
-import type {Or} from 'type-fest';
-
-type A = Or<false, boolean>;
-//=> boolean
-
-type B = Or<boolean, false>;
-//=> boolean
-
-type C = Or<true, boolean>;
-//=> true
-
-type D = Or<boolean, true>;
-//=> true
-
-type E = Or<boolean, boolean>;
-//=> boolean
-```
-
-Note: If `never` is passed as an argument, it is treated as `false` and the result is computed accordingly.
-
-@example
-```
-import type {Or} from 'type-fest';
-
-type A = Or<true, never>;
-//=> true
-
-type B = Or<never, true>;
-//=> true
-
-type C = Or<false, never>;
-//=> false
-
-type D = Or<never, false>;
-//=> false
-
-type E = Or<boolean, never>;
-//=> boolean
-
-type F = Or<never, boolean>;
-//=> boolean
-
-type G = Or<never, never>;
-//=> false
-```
-
-@see {@link OrAll}
-@see {@link And}
-@see {@link Xor}
-*/
-type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/internal/string.d.ts
-/**
-Returns a boolean for whether the given string `S` starts with the given string `SearchString`.
-
-@example
-```
-type A = StartsWith<'abcde', 'abc'>;
-//=> true
-
-type B = StartsWith<'abcde', 'bc'>;
-//=> false
-
-type C = StartsWith<string, 'bc'>;
-//=> never
-
-type D = StartsWith<'abcde', string>;
-//=> never
-```
-
-@category String
-@category Template literal
-*/
-type StartsWith<S extends string, SearchString extends string> = string extends S | SearchString ? never : S extends `${SearchString}${infer T}` ? true : false;
-/**
-Returns a boolean for whether the string is numeric.
-
-This type is a workaround for [Microsoft/TypeScript#46109](https://github.com/microsoft/TypeScript/issues/46109#issuecomment-930307987).
-*/
-type IsNumeric<T extends string> = T extends `${number}` ? Trim<T> extends T ? true : false : false;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/internal/object.d.ts
-/**
-Merges user specified options with default options.
-
-@example
-```
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: true};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//=> {maxRecursionDepth: 10; leavesOnly: true}
-```
-
-@example
-```
-// Complains if default values are not provided for optional options
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
-```
-
-@example
-```
-// Complains if an option's default type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
-```
-
-@example
-```
-// Complains if an option's specified type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: 'yes'};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                                                   ~~~~~~~~~~~~~~~~
-// 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]; }>>>;
-/**
-Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
-
-Note: This doesn't collapse literals within tagged types. For example, `CollapseLiterals<Tagged<'foo' | (string & {}), 'Tag'>>` returns `("foo" & Tag<"Tag", never>) | (string & Tag<"Tag", never>)` and not `string & Tag<"Tag", never>`.
-
-Use-case: For collapsing unions created using {@link LiteralUnion}.
-
-@example
-```
-import type {LiteralUnion} from 'type-fest';
-
-type A = CollapseLiterals<'foo' | 'bar' | (string & {})>;
-//=> string
-
-type B = CollapseLiterals<LiteralUnion<1 | 2 | 3, number>>;
-//=> number
-
-type C = CollapseLiterals<LiteralUnion<'onClick' | 'onChange', `on${string}`>>;
-//=> `on${string}`
-
-type D = CollapseLiterals<'click' | 'change' | (`on${string}` & {})>;
-//=> 'click' | 'change' | `on${string}`
-
-type E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined>;
-//=> string | null | undefined
-```
-*/
-type CollapseLiterals<T> = {} extends T ? T : T extends (infer U) & {} ? U : T;
-/**
-Returns the base type of a branded type.
-
-@example
-```
-type Brand = {readonly __brand: unique symbol};
-
-type A = UnwrapBrand<string & Brand>;
-//=> string
-
-type B = UnwrapBrand<number & Brand>;
-//=> number
-
-type C = UnwrapBrand<PropertyKey & Brand>;
-//=> PropertyKey
-
-type D = UnwrapBrand<(1 | 200n | 'foo' | 'bar') & Brand>;
-//=> 1 | 200n | 'foo' | 'bar'
-```
-*/
-type UnwrapBrand<T> = IfNotAnyOrNever<T, {
-  ifNot: _UnwrapBrand<T, Primitive>;
-}>;
-type _UnwrapBrand<T, Base> = T extends Primitive ? T extends (infer U) & Pick<T, Exclude<keyof T, KeysOfUnion<Base>>> ? U : T : T;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/is-string-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).
-
-The implementation of this type is inspired by the trick mentioned in this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
-
-@example
-```
-import type {IsStringLiteral} from 'type-fest';
-
-type A = IsStringLiteral<'foo'>;
-//=> true
-
-type B = IsStringLiteral<string>;
-//=> false
-
-// String types with infinite set of possible values return `false`
-type C = IsStringLiteral<`on${string}`>;
-//=> false
-
-type D = IsStringLiteral<Uppercase<string>>;
-//=> false
-
-type E = IsStringLiteral<'foo' | 'bar' | 'baz'>;
-//=> true
-
-type F = IsStringLiteral<'sm' | 'md' | 'lg' | `${number}px`>;
-//=> boolean
-```
-
-@example
-```
-import type {IsStringLiteral} from 'type-fest';
-
-type StringLength<S extends string, Counter extends never[] = []> =
-	IsStringLiteral<S> extends true
-		? S extends `${string}${infer Tail}`
-			? StringLength<Tail, [...Counter, never]>
-			: Counter['length']
-		: number; // return `number` for non-literal string types
-
-type L1 = StringLength<'foobar'>;
-//=> 6
-
-type L2 = StringLength<Lowercase<string>>;
-//=> number
-
-type L3 = StringLength<`${number}`>;
-//=> number
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsStringLiteral<S> = IfNotAnyOrNever<S, {
-  ifNot: _IsStringLiteral<CollapseLiterals<UnwrapBrand<S>>>;
-  ifAny: false;
-  ifNever: false;
-}>;
-type _IsStringLiteral<S> =
-// If `S` is an infinite string type (e.g., `on${string}`), `Record<S, 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.10.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
-	```
-	*/
-  strictNever?: boolean;
-};
-type DefaultAllExtendOptions = {
-  strictNever: true;
-};
-/**
-Returns a boolean for whether every element in an array type extends another type.
-
-@example
-```
-import type {AllExtend} from 'type-fest';
-
-type A = AllExtend<[1, 2, 3], number>;
-//=> true
-
-type B = AllExtend<[1, 2, '3'], number>;
-//=> false
-
-type C = AllExtend<[number, number | string], number>;
-//=> boolean
-
-type D = AllExtend<[true, boolean, true], true>;
-//=> boolean
-```
-
-Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
-
-```
-// @exactOptionalPropertyTypes: true
-import type {AllExtend} from 'type-fest';
-
-type A = AllExtend<[1?, 2?, 3?], number>;
-//=> true
-```
-
-```
-// @exactOptionalPropertyTypes: false
-import type {AllExtend} from 'type-fest';
-
-type A = AllExtend<[1?, 2?, 3?], number>;
-//=> boolean
-
-type B = AllExtend<[1?, 2?, 3?], number | undefined>;
-//=> true
-```
-
-@see {@link AllExtendOptions}
-
-@category Utilities
-@category Array
-*/
-type AllExtend<TArray extends UnknownArray, Type, Options extends AllExtendOptions = {}> = IfNotAnyOrNever<CollapseRestElement<TArray>, {
-  ifNot: _AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
-  ifAny: false;
-  ifNever: false;
-}>;
-// Kept free of `IfNotAnyOrNever` so that it stays tail-recursive, which allows it to handle long arrays.
-type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = 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;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/promisable.d.ts
-/**
-Create a type that represents either the value or the value wrapped in `PromiseLike`.
-
-Use-cases:
-- A function accepts a callback that may either return a value synchronously or may return a promised value.
-- This type could be the return type of `Promise#then()`, `Promise#catch()`, and `Promise#finally()` callbacks.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31394) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-import type {Promisable} from 'type-fest';
-
-async function logger(getLogEntry: () => Promisable<string>): Promise<void> {
-	const entry = await getLogEntry();
-	console.log(entry);
-}
-
-await logger(() => 'foo');
-await logger(() => Promise.resolve('bar'));
-```
-
-@category Async
-*/
-type Promisable<T> = T | PromiseLike<T>;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/is-lowercase.d.ts
-/**
-Returns a boolean for whether the given string literal is lowercase.
-
-@example
-```
-import type {IsLowercase} from 'type-fest';
-
-type A = IsLowercase<'abc'>;
-//=> true
-
-type B = IsLowercase<'Abc'>;
-//=> false
-
-type C = IsLowercase<string>;
-//=> boolean
-```
-*/
-type IsLowercase<S extends string> = AllExtend<_IsLowercase<S>, true>;
-/**
-Loops through each part in the string and returns a boolean array indicating whether each part is lowercase.
-*/
-type _IsLowercase<S extends string, Accumulator extends boolean[] = []> = S extends `${infer First}${infer Rest}` ? _IsLowercase<Rest, [...Accumulator, IsLowercaseHelper<First>]> : [...Accumulator, IsLowercaseHelper<S>];
-/**
-Returns a boolean for whether an individual part of the string is lowercase.
-*/
-type IsLowercaseHelper<S extends string> = S extends Lowercase<string> ? true : S extends Uppercase<string> | Capitalize<string> | `${string}${Uppercase<string>}${string}` ? false : boolean;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/is-uppercase.d.ts
-/**
-Returns a boolean for whether the given string literal is uppercase.
-
-@example
-```
-import type {IsUppercase} from 'type-fest';
-
-type A = IsUppercase<'ABC'>;
-//=> true
-
-type B = IsUppercase<'Abc'>;
-//=> false
-
-type C = IsUppercase<string>;
-//=> boolean
-```
-*/
-type IsUppercase<S extends string> = AllExtend<_IsUppercase<S>, true>;
-/**
-Loops through each part in the string and returns a boolean array indicating whether each part is uppercase.
-*/
-type _IsUppercase<S extends string, Accumulator extends boolean[] = []> = S extends `${infer First}${infer Rest}` ? _IsUppercase<Rest, [...Accumulator, IsUppercaseHelper<First>]> : [...Accumulator, IsUppercaseHelper<S>];
-/**
-Returns a boolean for whether an individual part of the string is uppercase.
-*/
-type IsUppercaseHelper<S extends string> = S extends Uppercase<string> ? true : S extends Lowercase<string> | Uncapitalize<string> | `${string}${Lowercase<string>}${string}` ? false : boolean;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/words.d.ts
-type SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];
-type RemoveLastCharacter<Sentence extends string, Character extends string> = Sentence extends `${infer LeftSide}${Character}` ? SkipEmptyWord<LeftSide> : never;
-/**
-Words options.
-
-@see {@link Words}
-*/
-type WordsOptions = {
-  /**
-	Split on numeric sequence.
-
-	@default true
-
-	@example
-	```
-	import type {Words} from 'type-fest';
-
-	type Example1 = Words<'p2pNetwork', {splitOnNumbers: true}>;
-	//=> ['p', '2', 'p', 'Network']
-
-	type Example2 = Words<'p2pNetwork', {splitOnNumbers: false}>;
-	//=> ['p2p', 'Network']
-	```
-	*/
-  splitOnNumbers?: boolean;
-  /**
-	Split on {@link AsciiPunctuation | punctuation characters} (e.g., `#`, `&`, `*`, `:`, `?`, `@`, `~`).
-
-	@example
-	```
-	import type {Words} from 'type-fest';
-
-	type Example1 = Words<'hello:world', {splitOnPunctuation: true}>;
-	//=> ['hello', 'world']
-
-	type Example2 = Words<'hello:world', {splitOnPunctuation: false}>;
-	//=> ['hello', ':world']
-	```
-	*/
-  splitOnPunctuation?: boolean;
-};
-type _DefaultWordsOptions = {
-  splitOnNumbers: true;
-  splitOnPunctuation: false;
-};
-/**
-Split a string similar to Lodash's `_.words()` function.
-
-- Split on each word that begins with a capital letter.
-- Split on each {@link WordSeparators}.
-- Split on each {@link AsciiPunctuation} (if {@link WordsOptions.splitOnPunctuation} is enabled).
-- Split on numeric sequence.
-
-@example
-```
-import type {Words} from 'type-fest';
-
-type Words0 = Words<'helloWorld'>;
-//=> ['hello', 'World']
-
-type Words1 = Words<'helloWORLD'>;
-//=> ['hello', 'WORLD']
-
-type Words2 = Words<'hello-world'>;
-//=> ['hello', 'world']
-
-type Words3 = Words<'--hello the_world'>;
-//=> ['hello', 'the', 'world']
-
-type Words4 = Words<'lifeIs42'>;
-//=> ['life', 'Is', '42']
-
-type Words5 = Words<'p2pNetwork', {splitOnNumbers: false}>;
-//=> ['p2p', 'Network']
-
-type Words6 = Words<'hello:world', {splitOnPunctuation: true}>;
-//=> ['hello', 'world']
-
-type Words7 = Words<'hello:world', {splitOnPunctuation: false}>;
-//=> ['hello', ':world']
-
-type Words8 = Words<'hello::world', {splitOnPunctuation: true}>;
-//=> ['hello', 'world']
-```
-
-@category Change case
-@category Template literal
-*/
-type Words<Sentence extends string, Options extends WordsOptions = {}> = WordsImplementation<Sentence, ApplyDefaultOptions<WordsOptions, _DefaultWordsOptions, Options>>;
-type WordsImplementation<Sentence extends string, Options extends Required<WordsOptions>, LastCharacter extends string = '', CurrentWord extends string = ''> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}` ? FirstCharacter extends WordSeparators | (Options['splitOnPunctuation'] extends true ? AsciiPunctuation : never) ?
-// Skip word separator
-[...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options>] : LastCharacter extends '' ?
-// Fist char of word
-WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter> :
-// Case change: non-numeric to numeric
-[false, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? Options['splitOnNumbers'] extends true ?
-// Split on number: push word
-[...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>] :
-// No split on number: concat word
-WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`> :
-// Case change: numeric to non-numeric
-[true, false] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? Options['splitOnNumbers'] extends true ?
-// Split on number: push word
-[...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>] :
-// No split on number: concat word
-WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`> :
-// No case change: concat word
-[true, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`> :
-// Case change: lower to upper, push word
-[true, true] extends [IsLowercase<LastCharacter>, IsUppercase<FirstCharacter>] ? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>] :
-// Case change: upper to lower, brings back the last character, push word
-[true, true] extends [IsUppercase<LastCharacter>, IsLowercase<FirstCharacter>] ? [...RemoveLastCharacter<CurrentWord, LastCharacter>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${LastCharacter}${FirstCharacter}`>] :
-// No case change: concat word
-WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [...SkipEmptyWord<CurrentWord>];
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/delimiter-case.d.ts
-type _DefaultDelimiterCaseOptions = Merge<_DefaultWordsOptions, {
-  splitOnNumbers: false;
-}>;
-/**
-Convert an array of words to delimiter case starting with a delimiter with input capitalization.
-*/
-type DelimiterCaseFromArray<Words extends string[], Delimiter extends string, OutputString extends string = ''> = Words extends [infer FirstWord extends string, ...infer RemainingWords extends string[]] ? DelimiterCaseFromArray<RemainingWords, Delimiter, OutputString extends '' ? FirstWord : `${OutputString}${StartsWith<FirstWord, AsciiPunctuation> extends true ? '' : Delimiter}${FirstWord}`> : OutputString;
-/**
-Convert a string literal to a custom string delimiter casing.
-
-This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
-
-@see {@link KebabCase}
-@see {@link SnakeCase}
-
-@example
-```
-import type {DelimiterCase} from 'type-fest';
-
-// Simple
-
-const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
-const someVariableNoSplitOnNumbers: DelimiterCase<'p2pNetwork', '#', {splitOnNumbers: false}> = 'p2p#network';
-const someVariableWithPunctuation: DelimiterCase<'div.card::after', '#', {splitOnPunctuation: true}> = 'div#card#after';
-
-// Advanced
-
-type OddlyCasedProperties<T> = {
-	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
-};
-
-type SomeOptions = {
-	dryRun: boolean;
-	includeFile: string;
-	foo: number;
-};
-
-const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
-	'dry#run': true,
-	'include#file': 'bar.js',
-	foo: 123,
-};
-```
-
-@category Change case
-@category Template literal
- */
-type DelimiterCase<Value, Delimiter extends string, Options extends WordsOptions = {}> = Value extends string ? Delimiter extends string // For distributing `Delimiter`
- ? IsStringLiteral<Value> extends false ? Value : Lowercase<DelimiterCaseFromArray<Words<Value, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>, Delimiter>> : never : Value;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/kebab-case.d.ts
-/**
-Convert a string literal to kebab-case.
-
-This can be useful when, for example, converting a camel-cased object property to a kebab-cased CSS class name or a command-line flag.
-
-@example
-```
-import type {KebabCase} from 'type-fest';
-
-// Simple
-
-const someVariable: KebabCase<'fooBar'> = 'foo-bar';
-const someVariableNoSplitOnNumbers: KebabCase<'p2pNetwork', {splitOnNumbers: false}> = 'p2p-network';
-const someVariableWithPunctuation: KebabCase<'div.card::after', {splitOnPunctuation: true}> = 'div-card-after';
-
-// Advanced
-
-type KebabCasedProperties<T> = {
-	[K in keyof T as KebabCase<K>]: T[K]
-};
-
-type CliOptions = {
-	dryRun: boolean;
-	includeFile: string;
-	foo: number;
-};
-
-const rawCliOptions: KebabCasedProperties<CliOptions> = {
-	'dry-run': true,
-	'include-file': 'bar.js',
-	foo: 123,
-};
-```
-
-@category Change case
-@category Template literal
-*/
-type KebabCase<Value, Options extends WordsOptions = {}> = DelimiterCase<Value, '-', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
-//#endregion
-//#region src/models/shared/ItemMetadataClass.d.ts
-export interface ItemMetadataClass<TBase extends Class<object>> {
-  new (...args: ConstructorParameters<TBase>): InstanceType<TBase> & ItemMetadata;
-  prototype: InstanceType<TBase> & ItemMetadata;
-}
-//#endregion
-//#region src/models/shared/Serializable.d.ts
-export declare abstract class Serializable {
-  toJSON(): this;
-}
-//#endregion
-//#region src/models/shared/TakeOne.d.ts
-export interface TakeOne {
-  <T extends readonly unknown[]>(values: T, index?: number): T[number];
-  <T extends object>(values: T, index: keyof T): T[keyof T];
-}
-//#endregion
-//#region src/util/types/FunctionLike.d.ts
-export type FunctionLike = ((...args: never) => unknown) | (abstract new (...args: never) => unknown);
-//#endregion
-//#region src/util/types/DeepOmit.d.ts
-export type DeepOmit<T, TKey extends PropertyKey> = T extends DeepOmitKeptValue ? T : T extends readonly unknown[] ? { [K in keyof T]: DeepOmit<T[K], TKey>; } : T extends object ? [keyof T] extends [never] ? T : { [P in keyof T as P extends symbol ? never : P extends TKey ? never : P]: DeepOmit<T[P], TKey>; } : T;
-type DeepOmitKeptValue = ArrayBufferView | Blob | Date | FunctionLike | Map<unknown, unknown> | Primitive | Promise<unknown> | RegExp | Set<unknown>;
-//#endregion
-//#region src/util/types/DeepOptionalUndefined.d.ts
-export type DeepOptionalUndefined<T> = T extends Date | FunctionLike | Primitive ? T : T extends unknown[] ? { [K in keyof T]: DeepOptionalUndefined<T[K]>; } : T extends object ? { [K in keyof T as undefined extends T[K] ? K : never]?: DeepOptionalUndefined<T[K]>; } & { [K in keyof T as undefined extends T[K] ? never : K]: DeepOptionalUndefined<T[K]>; } extends (infer O) ? { [K in keyof O]: O[K]; } : never : T;
-//#endregion
-//#region src/models/shared/ToData.d.ts
-export type ToData<T> = DeepOptionalUndefined<DeepOmit<T, "toJSON">>;
-//#endregion
-//#region src/models/text/DedentOptions.d.ts
-export interface DedentOptions {
-  alignValues?: boolean;
-  escapeSpecialCharacters?: boolean;
-  trimWhitespace?: boolean;
-}
-//#endregion
-//#region src/models/text/Dedent.d.ts
-export interface Dedent {
-  (strings: string | TemplateStringsArray, ...values: unknown[]): string;
-  withOptions: (options: DedentOptions) => Dedent;
-}
-//#endregion
-//#region src/models/zod/UniqueArraySchemaKey.d.ts
-export type UniqueArraySchemaKey<TSchema extends z.ZodType> = TSchema extends z.ZodObject ? keyof TSchema["shape"] & string : keyof z.output<TSchema> & string;
-//#endregion
-//#region src/models/zod/CreateUniqueArraySchema.d.ts
-export type CreateUniqueArraySchema = (<TOutput extends object, TInput, TSchema extends z.ZodType<TOutput, TInput>>(schema: TSchema, key: UniqueArraySchemaKey<TSchema>) => z.ZodArray<TSchema>) & (<TOutput extends Primitive, TInput, TSchema extends z.ZodType<TOutput, TInput>>(schema: TSchema) => z.ZodArray<TSchema>);
-//#endregion
-//#region src/services/app/constants.d.ts
-export declare const MAX_READ_LIMIT = 1e3;
-export declare const SITE_NAME = "Esposter";
-export declare const KIBIBYTE: number;
-export declare const GIBIBYTE: number;
-//#endregion
-//#region src/services/error/getResult.d.ts
-export declare const getResult: <T>(callback: () => T) => Result<T, Error>;
-//#endregion
-//#region src/services/error/getResultAsync.d.ts
-export declare const getResultAsync: <T>(callback: () => Promise<T>) => ResultAsync<T, Error>;
-//#endregion
-//#region src/services/error/reportFinalizerError.d.ts
-export declare const reportFinalizerError: <T, E>(callbackResult: Result<T, E>, finalizerError: unknown) => void;
-//#endregion
-//#region src/services/error/toAppError.d.ts
-export declare const toAppError: (error: unknown) => Error;
-//#endregion
-//#region src/services/error/withFinalizer.d.ts
-export declare const withFinalizer: <T>(callback: () => T, finalizer?: () => void) => T;
-//#endregion
-//#region src/services/error/withFinalizerAsync.d.ts
-export declare const withFinalizerAsync: <T>(callback: () => Promisable<T>, finalizer?: () => Promisable<void>) => Promise<T>;
-//#endregion
-//#region src/services/indexedDb/getRequestError.d.ts
-export declare const getRequestError: (request: IDBRequest) => DOMException;
-//#endregion
-//#region src/services/indexedDb/getTransactionDone.d.ts
-export declare const getTransactionDone: (transaction: IDBTransaction) => Promise<void>;
-//#endregion
-//#region src/services/indexedDb/getTransactionObjectStore.d.ts
-export declare const getTransactionObjectStore: <TSchema extends DatabaseSchema, TMode extends IDBTransactionMode>(transaction: IDBTransaction) => <TStoreName extends DatabaseStoreName<TSchema>>(name: TStoreName) => DatabaseObjectStore<TSchema, TStoreName, TMode>;
-//#endregion
-//#region src/services/indexedDb/openDatabase.d.ts
-export declare const openDatabase: <TSchema extends DatabaseSchema = DatabaseSchema>(name: string, version: number, options?: DatabaseOpenOptions<TSchema>) => Promise<Database<TSchema>>;
-//#endregion
-//#region src/services/indexedDb/requestToPromise.d.ts
-export declare const requestToPromise: <TResult>(request: IDBRequest) => Promise<TResult>;
-//#endregion
-//#region src/services/indexedDb/wrapDatabase.d.ts
-export declare const wrapDatabase: <TSchema extends DatabaseSchema = DatabaseSchema>(database: IDBDatabase) => Database<TSchema>;
-//#endregion
-//#region src/services/indexedDb/wrapIndex.d.ts
-export declare const wrapIndex: <TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>, TIndexName extends DatabaseIndexName<TSchema, TStoreName>>(index: IDBIndex) => DatabaseIndex<TSchema, TStoreName, TIndexName>;
-//#endregion
-//#region src/services/indexedDb/wrapObjectStore.d.ts
-export declare const wrapObjectStore: <TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>, TMode extends IDBTransactionMode>(objectStore: IDBObjectStore) => DatabaseObjectStore<TSchema, TStoreName, TMode>;
-//#endregion
-//#region src/services/indexedDb/wrapTransaction.d.ts
-export declare const wrapTransaction: <TSchema extends DatabaseSchema, TStoreName extends DatabaseStoreName<TSchema>, TMode extends IDBTransactionMode>(transaction: IDBTransaction) => DatabaseTransaction<TSchema, TStoreName, TMode>;
-//#endregion
-//#region src/services/indexedDb/wrapUpgradeDatabase.d.ts
-export declare const wrapUpgradeDatabase: <TSchema extends DatabaseSchema = DatabaseSchema>(database: IDBDatabase) => UpgradeDatabase<TSchema>;
-//#endregion
-//#region src/services/indexedDb/wrapUpgradeTransaction.d.ts
-export declare const wrapUpgradeTransaction: <TSchema extends DatabaseSchema>(transaction: IDBTransaction) => DatabaseTransaction<TSchema, DatabaseStoreName<TSchema>, "versionchange">;
-//#endregion
-//#region src/services/message/constants.d.ts
-export declare const MENTION_ID_ATTRIBUTE = "data-id";
-export declare const MENTION_ITEM_TYPE_ATTRIBUTE = "data-mention-type";
-export declare const MENTION_LABEL_ATTRIBUTE = "data-label";
-export declare const MENTION_TYPE_ATTRIBUTE = "data-type";
-export declare const MENTION_TYPE = "mention";
-export declare const MENTION_SELECTOR: string;
-export declare const MENTION_HERE_ID = "@here";
-export declare const MENTION_EVERYONE_ID = "@everyone";
-export declare const CUSTOM_EMOJI_ID_ATTRIBUTE = "data-custom-emoji-id";
-export declare const CUSTOM_EMOJI_NAME_ATTRIBUTE = "data-custom-emoji-name";
-export declare const SPOILER_ATTRIBUTE = "data-spoiler";
-export declare const SPOILER_SELECTOR: string;
-//#endregion
-//#region src/services/message/getMentions.d.ts
-export declare const getMentions: (message: string) => HTMLElement[];
-//#endregion
-//#region src/services/mime/charset.d.ts
-export declare const charset: (type: string) => false | string;
-//#endregion
-//#region src/services/mime/constants.d.ts
-export declare const MEDIA_TYPE_REGEX: RegExp;
-export declare const PATH_SEPARATOR_REGEX: RegExp;
-export declare const TEXT_MEDIA_TYPE_REGEX: RegExp;
-export declare const CHARSET_PARAMETER_REGEX: RegExp;
-export declare const DEFAULT_TEXT_CHARSET = "UTF-8";
-export declare const FacetScoreMap: ReadonlyMap<string, number>;
-export declare const DEFAULT_FACET_SCORE = 900;
-export declare const SourceScoreMap: ReadonlyMap<string, number>;
-export declare const DEFAULT_SOURCE_SCORE = 30;
-export declare const TypeScoreMap: ReadonlyMap<string, number>;
-export declare const DEFAULT_TYPE_SCORE = 0;
-//#endregion
-//#region src/services/mime/contentType.d.ts
-export declare const contentType: (value: string) => false | string;
-//#endregion
-//#region src/services/mime/extension.d.ts
-export declare const extension: (type: string) => false | string;
-//#endregion
-//#region src/services/mime/getExtensionMimeTypeMap.d.ts
-export declare const getExtensionMimeTypeMap: () => ReadonlyMap<string, string>;
-//#endregion
-//#region src/services/mime/getMediaType.d.ts
-export declare const getMediaType: (value: string) => string;
-//#endregion
-//#region src/services/mime/getMimeScore.d.ts
-export declare const getMimeScore: (mimeType: string, source?: string) => number;
-//#endregion
-//#region src/services/mime/getMimeTypeEntryMap.d.ts
-export declare const getMimeTypeEntryMap: () => ReadonlyMap<string, MimeDatabaseEntry>;
-//#endregion
-//#region src/services/mime/lookup.d.ts
-export declare const lookup: (path: string) => false | string;
-//#endregion
-//#region src/services/prettier/css.d.ts
-export declare const css: typeof String.raw;
-//#endregion
-//#region src/services/prettier/html.d.ts
-export declare const html: typeof String.raw;
-//#endregion
-//#region src/services/profanity/checkContainsProfanity.d.ts
-export declare const checkContainsProfanity: (text: unknown, { isWholeWord }?: Partial<ProfanityOptions>) => boolean;
-//#endregion
-//#region src/services/profanity/englishProfaneWords.d.ts
-export declare const englishProfaneWords: readonly string[];
-//#endregion
-//#region src/services/sanitizeHtml/checkIsAllowedUrl.d.ts
-export declare const checkIsAllowedUrl: (url: string, allowedSchemes: string[]) => boolean;
-//#endregion
-//#region src/services/sanitizeHtml/checkIsUnsafeUrlCharacter.d.ts
-export declare const checkIsUnsafeUrlCharacter: (character: string) => boolean;
-//#endregion
-//#region src/services/sanitizeHtml/checkIsWhitespaceCharacter.d.ts
-export declare const checkIsWhitespaceCharacter: (character: string) => boolean;
-//#endregion
-//#region src/services/sanitizeHtml/collectText.d.ts
-export declare const collectText: (nodes: DefaultTreeAdapterTypes.ChildNode[], depth: number) => string;
-//#endregion
-//#region src/services/sanitizeHtml/constants.d.ts
-export declare const HTML_NAMESPACE: html$1.NS;
-export declare const DEFAULT_ALLOWED_TAGS: string[];
-export declare const DEFAULT_LINK_ATTRIBUTES: string[];
-export declare const DEFAULT_ALLOWED_ATTRIBUTES: Record<string, string[]>;
-export declare const DEFAULT_ALLOWED_SCHEMES: string[];
-export declare const NON_TEXT_TAGS: string[];
-export declare const VOID_TAGS: string[];
-export declare const URL_ATTRIBUTES: string[];
-export declare const SRCSET_ATTRIBUTE = "srcset";
-export declare const IMPORTANT_REGEX: RegExp;
-export declare const MAX_NESTING_DEPTH = 256;
-export declare const SRCSET_DESCRIPTOR_REGEX: RegExp;
-export declare const ESCAPED_TEXT_CHARACTERS_REGEX: RegExp;
-export declare const ESCAPED_ATTRIBUTE_CHARACTERS_REGEX: RegExp;
-export declare const SANITIZER_ADVISORY_WATCH_SINCE = "2026-10-11";
-//#endregion
-//#region src/services/sanitizeHtml/escapeAttribute.d.ts
-export declare const escapeAttribute: (value: string) => string;
-//#endregion
-//#region src/services/sanitizeHtml/escapeCharacters.d.ts
-export declare const escapeCharacters: (value: string, charactersRegex: RegExp, entities: Record<string, string>) => string;
-//#endregion
-//#region src/services/sanitizeHtml/escapeText.d.ts
-export declare const escapeText: (text: string) => string;
-//#endregion
-//#region src/services/sanitizeHtml/filterAttributes.d.ts
-export declare const filterAttributes: (element: DefaultTreeAdapterTypes.Element, policy: SanitizePolicy) => Record<string, string>;
-//#endregion
-//#region src/services/sanitizeHtml/filterClasses.d.ts
-export declare const filterClasses: (value: string, patterns: string[] | undefined) => string | undefined;
-//#endregion
-//#region src/services/sanitizeHtml/filterHtml.d.ts
-export declare const filterHtml: (html: string, policy: SanitizePolicy) => string;
-//#endregion
-//#region src/services/sanitizeHtml/filterSrcset.d.ts
-export declare const filterSrcset: (value: string, allowedSchemes: string[]) => string | undefined;
-//#endregion
-//#region src/services/sanitizeHtml/filterStyle.d.ts
-export declare const filterStyle: (value: string, rules: Record<string, RegExp[]> | undefined) => string | undefined;
-//#endregion
-//#region src/services/sanitizeHtml/getChildNodes.d.ts
-export declare const getChildNodes: (element: DefaultTreeAdapterTypes.Element) => DefaultTreeAdapterTypes.ChildNode[];
-//#endregion
-//#region src/services/sanitizeHtml/matchesClassPattern.d.ts
-export declare const matchesClassPattern: (className: string, pattern: string) => boolean;
-//#endregion
-//#region src/services/sanitizeHtml/renderNode.d.ts
-export declare const renderNode: (node: DefaultTreeAdapterTypes.ChildNode, policy: SanitizePolicy, depth: number) => string;
-//#endregion
-//#region src/services/sanitizeHtml/sanitizeHtml.d.ts
-export declare const sanitizeHtml: (html: string, options?: SanitizeHtmlOptions) => string;
-//#endregion
-//#region src/services/sanitizeHtml/sanitizeTextHtml.d.ts
-export declare const sanitizeTextHtml: (html: string) => string;
-//#endregion
-//#region src/services/shared/applyItemMetadataMixin.d.ts
-export declare const applyItemMetadataMixin: <TBase extends Class<object>>(Base: TBase) => ItemMetadataClass<TBase>;
-//#endregion
-//#region src/services/zod/createNormalizedStringSchema.d.ts
-export declare const createNormalizedStringSchema: (maxLength: number, schema?: z.ZodString) => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
-//#endregion
-//#region src/services/zod/createUniqueArraySchema.d.ts
-export declare const createUniqueArraySchema: CreateUniqueArraySchema;
-//#endregion
-//#region src/services/zstd/constants.d.ts
-export declare const DEFAULT_COMPRESSION_LEVEL = 12;
-export declare const MIN_WINDOW_LOG = 10;
-export declare const MAX_WINDOW_LOG = 27;
-//#endregion
-//#region src/services/zstd/getWindowLog.d.ts
-export declare const getWindowLog: (dictionaryByteCount: number, inputByteCount: number) => number;
-//#endregion
-//#region src/test/constants.d.ts
-export declare const ALL_SPECIAL_VALUES: {
-  isPlainObject: boolean;
-  value: unknown;
-}[];
-//#endregion
-//#region src/util/array/chunk.d.ts
-export declare const chunk: <T>(array: T[], size: number) => T[][];
-//#endregion
-//#region src/util/array/chunkBySerializedSize.d.ts
-export declare const chunkBySerializedSize: <T>(items: T[], maxBytes: number, maxCount: number) => T[][];
-//#endregion
-//#region src/util/array/takeOne.d.ts
-export declare const takeOne: TakeOne;
-//#endregion
-//#region src/util/date/getEndOfDay.d.ts
-export declare const getEndOfDay: (date: Date) => Date;
-//#endregion
-//#region src/util/date/getZonedDateTime.d.ts
-export declare const getZonedDateTime: (date: Date) => Temporal.ZonedDateTime;
-//#endregion
-//#region src/util/dom/checkIsNestedInteraction.d.ts
-export declare const checkIsNestedInteraction: (event: MouseEvent) => boolean;
-//#endregion
-//#region src/util/environment/checkIsServer.d.ts
-export declare const checkIsServer: () => boolean;
-//#endregion
-//#region src/util/function/getSynchronizedFunction.d.ts
-export declare const getSynchronizedFunction: <TArgs extends unknown[]>(asyncFunction: (...args: TArgs) => Promise<unknown>) => ((...args: TArgs) => void);
-export declare const waitForSynchronizedFunctions: () => Promise<void>;
-//#endregion
-//#region src/util/function/noop.d.ts
-export declare const noop: () => void;
-//#endregion
-//#region src/util/id/constants.d.ts
-export declare const ID_SEPARATOR = "|";
-//#endregion
-//#region src/util/id/uuid/constants.d.ts
-export declare const UUIDV4_REGEX: RegExp;
-//#endregion
-//#region src/util/map/getOrCreate.d.ts
-export declare const getOrCreate: <TKey, TValue>(map: Map<TKey, TValue>, key: TKey, create: () => TValue) => TValue;
-//#endregion
-//#region src/util/object/checkIsCustomMethod.d.ts
-export declare const checkIsCustomMethod: (value: object, methodName: ObjectMethod) => boolean;
-//#endregion
-//#region src/util/object/checkIsDeepEqual.d.ts
-export declare const checkIsDeepEqual: (first: unknown, second: unknown) => boolean;
-//#endregion
-//#region src/util/object/checkIsPlainObject.d.ts
-export declare const checkIsPlainObject: (data: unknown) => data is Record<string, unknown>;
-//#endregion
-//#region src/util/object/checkIsSameBytes.d.ts
-export declare const checkIsSameBytes: (first: ArrayBuffer | ArrayBufferView | SharedArrayBuffer, second: ArrayBuffer | ArrayBufferView | SharedArrayBuffer) => boolean;
-//#endregion
-//#region src/util/object/checkIsSameValueZero.d.ts
-export declare const checkIsSameValueZero: (first: unknown, second: unknown) => boolean;
-//#endregion
-//#region src/util/object/getEnumerableKeys.d.ts
-export declare const getEnumerableKeys: (value: object) => PropertyKey[];
-//#endregion
-//#region src/util/types/GetArrayProps.d.ts
-export type GetArrayProps<T extends unknown[], P extends string, D extends unknown[], R extends boolean> = (D extends [unknown, ...infer Rest] ? GetProperties<T[number], R extends true ? `${P}[number]` : `${P}.[number]`, Rest, false> : never) | {
-  path: R extends true ? "length" : `${P}.length`;
-  value: T["length"];
-};
-//#endregion
-//#region src/util/types/KnownKeys.d.ts
-export type KnownKeys<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K]; };
-//#endregion
-//#region src/util/types/GetObjectProps.d.ts
-export type GetObjectProps<T, P extends string, D extends unknown[], R extends boolean> = { [K in keyof KnownKeys<T> & (number | string)]: K extends `${number}` ? never : NonNullable<T[K]> extends FunctionLike ? never : (D extends [unknown, ...infer Rest] ? GetProperties<T[K], R extends true ? `${K}` : `${P}.${K}`, Rest, false> : never) | {
-  path: R extends true ? `${K}` : `${P}.${K}`;
-  value: T[K];
-}; }[keyof KnownKeys<T> & (number | string)];
-//#endregion
-//#region src/util/types/GetPrimitiveProps.d.ts
-export type GetPrimitiveProps<T, P extends string, D extends unknown[], R extends boolean> = T extends string ? {
-  path: R extends true ? "length" : `${P}.length`;
-  value: number;
-} : T extends symbol ? (D extends [unknown, ...infer Rest] ? GetProperties<string | undefined, R extends true ? "description" : `${P}.description`, Rest, false> : never) | {
-  path: R extends true ? "description" : `${P}.description`;
-  value: string | undefined;
-} : never;
-//#endregion
-//#region src/util/types/GetProperties.d.ts
-export type GetProperties<T, P extends string = "", D extends unknown[] = [unknown, unknown, unknown, unknown, unknown], R extends boolean = true> = [T] extends [never] ? never : D extends [] ? never : NonNullable<T> extends (infer O) ? O extends unknown[] ? GetArrayProps<O, P, D, R> : O extends object ? GetObjectProps<O, P, D, R> : GetPrimitiveProps<O, P, D, R> : never;
-//#endregion
-//#region src/util/types/GetPaths.d.ts
-export type GetPaths<T> = GetProperties<T> extends (infer U) ? (U extends {
-  path: infer Path;
-} ? Path : never) : never;
-//#endregion
-//#region src/util/types/PropertyNames.d.ts
-export type PropertyNames<T> = { [P in GetPaths<T>]: P; };
-//#endregion
-//#region src/util/object/getPropertyNames.d.ts
-export declare const getPropertyNames: <T>() => PropertyNames<T>;
-//#endregion
-//#region src/util/object/jsonDateParse.d.ts
-export declare const jsonDateParse: <T = any>(text: string) => T;
-//#endregion
-//#region src/util/types/MergeObjectsStrict.d.ts
-export type MergeObjectsStrict<T extends object[]> = T extends [infer TFirst, infer TSecond, ...infer TRemaining] ? TSecond extends { [K in keyof TSecond]: K extends keyof TFirst ? never : TSecond[K]; } ? TRemaining extends object[] ? MergeObjectsStrict<[TSecond, ...TRemaining]> & TFirst : TFirst & TSecond : never : T extends [infer TFirst] ? TFirst : never;
-//#endregion
-//#region src/util/object/mergeObjectsStrict.d.ts
-export declare const mergeObjectsStrict: <T extends object[]>(...objects: T) => MergeObjectsStrict<T>;
-//#endregion
-//#region src/util/object/omitDeep.d.ts
-export declare const omitDeep: <T, TKey extends string>(value: T, ...keys: TKey[]) => DeepOmit<T, TKey>;
-//#endregion
-//#region src/util/promise/createEvictingPromiseCache.d.ts
-export declare const createEvictingPromiseCache: <TArguments extends unknown[], TValue>(getKey: (...args: TArguments) => string, load: (...args: TArguments) => Promise<TValue>) => ((...args: TArguments) => Promise<TValue>);
-//#endregion
-//#region src/util/promise/settleAll.d.ts
-export declare const settleAll: <T>(tasks: (() => Promise<T>)[], concurrencyLimit?: number) => Promise<T[]>;
-//#endregion
-//#region src/util/reactivity/getRawData.d.ts
-export declare const getRawData: <T>(data: T) => T;
-//#endregion
-//#region src/util/reactivity/toRawDeep.d.ts
-export declare const toRawDeep: <T extends object>(data: T) => T;
-//#endregion
-//#region src/util/text/capitalize.d.ts
-export declare const capitalize: (string: string) => string;
-//#endregion
-//#region src/util/text/dedent.d.ts
-export declare const dedent: Dedent;
-//#endregion
-//#region src/util/text/encodeUrlSubDelimiters.d.ts
-export declare const encodeUrlSubDelimiters: (value: string) => string;
-//#endregion
-//#region src/util/text/getDecodedUriComponent.d.ts
-export declare const getDecodedUriComponent: (value: string, fallback: string) => string;
-//#endregion
-//#region src/util/text/normalizeString.d.ts
-export declare const normalizeString: (value: null | string | undefined) => string;
-//#endregion
-//#region src/util/text/streamToText.d.ts
-export declare const streamToText: (readable: NodeJS.ReadableStream) => Promise<string>;
-//#endregion
-//#region src/util/text/toKebabCase.d.ts
-export declare const toKebabCase: <T extends string>(string: T) => KebabCase<T>;
-//#endregion
-//#region src/util/text/truncate.d.ts
-export declare const truncate: (string: string, length: number) => string;
-//#endregion
-//#region src/util/text/uncapitalize.d.ts
-export declare const uncapitalize: <T extends string>(string: T) => Uncapitalize<T>;
-//#endregion
-//#region src/util/time/hrtime.d.ts
-export declare const hrtime: (previousHrTime?: [number, number]) => [number, number];
-//#endregion
-//#region src/util/time/now.d.ts
-export declare const now: () => string;
-//#endregion
-//#region src/util/time/sleep.d.ts
-export declare const sleep: (durationMs: number) => Promise<void>;
-//#endregion
-//#region src/util/validation/exhaustiveGuard.d.ts
-export declare const exhaustiveGuard: (value: never) => never;
-//#endregion
-export {};