@esposter/shared 2.34.1 → 2.35.0

package/dist/index.d.ts

@@ -37,16 +37,11 @@ declare const RoutePath: {
   readonly About: "/about";
   readonly Achievements: "/achievements";
   readonly Anime: "/anime";
-  readonly Calendar: "/calendar";
   readonly Calls: (id: string) => string;
   readonly CallsIndex: "/calls";
   readonly Clicker: "/clicker";
-  readonly Dashboard: "/dashboard";
-  readonly DashboardEditor: "/dashboard/editor";
   readonly Docs: "/docs";
   readonly Dungeons: "/dungeons";
-  readonly EmailEditor: "/email-editor";
-  readonly FlowchartEditor: "/flowchart-editor";
   readonly FluidSimulator: "/fluid-simulator";
   readonly Github: "https://github.com/Esposter/Esposter";
   readonly Index: "/";
@@ -61,22 +56,24 @@ declare const RoutePath: {
   readonly PostCreate: "/post/create";
   readonly PostUpdate: (id: string) => string;
   readonly PrivacyPolicy: "/privacy-policy";
-  readonly Survey: (id: string) => string;
-  readonly Surveyer: "/surveyer";
-  readonly TableEditor: "/table-editor";
+  readonly Resource: (id: string) => string;
+  readonly Resources: "/resources";
+  readonly ResourcesAll: "/resources/all";
+  readonly ResourcesCreate: "/resources/create";
+  readonly ResourcesCreateType: (type: string) => string;
   readonly UserSettings: "/user/settings";
-  readonly WebpageEditor: "/webpage-editor";
+  readonly View: (type: string, id: string) => string;
 };
 type RoutePath = typeof RoutePath;
 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"];
 };
-type KnownKeys<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K] };
+type KnownKeys<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K]; };
 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 Function ? 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)];
+}; }[keyof KnownKeys<T> & (number | string)];
 type GetPrimitiveProps<T, P extends string, D extends unknown[], R extends boolean> = T extends string ? {
   path: R extends true ? "length" : `${P}.length`;
   value: number;
@@ -84,11 +81,11 @@ type GetPrimitiveProps<T, P extends string, D extends unknown[], R extends boole
   path: R extends true ? "description" : `${P}.description`;
   value: string | undefined;
 } : never;
