@esposter/shared 2.18.2 → 2.19.2

package/dist/index.d.ts

@@ -1,6 +1,11 @@
 import { z } from "zod";
-import { HTMLElement } from "node-html-parser";
 
+//#region src/test/constants.d.ts
+declare const AllSpecialValues: {
+  isPlainObject: boolean;
+  value: unknown;
+}[];
+//#endregion
 //#region src/models/shared/Operation.d.ts
 declare enum Operation {
   Create = "Create",
@@ -8,7 +13,7 @@ declare enum Operation {
   Push = "Push",
   Read = "Read",
   Unshift = "Unshift",
-  Update = "Update",
+  Update = "Update"
 }
 //#endregion
 //#region src/models/error/InvalidOperationError.d.ts
@@ -17,13 +22,13 @@ declare class InvalidOperationError extends Error {
 }
 //#endregion
 //#region src/models/error/NotFoundError.d.ts
-declare class NotFoundError<T$1 extends string = string> extends Error {
-  constructor(name: T$1, id: string);
+declare class NotFoundError<T extends string = string> extends Error {
+  constructor(name: T, id: string);
 }
 //#endregion
 //#region src/models/error/NotInitializedError.d.ts
-declare class NotInitializedError<T$1 extends string = string> extends Error {
-  constructor(name: T$1);
+declare class NotInitializedError<T extends string = string> extends Error {
+  constructor(name: T);
 }
 //#endregion
 //#region src/models/router/RoutePath.d.ts
@@ -39,6 +44,7 @@ declare const RoutePath: {
   readonly Dungeons: "/dungeons";
   readonly EmailEditor: "/email-editor";
   readonly FlowchartEditor: "/flowchart-editor";
+  readonly FluidSimulator: "/fluid-simulator";
   readonly Github: "https://github.com/Esposter/Esposter";
   readonly Index: "/";
   readonly Login: "/login";
@@ -58,7 +64,7 @@ declare const RoutePath: {
 };
 type RoutePath = typeof RoutePath;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/primitive.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/primitive.d.ts
 /**
 Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
 
@@ -66,18 +72,18 @@ Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/
 */
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/basic.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/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$1, Arguments extends unknown[] = any[]> = {
-  prototype: Pick<T$1, keyof T$1>;
-  new (...arguments_: Arguments): T$1;
+type Class<T, Arguments extends unknown[] = any[]> = {
+  prototype: Pick<T, keyof T>;
+  new (...arguments_: Arguments): T;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/is-any.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/is-any.d.ts
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -106,9 +112,9 @@ const anyA = get(anyObject, 'a');
 @category Type Guard
 @category Utilities
 */
-type IsAny<T$1> = 0 extends 1 & NoInfer<T$1> ? true : false;
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/is-optional-key-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/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.
 
@@ -149,9 +155,9 @@ type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
 @category Type Guard
 @category Utilities
 */
-type IsOptionalKeyOf<Type extends object, Key$1 extends keyof Type> = IsAny<Type | Key$1> extends true ? never : Key$1 extends keyof Type ? Type extends Record<Key$1, Type[Key$1]> ? false : true : false;
+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.3.1/node_modules/type-fest/source/optional-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
 
@@ -189,7 +195,7 @@ type OptionalKeysOf<Type extends object> = Type extends unknown // For distribut
 ? (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;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/required-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/required-keys-of.d.ts
 /**
 Extract all required keys from the given type.
 
@@ -223,7 +229,7 @@ const validator3 = createValidation<User>('luckyNumber', value => value > 0);
 type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
 ? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/is-never.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -264,22 +270,22 @@ 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>;
-//   ^? type A = 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>;
-//   ^? type B = false
+//=> false
 ```
 
 @category Type Guard
 @category Utilities
 */
-type IsNever<T$1> = [T$1] extends [never] ? true : false;
+type IsNever<T> = [T] extends [never] ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/if.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/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`.
 
@@ -374,7 +380,7 @@ type Works = IncludesWithoutIf<HundredZeroes, '1'>;
 */
 type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/internal/type.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/internal/type.d.ts
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.
 */
@@ -387,12 +393,12 @@ Needed to handle the case of a single call signature with properties.
 Multiple call signatures cannot currently be supported due to a TypeScript limitation.
 @see https://github.com/microsoft/TypeScript/issues/29732
 */
-type HasMultipleCallSignatures<T$1 extends (...arguments_: any[]) => unknown> = T$1 extends {
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
   (...arguments_: infer A): unknown;
   (...arguments_: infer B): unknown;
 } ? B extends A ? A extends B ? false : true : true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/simplify.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/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.
 
@@ -451,9 +457,9 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @see {@link SimplifyDeep}
 @category Object
 */
-type Simplify<T$1> = { [KeyType in keyof T$1]: T$1[KeyType] } & {};
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/is-equal.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/is-equal.d.ts
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -484,7 +490,7 @@ type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false
 // This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
 type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/omit-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/omit-index-signature.d.ts
 /**
 Omit any index signatures from the given object type, leaving only explicitly defined properties.
 
@@ -504,7 +510,7 @@ 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
+// 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:
@@ -513,12 +519,16 @@ Instead of causing a type error like the above, you can also use a [conditional
 type Indexed = {} extends Record<string, unknown>
 	? '✅ `{}` is assignable to `Record<string, unknown>`'
 	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
-// => '✅ `{}` is 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>`';
-// => "❌ `{}` 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`...
@@ -566,7 +576,7 @@ type Example = {
 };
 
 type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
-// => { foo: 'bar'; qux?: 'baz' | undefined; }
+//=> {foo: 'bar'; qux?: 'baz'}
 ```
 
 @see {@link PickIndexSignature}
@@ -574,7 +584,7 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 */
 type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/pick-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/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.
 
@@ -622,10 +632,9 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 */
 type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/merge.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/merge.d.ts
 // Merges two objects without worrying about index signatures.
-type SimpleMerge<Destination, Source> = { [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.
 
@@ -648,7 +657,7 @@ type Bar = {
 };
 
 export type FooBar = Merge<Foo, Bar>;
-// => {
+//=> {
 // 	[x: string]: unknown;
 // 	[x: number]: number;
 // 	[x: symbol]: unknown;
@@ -658,11 +667,19 @@ export type FooBar = Merge<Foo, Bar>;
 // }
 ```
 
+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> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+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.3.1/node_modules/type-fest/source/internal/object.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/internal/object.d.ts
 /**
 Merges user specified options with default options.
 
@@ -717,7 +734,7 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 */
 type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/except.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/except.d.ts
 /**
 Filter out keys from an object.
 
@@ -745,7 +762,7 @@ type Filtered = Filter<'bar', 'foo'>;
 
 @see {Except}
 */
-type Filter<KeyType$1, ExcludeType> = IsEqual<KeyType$1, ExcludeType> extends true ? never : (KeyType$1 extends ExcludeType ? never : KeyType$1);
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
 type ExceptOptions = {
   /**
   Disallow assigning non-specified properties.
@@ -757,7 +774,6 @@ type ExceptOptions = {
 type DefaultExceptOptions = {
   requireExactProps: false;
 };
-
 /**
 Create a type from an object type without certain keys.
 
@@ -781,14 +797,14 @@ type FooWithoutA = Except<Foo, 'a'>;
 
 // @ts-expect-error
 const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
-//=> errors: 'a' does not exist in type '{ b: string; }'
+// errors: 'a' does not exist in type '{ b: string; }'
 
 type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
-//=> {a: number} & Partial<Record<"b", never>>
+//=> {a: number} & Partial<Record<'b', never>>
 
 // @ts-expect-error
 const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
-//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+// errors at 'b': Type 'string' is not assignable to type 'undefined'.
 
 // The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
 
@@ -803,12 +819,12 @@ type UserData = {
 
 // `Omit` clearly doesn't behave as expected in this case:
 type PostPayload = Omit<UserData, 'email'>;
-//=> { [x: string]: string; [x: number]: string; }
+//=> {[x: string]: string; [x: number]: string}
 
 // In situations like this, `Except` works better.
 // It simply removes the `email` key while preserving all the other keys.
 type PostPayloadFixed = Except<UserData, 'email'>;
-//=> { [x: string]: string; name: string; role: 'admin' | 'user'; }
+//=> {[x: string]: string; name: string; role: 'admin' | 'user'}
 ```
 
 @category Object
@@ -816,7 +832,7 @@ type PostPayloadFixed = Except<UserData, 'email'>;
 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>> : {});
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/required-deep.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/required-deep.d.ts
 /**
 Create a type from another type with all keys and nested keys set to required.
 
@@ -858,19 +874,20 @@ Note that types containing overloaded functions are not made deeply required due
 @category Set
 @category Map
 */
-type RequiredDeep<T$1> = T$1 extends BuiltIns ? T$1 : T$1 extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T$1 extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : T$1 extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T$1 extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : T$1 extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T$1 extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : T$1 extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : T$1 extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T$1> extends true ? T$1 : HasMultipleCallSignatures<T$1> extends true ? T$1 : ((...arguments_: Parameters<T$1>) => ReturnType<T$1>) & RequiredObjectDeep<T$1> : T$1 extends object ? RequiredObjectDeep<T$1> : unknown;
+type RequiredDeep<T> = T extends BuiltIns ? T : T extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : T extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : T extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : T extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T> extends true ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & RequiredObjectDeep<T> : T extends object ? Simplify<RequiredObjectDeep<T>> // `Simplify` to prevent `RequiredObjectDeep` from appearing in the resulting type
+: unknown;
 type RequiredObjectDeep<ObjectType extends object> = { [KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]> };
 //#endregion
 //#region src/util/types/PropertyNames.d.ts
-type PropertyNames<T$1> = RequiredDeep<{ [P in keyof T$1]: P }>;
+type PropertyNames<T> = RequiredDeep<{ [P in keyof T]: P }>;
 //#endregion
 //#region src/models/shared/ItemEntityType.d.ts
-interface ItemEntityType<T$1 extends string> {
-  type: T$1;
+interface ItemEntityType<T extends string> {
+  type: T;
 }
 declare const ItemEntityTypePropertyNames: PropertyNames<ItemEntityType<string>>;
-declare const createItemEntityTypeSchema: <T$1 extends z.ZodType<string>>(schema: T$1) => z.ZodObject<{
-  type: T$1;
+declare const createItemEntityTypeSchema: <T extends z.ZodType<string>>(schema: T) => z.ZodObject<{
+  type: T;
 }>;
 //#endregion
 //#region src/models/shared/ItemMetadata.d.ts
@@ -891,23 +908,29 @@ declare abstract class Serializable {
   toJSON(): string;
 }
 //#endregion
+//#region src/models/shared/TakeOne.d.ts
+interface TakeOne {
+  <T extends readonly unknown[]>(values: T, index?: number): T[number];
+  <T extends Record<PropertyKey, unknown>>(values: T, index: keyof T): T[keyof T];
+}
+//#endregion
 //#region src/util/types/DeepOmitArray.d.ts
 type DeepOmitArray<TArray extends unknown[], TKey> = { [P in keyof TArray]: DeepOmit<TArray[P], TKey> };
 //#endregion
 //#region src/util/types/DeepOmit.d.ts
-type DeepOmit<T$1, TKey> = T$1 extends Primitive ? T$1 : { [P in Exclude<keyof T$1, TKey>]: T$1[P] extends infer TP ? TP extends Date | Function | Primitive ? TP : TP extends unknown[] ? DeepOmitArray<TP, TKey> : Record<string, unknown> extends TP ? TP : DeepOmit<TP, TKey> : never };
+type DeepOmit<T, TKey> = T extends Primitive ? T : { [P in Exclude<keyof T, TKey>]: T[P] extends infer TP ? TP extends Date | Function | Primitive ? TP : TP extends unknown[] ? DeepOmitArray<TP, TKey> : Record<string, unknown> extends TP ? TP : DeepOmit<TP, TKey> : never };
 //#endregion
 //#region src/util/types/DeepOptionalProperties.d.ts
-type DeepOptionalProperties<T$1> = { [K in keyof T$1 as undefined extends T$1[K] ? K : never]?: DeepOptionalProperties<T$1[K]> };
+type DeepOptionalProperties<T> = { [K in keyof T as undefined extends T[K] ? K : never]?: DeepOptionalProperties<T[K]> };
 //#endregion
 //#region src/util/types/DeepRequiredProperties.d.ts
-type DeepRequiredProperties<T$1> = { [K in keyof T$1 as undefined extends T$1[K] ? never : K]: DeepRequiredProperties<T$1[K]> };
+type DeepRequiredProperties<T> = { [K in keyof T as undefined extends T[K] ? never : K]: DeepRequiredProperties<T[K]> };
 //#endregion
 //#region src/util/types/DeepOptionalUndefined.d.ts
-type DeepOptionalUndefined<T$1> = T$1 extends ((...args: unknown[]) => unknown) ? T$1 : T$1 extends (infer U)[] ? DeepOptionalUndefined<U>[] : T$1 extends readonly (infer U)[] ? readonly DeepOptionalUndefined<U>[] : T$1 extends Date ? T$1 : T$1 extends object ? keyof T$1 extends never ? never : DeepOptionalProperties<T$1> extends Record<never, unknown> ? DeepRequiredProperties<T$1> : DeepRequiredProperties<T$1> extends Record<never, unknown> ? DeepOptionalProperties<T$1> : DeepOptionalProperties<T$1> & DeepRequiredProperties<T$1> : T$1;
+type DeepOptionalUndefined<T> = T extends ((...args: unknown[]) => unknown) ? T : T extends (infer U)[] ? DeepOptionalUndefined<U>[] : T extends readonly (infer U)[] ? readonly DeepOptionalUndefined<U>[] : T extends Date ? T : T extends object ? keyof T extends never ? never : DeepOptionalProperties<T> extends Record<never, unknown> ? DeepRequiredProperties<T> : DeepRequiredProperties<T> extends Record<never, unknown> ? DeepOptionalProperties<T> : DeepOptionalProperties<T> & DeepRequiredProperties<T> : T;
 //#endregion
 //#region src/models/shared/ToData.d.ts
-type ToData<T$1 extends Serializable> = DeepOptionalUndefined<DeepOmit<T$1, "toJSON">>;
+type ToData<T extends Serializable> = DeepOptionalUndefined<DeepOmit<T, "toJSON">>;
 //#endregion
 //#region src/models/shared/WithMetadata.d.ts
 interface WithMetadata<TBase extends Class<NonNullable<unknown>>> {
@@ -924,6 +947,294 @@ declare const MENTION_LABEL_ATTRIBUTE = "data-label";
 declare const MENTION_TYPE_ATTRIBUTE = "data-type";
 declare const MENTION_TYPE = "mention";
 //#endregion
+//#region ../../node_modules/.pnpm/node-html-parser@7.0.2/node_modules/node-html-parser/dist/void-tag.d.ts
+declare class VoidTag {
+  addClosingSlash: boolean;
+  private voidTags;
+  constructor(addClosingSlash?: boolean, tags?: string[]);
+  formatNode(tag: string, attrs: string, innerHTML: string): string;
+  isVoidElement(tag: string): boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/node-html-parser@7.0.2/node_modules/node-html-parser/dist/nodes/type.d.ts
+declare enum NodeType {
+  ELEMENT_NODE = 1,
+  TEXT_NODE = 3,
+  COMMENT_NODE = 8
+}
+//#endregion
+//#region ../../node_modules/.pnpm/node-html-parser@7.0.2/node_modules/node-html-parser/dist/nodes/node.d.ts
+/**
+ * Node Class as base class for TextNode and HTMLElement.
+ */
+declare abstract class Node {
+  parentNode: HTMLElement;
+  abstract rawTagName: string;
+  abstract nodeType: NodeType;
+  childNodes: Node[];
+  range: readonly [number, number];
+  abstract text: string;
+  abstract rawText: string;
+  abstract toString(): string;
+  abstract clone(): Node;
+  constructor(parentNode?: HTMLElement, range?: [number, number]);
+  /**
+   * Remove current node
+   */
+  remove(): this;
+  get innerText(): string;
+  get textContent(): string;
+  set textContent(val: string);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/node-html-parser@7.0.2/node_modules/node-html-parser/dist/nodes/html.d.ts
+interface KeyAttributes {
+  id?: string;
+  class?: string;
+}
+interface Attributes {
+  [key: string]: string;
+}
+interface RawAttributes {
+  [key: string]: string;
+}
+type InsertPosition = 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend';
+type NodeInsertable = Node | string;
+declare class DOMTokenList {
+  private _set;
+  private _afterUpdate;
+  private _validate;
+  constructor(valuesInit?: string[], afterUpdate?: (t: DOMTokenList) => void);
+  add(c: string): void;
+  replace(c1: string, c2: string): void;
+  remove(c: string): void;
+  toggle(c: string): void;
+  contains(c: string): boolean;
+  get length(): number;
+  values(): IterableIterator<string>;
+  get value(): string[];
+  toString(): string;
+}
+/**
+ * HTMLElement, which contains a set of children.
+ *
+ * Note: this is a minimalist implementation, no complete tree
+ *   structure provided (no parentNode, nextSibling,
+ *   previousSibling etc).
+ * @class HTMLElement
+ * @extends {Node}
+ */
+declare class HTMLElement extends Node {
+  rawAttrs: string;
+  private voidTag;
+  private _attrs;
+  private _rawAttrs;
+  private _parseOptions;
+  private _id;
+  rawTagName: string;
+  classList: DOMTokenList;
+  /**
+   * Node Type declaration.
+   */
+  nodeType: NodeType;
+  /**
+   * Quote attribute values
+   * @param attr attribute value
+   * @returns {string} quoted value
+   */
+  private quoteAttribute;
+  /**
+   * Creates an instance of HTMLElement.
+   * @param keyAttrs	id and class attribute
+   * @param [rawAttrs]	attributes in string
+   *
+   * @memberof HTMLElement
+   */
+  constructor(tagName: string, keyAttrs: KeyAttributes, rawAttrs?: string, parentNode?: HTMLElement, range?: [number, number], voidTag?: VoidTag, _parseOptions?: Partial<Options>);
+  /**
+   * Remove Child element from childNodes array
+   * @param {HTMLElement} node     node to remove
+   */
+  removeChild(node: Node): this;
+  /**
+   * Exchanges given child with new child
+   * @param {HTMLElement} oldNode     node to exchange
+   * @param {HTMLElement} newNode     new node
+   */
+  exchangeChild(oldNode: Node, newNode: Node): this;
+  get tagName(): string;
+  set tagName(newname: string);
+  get localName(): string;
+  get isVoidElement(): boolean;
+  get id(): string;
+  set id(newid: string);
+  /**
+   * Get escpaed (as-it) text value of current node and its children.
+   * @return {string} text content
+   */
+  get rawText(): string;
+  get textContent(): string;
+  set textContent(val: string);
+  /**
+   * Get unescaped text value of current node and its children.
+   * @return {string} text content
+   */
+  get text(): string;
+  /**
+   * Get structured Text (with '\n' etc.)
+   * @return {string} structured text
+   */
+  get structuredText(): string;
+  toString(): string;
+  get innerHTML(): string;
+  set innerHTML(content: string);
+  set_content(content: string | Node | Node[], options?: Partial<Options>): this;
+  replaceWith(...nodes: (string | Node)[]): this;
+  get outerHTML(): string;
+  /**
+   * Trim element from right (in block) after seeing pattern in a TextNode.
+   * @param  {RegExp} pattern pattern to find
+   * @return {HTMLElement}    reference to current node
+   */
+  trimRight(pattern: RegExp): this;
+  /**
+   * Get DOM structure
+   * @return {string} structure
+   */
+  get structure(): string;
+  /**
+   * Remove whitespaces in this sub tree.
+   * @return {HTMLElement} pointer to this
+   */
+  removeWhitespace(): this;
+  /**
+   * Query CSS selector to find matching nodes.
+   * @param  {string}         selector Simplified CSS selector
+   * @return {HTMLElement[]}  matching elements
+   */
+  querySelectorAll(selector: string): HTMLElement[];
+  /**
+   * Query CSS Selector to find matching node.
+   * @param  {string}         selector Simplified CSS selector
+   * @return {(HTMLElement|null)}    matching node
+   */
+  querySelector(selector: string): HTMLElement | null;
+  /**
+   * find elements by their tagName
+   * @param {string} tagName the tagName of the elements to select
+   */
+  getElementsByTagName(tagName: string): Array<HTMLElement>;
+  /**
+   * find element by it's id
+   * @param {string} id the id of the element to select
+   * @returns {HTMLElement | null} the element with the given id or null if not found
+   */
+  getElementById(id: string): HTMLElement | null;
+  /**
+   * traverses the Element and its parents (heading toward the document root) until it finds a node that matches the provided selector string. Will return itself or the matching ancestor. If no such element exists, it returns null.
+   * @param selector a DOMString containing a selector list
+   * @returns {HTMLElement | null} the element with the given id or null if not found
+   */
+  closest(selector: string): HTMLElement | null;
+  /**
+   * Append a child node to childNodes
+   * @param  {Node} node node to append
+   * @return {Node}      node appended
+   */
+  appendChild<T extends Node = Node>(node: T): T;
+  /**
+   * Get attributes
+   * @access private
+   * @return {Object} parsed and unescaped attributes
+   */
+  get attrs(): Attributes;
+  get attributes(): Record<string, string>;
+  /**
+   * Get escaped (as-is) attributes
+   * @return {Object} parsed attributes
+   */
+  get rawAttributes(): RawAttributes;
+  removeAttribute(key: string): this;
+  hasAttribute(key: string): boolean;
+  /**
+   * Get an attribute
+   * @return {string | undefined} value of the attribute; or undefined if not exist
+   */
+  getAttribute(key: string): string | undefined;
+  /**
+   * Set an attribute value to the HTMLElement
+   * @param {string} key The attribute name
+   * @param {string} value The value to set, or null / undefined to remove an attribute
+   */
+  setAttribute(key: string, value: string): this;
+  /**
+   * Replace all the attributes of the HTMLElement by the provided attributes
+   * @param {Attributes} attributes the new attribute set
+   */
+  setAttributes(attributes: Attributes): this;
+  insertAdjacentHTML(where: InsertPosition, html: string): this;
+  /** Prepend nodes or strings to this node's children. */
+  prepend(...insertable: NodeInsertable[]): void;
+  /** Append nodes or strings to this node's children. */
+  append(...insertable: NodeInsertable[]): void;
+  /** Insert nodes or strings before this node. */
+  before(...insertable: NodeInsertable[]): void;
+  /** Insert nodes or strings after this node. */
+  after(...insertable: NodeInsertable[]): void;
+  get nextSibling(): Node | null;
+  get nextElementSibling(): HTMLElement | null;
+  get previousSibling(): Node | null;
+  get previousElementSibling(): HTMLElement | null;
+  /** Get all childNodes of type {@link HTMLElement}. */
+  get children(): HTMLElement[];
+  /**
+   * Get the first child node.
+   * @return The first child or undefined if none exists.
+   */
+  get firstChild(): Node | undefined;
+  /**
+   * Get the first child node of type {@link HTMLElement}.
+   * @return The first child element or undefined if none exists.
+   */
+  get firstElementChild(): HTMLElement | undefined;
+  /**
+   * Get the last child node.
+   * @return The last child or undefined if none exists.
+   */
+  get lastChild(): Node | undefined;
+  /**
+   * Get the last child node of type {@link HTMLElement}.
+   * @return The last child element or undefined if none exists.
+   */
+  get lastElementChild(): HTMLElement | undefined;
+  get childElementCount(): number;
+  get classNames(): string;
+  /** Clone this Node */
+  clone(): Node;
+}
+interface Options {
+  lowerCaseTagName?: boolean;
+  comment?: boolean;
+  /**
+   * @see PR #215 for explanation
+   */
+  fixNestedATags?: boolean;
+  parseNoneClosedTags?: boolean;
+  blockTextElements: {
+    [tag: string]: boolean;
+  };
+  voidTag?: {
+    /**
+     * options, default value is ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']
+     */
+    tags?: string[];
+    /**
+     * void tag serialisation, add a final slash <br/>
+     */
+    closingSlash?: boolean;
+  };
+}
+//#endregion
 //#region src/services/message/getMentions.d.ts
 declare const getMentions: (message: string) => HTMLElement[];
 //#endregion
@@ -939,6 +1250,9 @@ declare const applyItemMetadataMixin: <TBase extends Class<NonNullable<unknown>>
 //#region src/services/survey/constants.d.ts
 declare const SURVEY_DISPLAY_NAME = "Surveyer";
 //#endregion
+//#region src/util/array/takeOne.d.ts
+declare const takeOne: TakeOne;
+//#endregion
 //#region src/util/environment/getIsServer.d.ts
 declare const getIsServer: () => boolean;
 //#endregion
@@ -946,7 +1260,7 @@ declare const getIsServer: () => boolean;
 declare const ID_SEPARATOR = "|";
 //#endregion
 //#region src/util/object/getPropertyNames.d.ts
-declare const getPropertyNames: <T$1>() => PropertyNames<T$1>;
+declare const getPropertyNames: <T>() => PropertyNames<T>;
 //#endregion
 //#region src/util/object/isPlainObject.d.ts
 declare const isPlainObject: (data: unknown) => data is object;
@@ -955,16 +1269,16 @@ declare const isPlainObject: (data: unknown) => data is object;
 declare const jsonDateParse: (text: string) => any;
 //#endregion
 //#region src/util/types/MergeObjectsStrict.d.ts
-type MergeObjectsStrict<T$1 extends object[]> = T$1 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$1 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;
 //#endregion
 //#region src/util/object/mergeObjectsStrict.d.ts
-declare const mergeObjectsStrict: <T$1 extends object[]>(...objects: T$1) => MergeObjectsStrict<T$1>;
+declare const mergeObjectsStrict: <T extends object[]>(...objects: T) => MergeObjectsStrict<T>;
 //#endregion
 //#region src/util/reactivity/getRawData.d.ts
-declare const getRawData: <T$1>(data: T$1) => T$1;
+declare const getRawData: <T>(data: T) => T;
 //#endregion
 //#region src/util/reactivity/toRawDeep.d.ts
-declare const toRawDeep: <T$1 extends object>(data: T$1) => T$1;
+declare const toRawDeep: <T extends object>(data: T) => T;
 //#endregion
 //#region src/util/regex/escapeRegExp.d.ts
 declare const escapeRegExp: (string: string) => string;
@@ -979,13 +1293,13 @@ declare const streamToText: (readable: NodeJS.ReadableStream) => Promise<string>
 type CamelToKebab<S extends string> = S extends `${infer T}${infer U}` ? U extends Uncapitalize<U> ? `${Uncapitalize<T>}${CamelToKebab<U>}` : `${Uncapitalize<T>}-${CamelToKebab<U>}` : S;
 //#endregion
 //#region src/util/text/toKebabCase.d.ts
-declare const toKebabCase: <T$1 extends string>(string: T$1) => CamelToKebab<T$1>;
+declare const toKebabCase: <T extends string>(string: T) => CamelToKebab<T>;
 //#endregion
 //#region src/util/text/truncate.d.ts
 declare const truncate: (string: string, length: number) => string;
 //#endregion
 //#region src/util/text/uncapitalize.d.ts
-declare const uncapitalize: <T$1 extends string>(string: T$1) => Uncapitalize<T$1>;
+declare const uncapitalize: <T extends string>(string: T) => Uncapitalize<T>;
 //#endregion
 //#region src/util/time/hrtime.d.ts
 declare const hrtime: (previousHrTime?: [number, number]) => [number, number];
@@ -994,10 +1308,10 @@ declare const hrtime: (previousHrTime?: [number, number]) => [number, number];
 declare const now: () => string;
 //#endregion
 //#region src/util/types/FunctionProperties.d.ts
-type FunctionProperties<T$1> = { [K in keyof T$1]: T$1[K] extends Function ? K : never };
+type FunctionProperties<T> = { [K in keyof T]: T[K] extends Function ? K : never };
 //#endregion
 //#region src/util/types/ExcludeFunctionProperties.d.ts
-type ExcludeFunctionProperties<T$1> = Except<T$1, FunctionProperties<T$1>[keyof T$1]>;
+type ExcludeFunctionProperties<T> = Except<T, FunctionProperties<T>[keyof T]>;
 //#endregion
 //#region src/util/types/KebabToCamel.d.ts
 type KebabToCamel<S extends string> = S extends `${infer T}-${infer U}` ? `${T}${Capitalize<KebabToCamel<U>>}` : S;
@@ -1006,25 +1320,25 @@ type KebabToCamel<S extends string> = S extends `${infer T}-${infer U}` ? `${T}$
 type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
 //#endregion
 //#region src/util/types/PartialByKeys.d.ts
-type PartialByKeys<T$1, K$1 extends keyof T$1 = keyof T$1> = Except<T$1, K$1> & Partial<Pick<T$1, Extract<keyof T$1, K$1>>>;
+type PartialByKeys<T, K extends keyof T = keyof T> = Except<T, K> & Partial<Pick<T, Extract<keyof T, K>>>;
 //#endregion
 //#region src/util/types/TupleSplitHead.d.ts
-type TupleSplitHead<T$1 extends unknown[], N extends number> = T$1["length"] extends N ? T$1 : T$1 extends [...infer R, unknown] ? TupleSplitHead<R, N> : never;
+type TupleSplitHead<T extends unknown[], N extends number> = T["length"] extends N ? T : T extends [...infer R, unknown] ? TupleSplitHead<R, N> : never;
 //#endregion
 //#region src/util/types/TupleSplitTail.d.ts
-type TupleSplitTail<T$1, N extends number, O extends unknown[] = []> = O["length"] extends N ? T$1 : T$1 extends [infer F, ...infer R] ? TupleSplitTail<[...R], N, [...O, F]> : never;
+type TupleSplitTail<T, N extends number, O extends unknown[] = []> = O["length"] extends N ? T : T extends [infer F, ...infer R] ? TupleSplitTail<[...R], N, [...O, F]> : never;
 //#endregion
 //#region src/util/types/TupleSplit.d.ts
-type TupleSplit<T$1 extends unknown[], N extends number> = [TupleSplitHead<T$1, N>, TupleSplitTail<T$1, N>];
+type TupleSplit<T extends unknown[], N extends number> = [TupleSplitHead<T, N>, TupleSplitTail<T, N>];
 //#endregion
 //#region src/util/types/SkipFirst.d.ts
-type SkipFirst<T$1 extends unknown[], N extends number> = TupleSplit<T$1, N>[1];
+type SkipFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[1];
 //#endregion
 //#region src/util/types/TakeFirst.d.ts
-type TakeFirst<T$1 extends unknown[], N extends number> = TupleSplit<T$1, N>[0];
+type TakeFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[0];
 //#endregion
 //#region src/util/types/TupleSlice.d.ts
-type TupleSlice<T$1 extends unknown[], S extends number, E extends number = T$1["length"]> = SkipFirst<TakeFirst<T$1, E>, S>;
+type TupleSlice<T extends unknown[], S extends number, E extends number = T["length"]> = SkipFirst<TakeFirst<T, E>, S>;
 //#endregion
 //#region src/util/validation/exhaustiveGuard.d.ts
 declare const exhaustiveGuard: (value: never) => never;
@@ -1036,4 +1350,4 @@ declare const UUIDV4_REGEX: RegExp;
 //#region src/util/id/uuid/uuidValidateV4.d.ts
 declare const uuidValidateV4: (uuid: string) => boolean;
 //#endregion
-export { CamelToKebab, DeepOmit, DeepOmitArray, DeepOptionalProperties, DeepOptionalUndefined, DeepRequiredProperties, ExcludeFunctionProperties, FunctionProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, KebabToCamel, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, PartialByKeys, PropertyNames, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, SkipFirst, TakeFirst, ToData, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, WithMetadata, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, now, streamToText, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4 };
+export { AllSpecialValues, CamelToKebab, DeepOmit, DeepOmitArray, DeepOptionalProperties, DeepOptionalUndefined, DeepRequiredProperties, ExcludeFunctionProperties, FunctionProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, KebabToCamel, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, PartialByKeys, PropertyNames, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, SkipFirst, TakeFirst, TakeOne, ToData, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, WithMetadata, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, now, streamToText, takeOne, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4 };