@esposter/shared 4.2.0 → 4.3.2

package/dist/index.d.ts

@@ -0,0 +1,2493 @@
+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/history/History.d.ts
+export interface History<T> {
+  future: T[];
+  limit: number;
+  past: T[];
+}
+//#endregion
+//#region src/models/history/HistoryStep.d.ts
+export interface HistoryStep<T> {
+  entry?: T;
+  history: History<T>;
+}
+//#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/jsonPatch/JsonPatchOperationType.d.ts
+export declare enum JsonPatchOperationType {
+  Add = "add",
+  Copy = "copy",
+  Move = "move",
+  Remove = "remove",
+  Replace = "replace",
+  Test = "test"
+}
+//#endregion
+//#region src/models/jsonPatch/JsonPatchOperation.d.ts
+export type JsonPatchOperation = JsonPatchFromOperation | JsonPatchRemoveOperation | JsonPatchValueOperation;
+interface JsonPatchFromOperation {
+  from: string;
+  op: JsonPatchOperationType.Copy | JsonPatchOperationType.Move;
+  path: string;
+}
+interface JsonPatchRemoveOperation {
+  op: JsonPatchOperationType.Remove;
+  path: string;
+}
+interface JsonPatchValueOperation {
+  op: JsonPatchOperationType.Add | JsonPatchOperationType.Replace | JsonPatchOperationType.Test;
+  path: string;
+  value: unknown;
+}
+//#endregion
+//#region src/models/jsonPatch/ApplyPatchesResult.d.ts
+export interface ApplyPatchesResult<T> {
+  document: T;
+  inverses: JsonPatchOperation[];
+}
+//#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 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: readonly UniqueArraySchemaKey<TSchema>[] | 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/history/createHistory.d.ts
+export declare const createHistory: <T>(limit: number) => History<T>;
+//#endregion
+//#region src/services/history/pushHistory.d.ts
+export declare const pushHistory: <T>(history: History<T>, entry: T) => History<T>;
+//#endregion
+//#region src/services/history/redoHistory.d.ts
+export declare const redoHistory: <T>(history: History<T>) => HistoryStep<T>;
+//#endregion
+//#region src/services/history/undoHistory.d.ts
+export declare const undoHistory: <T>(history: History<T>) => HistoryStep<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/jsonPatch/addJsonValue.d.ts
+export declare const addJsonValue: (document: unknown, path: string, value: unknown) => ApplyPatchesResult<unknown>;
+//#endregion
+//#region src/services/jsonPatch/applyPatch.d.ts
+export declare const applyPatch: (document: unknown, operation: JsonPatchOperation) => ApplyPatchesResult<unknown>;
+//#endregion
+//#region src/services/jsonPatch/applyPatches.d.ts
+export declare const applyPatches: <T>(document: T, operations: JsonPatchOperation[]) => ApplyPatchesResult<T>;
+//#endregion
+//#region src/services/jsonPatch/constants.d.ts
+export declare const APPEND_SEGMENT = "-";
+export declare const JSON_POINTER_REGEX: RegExp;
+//#endregion
+//#region src/services/jsonPatch/parseArrayIndex.d.ts
+export declare const parseArrayIndex: (segment: string, maxIndex: number) => number | undefined;
+//#endregion
+//#region src/services/jsonPatch/parseJsonPointer.d.ts
+export declare const parseJsonPointer: (pointer: string) => string[];
+//#endregion
+//#region src/services/jsonPatch/readJsonValue.d.ts
+export declare const readJsonValue: (document: unknown, segments: string[]) => unknown;
+//#endregion
+//#region src/services/jsonPatch/removeJsonValue.d.ts
+export declare const removeJsonValue: (document: unknown, path: string) => ApplyPatchesResult<unknown>;
+//#endregion
+//#region src/services/jsonPatch/toJsonPointer.d.ts
+export declare const toJsonPointer: (segments: string[]) => string;
+//#endregion
+//#region src/services/jsonPatch/updateJsonValue.d.ts
+export declare const updateJsonValue: (document: unknown, segments: string[], update: (value: unknown) => unknown) => unknown;
+//#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-21";
+//#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/array/takeRandom.d.ts
+export declare const takeRandom: <T>(values: readonly T[], random: () => number) => T;
+//#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/checkIsNestedControl.d.ts
+export declare const checkIsNestedControl: (event: MouseEvent) => boolean;
+//#endregion
+//#region src/util/dom/checkIsNestedInteraction.d.ts
+export declare const checkIsNestedInteraction: (event: MouseEvent) => boolean;
+//#endregion
+//#region src/util/dom/downloadFile.d.ts
+export declare const downloadFile: (filename: string, blobPart: BlobPart, type: string) => void;
+//#endregion
+//#region src/util/dom/downloadUrl.d.ts
+export declare const downloadUrl: (url: string, filename: string) => void;
+//#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/clonePlainDeep.d.ts
+export declare const clonePlainDeep: <T>(data: T) => T;
+//#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: 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/constants.d.ts
+export declare const MILLISECONDS_PER_SECOND = 1e3;
+//#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 {};