-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;
-type GetPaths<T> = GetProperties<T> extends infer U ? (U extends {
+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;
+type GetPaths<T> = GetProperties<T> extends (infer U) ? (U extends {
   path: infer Path;
 } ? Path : never) : never;
-type PropertyNames<T> = { [P in GetPaths<T>]: P };
+type PropertyNames<T> = { [P in GetPaths<T>]: P; };
 interface ItemEntityType<T extends string> {
   type: T;
 }
@@ -233,8 +230,8 @@ const update2: UpdateOperation<User> = {
 @category Utilities
 */
 type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
-? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
-: never;
+ ? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never; }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+ : never; // Should never happen
 /**
 Extract all required keys from the given type.
 
@@ -266,7 +263,7 @@ const validator3 = createValidation<User>('luckyNumber', value => value > 0);
 @category Utilities
 */
 type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
-? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
+ ? Exclude<keyof Type, OptionalKeysOf<Type>> : never; // Should never happen
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -457,16 +454,16 @@ An if-else-like type that resolves depending on whether the given type is `any`
 
 @example
 ```
-// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
-type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+// When `T` is neither `any` nor `never` (like `string`) => Returns `IfNot` branch
+type A = IfNotAnyOrNever<string, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
 //=> 'VALID'
 
 // When `T` is `any` => Returns `IfAny` branch
-type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+type B = IfNotAnyOrNever<any, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
 //=> 'IS_ANY'
 
 // When `T` is `never` => Returns `IfNever` branch
-type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+type C = IfNotAnyOrNever<never, {ifNot: 'VALID'; ifAny: 'IS_ANY'; ifNever: 'IS_NEVER'}>;
 //=> 'IS_NEVER'
 ```
 
@@ -479,7 +476,7 @@ import type {StringRepeat} from 'type-fest';
 type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;
 
 // The following implementation is not tail recursive
-type TrimLeft<S extends string> = IfNotAnyOrNever<S, S extends ` ${infer R}` ? TrimLeft<R> : S>;
+type TrimLeft<S extends string> = IfNotAnyOrNever<S, {ifNot: S extends ` ${infer R}` ? TrimLeft<R> : S}>;
 
 // Hence, instantiations with long strings will fail
 // @ts-expect-error
@@ -488,7 +485,7 @@ type T1 = TrimLeft<NineHundredNinetyNineSpaces>;
 // Error: Type instantiation is excessively deep and possibly infinite.
 
 // To fix this, move the recursion into a helper type
-type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, _TrimLeftOptimised<S>>;
+type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, {ifNot: _TrimLeftOptimised<S>}>;
 
 type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;
 
@@ -496,7 +493,11 @@ type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
 //=> ''
 ```
 */
-type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;
+type IfNotAnyOrNever<T, Cases extends {
+  ifNot: unknown;
+  ifAny?: unknown;
+  ifNever?: unknown;
+}> = IsAny<T> extends true ? 'ifAny' extends keyof Cases ? Cases['ifAny'] : any : IsNever<T> extends true ? 'ifNever' extends keyof Cases ? Cases['ifNever'] : never : Cases['ifNot'];
 /**
 Indicates the value of `exactOptionalPropertyTypes` compiler option.
 */
@@ -532,22 +533,25 @@ type B = CollapseRestElement<[string?, string?, ...number[]]>;
 //=> [string | undefined, string | undefined, number]
 ```
 */
-type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, _CollapseRestElement<TArray>>;
+type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, {
+  ifNot: _CollapseRestElement<TArray>;
+}>;
 type _CollapseRestElement<TArray extends UnknownArray, ForwardAccumulator extends UnknownArray = [], BackwardAccumulator extends UnknownArray = []> = TArray extends UnknownArray // For distributing `TArray`
-? keyof TArray & `${number}` extends never // Enters this branch, if `TArray` is empty (e.g., []),
+ ? keyof TArray & `${number}` extends never ?
+// Enters this branch, if `TArray` is empty (e.g., []),
 // or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-? TArray extends readonly [...infer Rest, infer Last] ? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
-: TArray extends readonly [] ? [...ForwardAccumulator, ...BackwardAccumulator] : [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
-: TArray extends readonly [(infer First)?, ...infer Rest] ? _CollapseRestElement<Rest, [...ForwardAccumulator, '0' extends OptionalKeysOf<TArray> ? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
-: First], BackwardAccumulator> : never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
-: never; // Should never happen
-type Whitespace = '\u{9}' // '\t'
-| '\u{A}' // '\n'
-| '\u{B}' // '\v'
-| '\u{C}' // '\f'
-| '\u{D}' // '\r'
-| '\u{20}' // ' '
-| '\u{85}' | '\u{A0}' | '\u{1680}' | '\u{2000}' | '\u{2001}' | '\u{2002}' | '\u{2003}' | '\u{2004}' | '\u{2005}' | '\u{2006}' | '\u{2007}' | '\u{2008}' | '\u{2009}' | '\u{200A}' | '\u{2028}
' | '\u{2029}
' | '\u{202F}' | '\u{205F}' | '\u{3000}' | '\u{FEFF}';
+TArray extends readonly [...infer Rest, infer Last] ? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
+ : TArray extends readonly [] ? [...ForwardAccumulator, ...BackwardAccumulator] : [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
+ : TArray extends readonly [(infer First)?, ...infer Rest] ? _CollapseRestElement<Rest, [...ForwardAccumulator, '0' extends OptionalKeysOf<TArray> ? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+ : First], BackwardAccumulator> : never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+ : never; // Should never happen
+type Whitespace = '\t' // '\t'
+ | '\n' // '\n'
+ | '\v' // '\v'
+ | '\f' // '\f'
+ | '\r' // '\r'
+ | ' ' // ' '
+ | '…' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | '
' | '
' | ' ' | ' ' | '　' | '';
 type WordSeparators = '-' | '_' | Whitespace;
 type AsciiPunctuation = '!' | '"' | '#' | '$' | '%' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | '[' | '\\' | ']' | '^' | '_' | '`' | '{' | '|' | '}' | '~';
 declare const tag: unique symbol;
@@ -555,7 +559,7 @@ declare const tag: unique symbol;
 type TagContainer<Token> = {
   readonly [tag]: Token;
 };
-type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{ [K in Token]: TagMetadata }>;
+type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{ [K in Token]: TagMetadata; }>;
 /**
 Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf).
 
@@ -646,81 +650,7 @@ type WontWork = UnwrapTagged<string>;
 @category Type
 */
 type UnwrapTagged<TaggedType extends Tag<PropertyKey, any>> = RemoveAllTags<TaggedType>;
-type RemoveAllTags<T> = T extends Tag<PropertyKey, any> ? { [ThisTag in keyof T[typeof tag]]: T extends Tagged<infer Type, ThisTag, T[typeof tag][ThisTag]> ? RemoveAllTags<Type> : never }[keyof T[typeof tag]] : T;
-/**
-Note: The `Opaque` type is deprecated in favor of `Tagged`.
-
-Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for runtime values that would otherwise have the same type. (See examples.)
-
-The generic type parameters can be anything.
-
-Note that `Opaque` is somewhat of a misnomer here, in that, unlike [some alternative implementations](https://github.com/microsoft/TypeScript/issues/4895#issuecomment-425132582), the original, untagged type is not actually hidden. (E.g., functions that accept the untagged type can still be called with the "opaque" version -- but not vice-versa.)
-
-Also note that this implementation is limited to a single tag. If you want to allow multiple tags, use `Tagged` instead.
-
-[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
-
-There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
-	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
-	- [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
-	- [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
-
-@example
-```
-import type {Opaque} from 'type-fest';
-
-type AccountNumber = Opaque<number, 'AccountNumber'>;
-type AccountBalance = Opaque<number, 'AccountBalance'>;
-
-// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
-type ThingOne = Opaque<string>;
-type ThingTwo = Opaque<string>;
-
-// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
-// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
-type NewThingOne = Opaque<string, 'ThingOne'>;
-type NewThingTwo = Opaque<string, 'ThingTwo'>;
-
-// Now they're completely separate types, so the following will fail to compile.
-function createNewThingOne(): NewThingOne {
-	// As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
-	return 'new thing one' as NewThingOne;
-}
-
-// This will fail to compile, as they are fundamentally different types.
-// @ts-expect-error
-const thingTwo = createNewThingOne() as NewThingTwo;
-
-// Here's another example of opaque typing.
-function createAccountNumber(): AccountNumber {
-	return 2 as AccountNumber;
-}
-
-declare function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance;
-
-// This will compile successfully.
-getMoneyForAccount(createAccountNumber());
-
-// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
-// @ts-expect-error
-getMoneyForAccount(2);
-
-// You can use opaque values like they aren't opaque too.
-const accountNumber = createAccountNumber();
-
-// This will compile successfully.
-const newAccountNumber = accountNumber + 2;
-
-// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
-type Person = {
-	id: Opaque<number, Person>;
-	name: string;
-};
-```
-
-@category Type
-@deprecated Use {@link Tagged} instead
-*/
+type RemoveAllTags<T> = T extends Tag<PropertyKey, any> ? { [ThisTag in keyof T[typeof tag]]: T extends Tagged<infer Type, ThisTag, T[typeof tag][ThisTag]> ? RemoveAllTags<Type> : never; }[keyof T[typeof tag]] : T;
 /**
 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).
 
@@ -777,8 +707,13 @@ type L2 = Length<`${number}`>;
 @category Type Guard
 @category Utilities
 */
-type IsStringLiteral<S> = IfNotAnyOrNever<S, _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>, false, false>;
-type _IsStringLiteral<S> = // If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
+type IsStringLiteral<S> = IfNotAnyOrNever<S, {
+  ifNot: _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>;
+  ifAny: false;
+  ifNever: false;
+}>;
+type _IsStringLiteral<S> =
+// If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
 // and since `{}` extends index signatures, the result becomes `false`.
 S extends string ? {} extends Record<S, never> ? false : true : false;
 /**
@@ -805,34 +740,6 @@ type Example = Trim<' foo '>;
 */
 type Trim<V extends string> = TrimLeft<TrimRight<V>>;
 /**
-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;
-/**
 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
@@ -890,7 +797,7 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @see {@link SimplifyDeep}
 @category Object
 */
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -1011,7 +918,7 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 @see {@link PickIndexSignature}
 @category Object
 */
-type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType]; };
 /**
 Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 
@@ -1057,9 +964,9 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 @see {@link OmitIndexSignature}
 @category Object
 */
-type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
+type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType]; };
 // Merges two objects without worrying about index signatures.
-type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;
+type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key]; } & Source>;
 /**
 Merge two types into a new type. Keys of the second type overrides keys of the first type.
 
@@ -1123,10 +1030,9 @@ Note: If you want a merge type that more accurately reflects the runtime behavio
 @category Object
 */
 type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
-? Source extends unknown // For distributing `Source`
-? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
-: never;
-// Should never happen
+ ? Source extends unknown // For distributing `Source`
+ ? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
+ : never; // Should never happen
 type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 /**
 Merges user specified options with default options.
@@ -1180,9 +1086,9 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
 ```
 */
-type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
-? Result : never;
-type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key] }>>>;
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends (infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+) ? Result : never;
+type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key]; }>>>;
 /**
 Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
 
@@ -1210,33 +1116,42 @@ type E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined
 //=> string | null | undefined
 ```
 */
-type CollapseLiterals<T> = {} extends T ? T : T extends infer U & {} ? U : T;
+type CollapseLiterals<T> = {} extends T ? T : T extends (infer U) & {} ? U : T;
 /**
 @see {@link SomeExtend}
 */
 type SomeExtendOptions = {
   /**
-  Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
-  	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
-  - When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
-  	@default true
-  	@example
-  ```
-  import type {SomeExtend} from 'type-fest';
-  	type A = SomeExtend<[1, 2, never], string, {strictNever: true}>;
-  //=> false
-  	type B = SomeExtend<[1, 2, never], string, {strictNever: false}>;
-  //=> true
-  	type C = SomeExtend<[1, never], never, {strictNever: true}>;
-  //=> true
-  	type D = SomeExtend<[1, never], never, {strictNever: false}>;
-  //=> true
-  	type E = SomeExtend<[never], any, {strictNever: true}>;
-  //=> true
-  	type F = SomeExtend<[never], any, {strictNever: false}>;
-  //=> true
-  ```
-  */
+	Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+
+	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+	- When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+
+	@default true
+
+	@example
+	```
+	import type {SomeExtend} from 'type-fest';
+
+	type A = SomeExtend<[1, 2, never], string, {strictNever: true}>;
+	//=> false
+
+	type B = SomeExtend<[1, 2, never], string, {strictNever: false}>;
+	//=> true
+
+	type C = SomeExtend<[1, never], never, {strictNever: true}>;
+	//=> true
+
+	type D = SomeExtend<[1, never], never, {strictNever: false}>;
+	//=> true
+
+	type E = SomeExtend<[never], any, {strictNever: true}>;
+	//=> true
+
+	type F = SomeExtend<[never], any, {strictNever: false}>;
+	//=> true
+	```
+	*/
   strictNever?: boolean;
 };
 type DefaultSomeExtendOptions = {
@@ -1289,8 +1204,13 @@ type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
 @category Array
 */
 type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> = _SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
-type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
-? true : _SomeExtend<Rest, Type, Options> : First extends Type ? true : _SomeExtend<Rest, Type, Options> : false, false, false>;
+type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, {
+  ifNot: TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true ?
+  // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
+  true : _SomeExtend<Rest, Type, Options> : First extends Type ? true : _SomeExtend<Rest, Type, Options> : false;
+  ifAny: false;
+  ifNever: false;
+}>;
 /**
 Returns a boolean for whether any of the given elements is `true`.
 
@@ -1439,35 +1359,74 @@ type G = Or<never, never>;
 */
 type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
 /**
+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;
+/**
 @see {@link AllExtend}
 */
 type AllExtendOptions = {
   /**
-  Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
-  	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
-  - When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
-  	@default true
-  	@example
-  ```
-  import type {AllExtend} from 'type-fest';
-  	type A = AllExtend<[1, 2, never], number, {strictNever: true}>;
-  //=> false
-  	type B = AllExtend<[1, 2, never], number, {strictNever: false}>;
-  //=> true
-  	type C = AllExtend<[never, never], never, {strictNever: true}>;
-  //=> true
-  	type D = AllExtend<[never, never], never, {strictNever: false}>;
-  //=> true
-  	type E = AllExtend<['a', 'b', never], any, {strictNever: true}>;
-  //=> true
-  	type F = AllExtend<['a', 'b', never], any, {strictNever: false}>;
-  //=> true
-  	type G = AllExtend<[never, 1], never, {strictNever: true}>;
-  //=> false
-  	type H = AllExtend<[never, 1], never, {strictNever: false}>;
-  //=> false
-  ```
-  */
+	Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+
+	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+	- When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+
+	@default true
+
+	@example
+	```
+	import type {AllExtend} from 'type-fest';
+
+	type A = AllExtend<[1, 2, never], number, {strictNever: true}>;
+	//=> false
+
+	type B = AllExtend<[1, 2, never], number, {strictNever: false}>;
+	//=> true
+
+	type C = AllExtend<[never, never], never, {strictNever: true}>;
+	//=> true
+
+	type D = AllExtend<[never, never], never, {strictNever: false}>;
+	//=> true
+
+	type E = AllExtend<['a', 'b', never], any, {strictNever: true}>;
+	//=> true
+
+	type F = AllExtend<['a', 'b', never], any, {strictNever: false}>;
+	//=> true
+
+	type G = AllExtend<[never, 1], never, {strictNever: true}>;
+	//=> false
+
+	type H = AllExtend<[never, 1], never, {strictNever: false}>;
+	//=> false
+	```
+	*/
   strictNever?: boolean;
 };
 type DefaultAllExtendOptions = {
@@ -1520,8 +1479,13 @@ type B = AllExtend<[1?, 2?, 3?], number | undefined>;
 @category Array
 */
 type AllExtend<TArray extends UnknownArray, Type, Options extends AllExtendOptions = {}> = _AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
-type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, recurse further.
-? _AllExtend<Rest, Type, Options> : false : First extends Type ? _AllExtend<Rest, Type, Options> : false : true, false, false>;
+type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, {
+  ifNot: TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true ?
+  // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, recurse further.
+  _AllExtend<Rest, Type, Options> : false : First extends Type ? _AllExtend<Rest, Type, Options> : false : true;
+  ifAny: false;
+  ifNever: false;
+}>;
 /**
 Filter out keys from an object.
 
@@ -1552,10 +1516,12 @@ type Filtered = Filter<'bar', 'foo'>;
 type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
 type ExceptOptions = {
   /**
-  Disallow assigning non-specified properties.
-  	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
-  	@default false
-  */
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
   requireExactProps?: boolean;
 };
 type DefaultExceptOptions = {
@@ -1617,7 +1583,7 @@ type PostPayloadFixed = Except<UserData, 'email'>;
 @category Object
 */
 type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
-type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType]; } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
 /**
 Create a type that represents either the value or the value wrapped in `PromiseLike`.
 
@@ -1704,29 +1670,36 @@ Words options.
 */
 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']
-  ```
-  */
+	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']
-  ```
-  */
+	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 = {
@@ -1777,19 +1750,31 @@ type Words8 = Words<'hello::world', {splitOnPunctuation: true}>;
 @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>];
+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>];
 type _DefaultDelimiterCaseOptions = Merge<_DefaultWordsOptions, {
   splitOnNumbers: false;
 }>;
@@ -1838,7 +1823,7 @@ const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
 @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;
+ ? IsStringLiteral<Value> extends false ? Value : Lowercase<DelimiterCaseFromArray<Words<Value, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>, Delimiter>> : never : Value;
 /**
 Convert a string literal to kebab-case.
 
@@ -1877,8 +1862,8 @@ const rawCliOptions: KebabCasedProperties<CliOptions> = {
 @category Template literal
 */
 type KebabCase<Value, Options extends WordsOptions = {}> = DelimiterCase<Value, '-', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
-type DeepOmit<T, TKey extends PropertyKey> = [T] extends [Date | Function | Primitive] ? T : [Record<string, unknown>] extends [T] ? T : T extends object ? T extends unknown[] ? T extends readonly unknown[] ? { [K in keyof T]: DeepOmit<T[K], TKey> } : DeepOmit<T[number], TKey>[] : { [P in keyof T as P extends TKey ? never : P]: DeepOmit<T[P], TKey> } : T;
-type DeepOptionalUndefined<T> = T extends Date | Function | 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;
+type DeepOmit<T, TKey extends PropertyKey> = [T] extends [Date | Function | Primitive] ? T : [Record<string, unknown>] extends [T] ? T : T extends object ? T extends unknown[] ? T extends readonly unknown[] ? { [K in keyof T]: DeepOmit<T[K], TKey>; } : DeepOmit<T[number], TKey>[] : { [P in keyof T as P extends TKey ? never : P]: DeepOmit<T[P], TKey>; } : T;
+type DeepOptionalUndefined<T> = T extends Date | Function | 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;
 type ToData<T> = DeepOptionalUndefined<DeepOmit<T, "toJSON">>;
 interface WithMetadata<TBase extends Class<NonNullable<unknown>>> {
   new (...args: ConstructorParameters<TBase>): InstanceType<TBase> & ItemMetadata;
@@ -1886,6 +1871,7 @@ interface WithMetadata<TBase extends Class<NonNullable<unknown>>> {
 }
 declare const MAX_READ_LIMIT = 1000;
 declare const SITE_NAME = "Esposter";
+declare const createExponentialBackoff: (baseDelayMs: number, maxDelayMs: number) => (<T>(operation: () => Promise<T>) => Promise<T>);
 interface ErrorConfig {
   withStackTrace: boolean;
 }
@@ -1934,10 +1920,10 @@ declare type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends
 declare type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>> : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Errs[number][]>> : ResultAsync<Oks, Errs> : never : never;
 declare type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]> : never;
 declare type Writable<T> = T extends ReadonlyArray<unknown> ? [...T] : T;
-declare type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never };
-declare type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never };
-declare type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never };
-declare type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never };
+declare type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never; };
+declare type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never; };
+declare type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never; };
+declare type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never; };
 declare type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never;
 declare type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never;
 declare type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never;
@@ -2170,7 +2156,7 @@ declare type CollectResults<T, Collected extends unknown[] = [], Depth extends n
 declare type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
 declare type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [infer L, infer R] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
 declare type Dedup<T> = T extends Result<infer RL, infer RR> ? [unknown] extends [RL] ? Err<RL, RR> : Ok<RL, RR> : T;
-declare type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends ((v: infer V) => unknown) ? V : never : never) extends ((_: unknown) => infer W) ? [...MemberListOf<Exclude<T, W>>, W] : [];
+declare type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends (infer U) ? (U extends unknown ? (u: U) => unknown : never) extends ((v: infer V) => unknown) ? V : never : never) extends ((_: unknown) => infer W) ? [...MemberListOf<Exclude<T, W>>, W] : [];
 declare type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
 declare type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
 declare type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
@@ -2194,6 +2180,7 @@ declare const MENTION_TYPE_ATTRIBUTE = "data-type";
 declare const MENTION_TYPE = "mention";
 declare const MENTION_HERE_ID = "@here";
 declare const MENTION_EVERYONE_ID = "@everyone";
+//#region src/void-tag.d.ts
 declare class VoidTag {
   addClosingSlash: boolean;
   private voidTags;
@@ -2201,16 +2188,20 @@ declare class VoidTag {
   formatNode(tag: string, attrs: string, innerHTML: string): string;
   isVoidElement(tag: string): boolean;
 }
+//#endregion
+//#region src/nodes/type.d.ts
 declare enum NodeType {
   ELEMENT_NODE = 1,
   TEXT_NODE = 3,
   COMMENT_NODE = 8
 }
+//#endregion
+//#region src/nodes/node.d.ts
 /**
  * Node Class as base class for TextNode and HTMLElement.
  */
 declare abstract class Node {
-  parentNode: HTMLElement;
+  parentNode: HTMLElement | null;
   abstract rawTagName: string;
   abstract nodeType: NodeType;
   childNodes: Node[];
@@ -2219,7 +2210,7 @@ declare abstract class Node {
   abstract rawText: string;
   abstract toString(): string;
   abstract clone(): Node;
-  constructor(parentNode?: HTMLElement, range?: [number, number]);
+  constructor(parentNode?: HTMLElement | null, range?: [number, number]);
   /**
    * Remove current node
    */
@@ -2228,6 +2219,8 @@ declare abstract class Node {
   get textContent(): string;
   set textContent(val: string);
 }
+//#endregion
+//#region src/nodes/html.d.ts
 interface KeyAttributes {
   id?: string;
   class?: string;
@@ -2251,7 +2244,7 @@ declare class DOMTokenList {
   toggle(c: string): void;
   contains(c: string): boolean;
   get length(): number;
-  values(): IterableIterator<string>;
+  values(): SetIterator<string>;
   get value(): string[];
   toString(): string;
 }
@@ -2290,7 +2283,7 @@ declare class HTMLElement extends Node {
    *
    * @memberof HTMLElement
    */
-  constructor(tagName: string, keyAttrs: KeyAttributes, rawAttrs?: string, parentNode?: HTMLElement, range?: [number, number], voidTag?: VoidTag, _parseOptions?: Partial<Options>);
+  constructor(tagName: string, keyAttrs: KeyAttributes, rawAttrs?: string, parentNode?: HTMLElement | null, range?: [number, number], voidTag?: VoidTag, _parseOptions?: Partial<Options>);
   /**
    * Remove Child element from childNodes array
    * @param {HTMLElement} node     node to remove
@@ -2489,17 +2482,17 @@ declare const getMentions: (message: string) => HTMLElement[];
 declare const css: typeof String.raw;
 declare const html: typeof String.raw;
 declare const sanitizeHtml: (...[html, options]: Parameters<typeof baseSanitizeHtml>) => string;
-declare const sanitizeMessageHtml: (html: string) => string;
+declare const sanitizeTextHtml: (html: string) => string;
 declare const applyItemMetadataMixin: <TBase extends Class<NonNullable<unknown>>>(Base: TBase) => WithMetadata<TBase>;
-declare const SURVEY_DISPLAY_NAME = "Surveyer";
 declare const takeOne: TakeOne;
 declare const getIsServer: () => boolean;
 declare const noop: () => void;
 declare const ID_SEPARATOR = "|";
+declare const getOrCreate: <TKey, TValue>(map: Map<TKey, TValue>, key: TKey, create: () => TValue) => TValue;
 declare const checkIsPlainObject: (data: unknown) => data is object;
 declare const getPropertyNames: <T>() => PropertyNames<T>;
 declare const jsonDateParse: <T = any>(text: string) => T;
-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;
+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;
 declare const mergeObjectsStrict: <T extends object[]>(...objects: T) => MergeObjectsStrict<T>;
 declare const getRawData: <T>(data: T) => T;
 declare const toRawDeep: <T extends object>(data: T) => T;
@@ -2512,8 +2505,9 @@ declare const truncate: (string: string, length: number) => string;
 declare const uncapitalize: <T extends string>(string: T) => Uncapitalize<T>;
 declare const hrtime: (previousHrTime?: [number, number]) => [number, number];
 declare const now: () => string;
+declare const sleep: (durationMs: number) => Promise<void>;
 type BuildTuple<N extends number, T = unknown, R extends unknown[] = []> = R["length"] extends N ? R : BuildTuple<N, T, [...R, T]>;
-type FunctionProperties<T> = { [K in keyof T]: T[K] extends Function ? K : never };
+type FunctionProperties<T> = { [K in keyof T]: T[K] extends Function ? K : never; };
 type ExcludeFunctionProperties<T> = Except<T, FunctionProperties<T>[keyof T]>;
 type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
 type TupleSplit<T extends unknown[], N extends number> = T extends [...BuildTuple<N>, ...infer R] ? [T extends [...infer H, ...R] ? H : BuildTuple<N, T[number]>, R] : [T, []];
@@ -2526,7 +2520,6 @@ declare const exhaustiveGuard: (value: never) => never;
 type CreateUniqueArraySchema = (<TOutput extends object, TInput, TSchema extends z.ZodType<TOutput, TInput>>(schema: TSchema, key: UniqueArraySchemaKey<TSchema>) => z.ZodArray<TSchema>) & (<TSchema extends z.ZodType>(schema: TSchema) => z.ZodArray<TSchema>);
 type UniqueArraySchemaKey<TSchema extends z.ZodType> = TSchema extends z.ZodObject ? keyof TSchema["shape"] & string : keyof z.output<TSchema> & string;
 declare const createUniqueArraySchema: CreateUniqueArraySchema;
-declare const NIL = "00000000-0000-0000-0000-000000000000";
 declare const UUIDV4_REGEX: RegExp;
 declare const uuidValidateV4: (uuid: string) => boolean;
-export { AllSpecialValues, BuildTuple, ClassifiedMentions, CreateUniqueArraySchema, DeepOmit, DeepOptionalUndefined, ExcludeFunctionProperties, ForbiddenError, FunctionProperties, GetArrayProps, GetObjectProps, GetPaths, GetPrimitiveProps, GetProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, KnownKeys, MAX_READ_LIMIT, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_ITEM_TYPE_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MentionType, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, PropertyNames, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, SkipFirst, TakeFirst, TakeOne, ToData, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, UniqueArraySchemaKey, WithMetadata, applyItemMetadataMixin, capitalize, checkIsPlainObject, classifyMentions, createItemEntityTypeSchema, createNormalizedStringSchema, createUniqueArraySchema, css, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, getResult, getResultAsync, hrtime, html, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, noop, normalizeString, now, sanitizeHtml, sanitizeMessageHtml, streamToText, takeOne, toAppError, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4, withFinalizer, withFinalizerAsync };
+export { AllSpecialValues, BuildTuple, ClassifiedMentions, CreateUniqueArraySchema, DeepOmit, DeepOptionalUndefined, ExcludeFunctionProperties, ForbiddenError, FunctionProperties, GetArrayProps, GetObjectProps, GetPaths, GetPrimitiveProps, GetProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, KnownKeys, MAX_READ_LIMIT, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_ITEM_TYPE_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MentionType, MergeObjectsStrict, NotFoundError, NotInitializedError, Operation, PropertyNames, RoutePath, SITE_NAME, Serializable, SkipFirst, TakeFirst, TakeOne, ToData, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, UniqueArraySchemaKey, WithMetadata, applyItemMetadataMixin, capitalize, checkIsPlainObject, classifyMentions, createExponentialBackoff, createItemEntityTypeSchema, createNormalizedStringSchema, createUniqueArraySchema, css, exhaustiveGuard, getIsServer, getMentions, getOrCreate, getPropertyNames, getRawData, getResult, getResultAsync, hrtime, html, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, noop, normalizeString, now, sanitizeHtml, sanitizeTextHtml, sleep, streamToText, takeOne, toAppError, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4, withFinalizer, withFinalizerAsync };