dep 1.0.0 → 1.1.0

package/node_modules/boxen/node_modules/type-fest/source/set-required-deep.d.ts

@@ -1,68 +0,0 @@
-import type {IsAny} from './is-any';
-import type {NonRecursiveType, StringToNumber} from './internal';
-import type {Paths} from './paths';
-import type {SetRequired} from './set-required';
-import type {SimplifyDeep} from './simplify-deep';
-import type {UnionToTuple} from './union-to-tuple';
-import type {RequiredDeep} from './required-deep';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Create a type that makes the given keys required. You can specify deeply nested key paths. The remaining keys are kept as is.
-
-Use-case: Selectively make nested properties required in complex types like models.
-
-@example
-```
-import type {SetRequiredDeep} from 'type-fest';
-
-type Foo = {
-	a?: number;
-	b?: string;
-	c?: {
-		d?: number
-	}[]
-}
-
-type SomeRequiredDeep = SetRequiredDeep<Foo, 'a' | `c.${number}.d`>;
-// type SomeRequiredDeep = {
-// 	a: number; // Is now required
-// 	b?: string;
-// 	c: {
-// 		d: number // Is now required
-// 	}[]
-// }
-
-// Set specific indices in an array to be required.
-type ArrayExample = SetRequiredDeep<{a: [number?, number?, number?]}, 'a.0' | 'a.1'>;
-//=> {a: [number, number, number?]}
-```
-
-@category Object
-*/
-export type SetRequiredDeep<BaseType, KeyPaths extends Paths<BaseType>> = IsAny<KeyPaths> extends true
-	? SimplifyDeep<RequiredDeep<BaseType>>
-	: SetRequiredDeepHelper<BaseType, UnionToTuple<KeyPaths>>;
-
-/**
-Internal helper for {@link SetRequiredDeep}.
-
-Recursively transforms the `BaseType` by applying {@link SetRequiredDeepSinglePath} for each path in `KeyPathsTuple`.
-*/
-type SetRequiredDeepHelper<BaseType, KeyPathsTuple extends UnknownArray> =
-	KeyPathsTuple extends [infer KeyPath, ...infer RestPaths]
-		? SetRequiredDeepHelper<SetRequiredDeepSinglePath<BaseType, KeyPath>, RestPaths>
-		: BaseType;
-
-/**
-Makes a single path required in `BaseType`.
-*/
-type SetRequiredDeepSinglePath<BaseType, KeyPath> = BaseType extends NonRecursiveType
-	? BaseType
-	: KeyPath extends `${infer Property}.${infer RestPath}`
-		? {
-			[Key in keyof BaseType]: Property extends `${Key & (string | number)}`
-				? SetRequiredDeepSinglePath<BaseType[Key], RestPath>
-				: BaseType[Key];
-		}
-		: SetRequired<BaseType, (KeyPath | StringToNumber<KeyPath & string>) & keyof BaseType>;

package/node_modules/boxen/node_modules/type-fest/source/set-required.d.ts

@@ -1,70 +0,0 @@
-import type {Except} from './except';
-import type {HomomorphicPick, IfArrayReadonly} from './internal';
-import type {OptionalKeysOf} from './optional-keys-of';
-import type {Simplify} from './simplify';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
-
-Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
-
-@example
-```
-import type {SetRequired} from 'type-fest';
-
-type Foo = {
-	a?: number;
-	b: string;
-	c?: boolean;
-}
-
-type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
-// type SomeRequired = {
-// 	a?: number;
-// 	b: string; // Was already required and still is.
-// 	c: boolean; // Is now required.
-// }
-
-// Set specific indices in an array to be required.
-type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
-//=> [number, number, number?]
-```
-
-@category Object
-*/
-export type SetRequired<BaseType, Keys extends keyof BaseType> =
-	BaseType extends UnknownArray
-		? SetArrayRequired<BaseType, Keys> extends infer ResultantArray
-			? IfArrayReadonly<BaseType, Readonly<ResultantArray>, ResultantArray>
-			: never
-		: Simplify<
-		// Pick just the keys that are optional from the base type.
-		Except<BaseType, Keys> &
-		// Pick the keys that should be required from the base type and make them required.
-		Required<HomomorphicPick<BaseType, Keys>>
-		>;
-
-/**
-Remove the optional modifier from the specified keys in an array.
-*/
-type SetArrayRequired<
-	TArray extends UnknownArray,
-	Keys,
-	Counter extends any[] = [],
-	Accumulator extends UnknownArray = [],
-> = TArray extends unknown // For distributing `TArray` when it's a union
-	? keyof TArray & `${number}` extends never
-		// Exit if `TArray` is empty (e.g., []), or
-		// `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-		? [...Accumulator, ...TArray]
-		: TArray extends readonly [(infer First)?, ...infer Rest]
-			? '0' extends OptionalKeysOf<TArray> // If the first element of `TArray` is optional
-				? `${Counter['length']}` extends `${Keys & (string | number)}` // If the current index needs to be required
-					? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]>
-					// If the current element is optional, but it doesn't need to be required,
-					// then we can exit early, since no further elements can now be made required.
-					: [...Accumulator, ...TArray]
-				: SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]>
-			: never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
-	: never; // Should never happen

package/node_modules/boxen/node_modules/type-fest/source/set-return-type.d.ts

@@ -1,29 +0,0 @@
-import type {IsUnknown} from './is-unknown';
-
-/**
-Create a function type with a return type of your choice and the same parameters as the given function type.
-
-Use-case: You want to define a wrapped function that returns something different while receiving the same parameters. For example, you might want to wrap a function that can throw an error into one that will return `undefined` instead.
-
-@example
-```
-import type {SetReturnType} from 'type-fest';
-
-type MyFunctionThatCanThrow = (foo: SomeType, bar: unknown) => SomeOtherType;
-
-type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | undefined>;
-//=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
-```
-
-@category Function
-*/
-export type SetReturnType<Function_ extends (...arguments_: any[]) => any, TypeToReturn> =
-	// Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
-	Function_ extends (this: infer ThisArgument, ...arguments_: infer Arguments) => any ? (
-		// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
-		// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
-		IsUnknown<ThisArgument> extends true ? (...arguments_: Arguments) => TypeToReturn : (this: ThisArgument, ...arguments_: Arguments) => TypeToReturn
-	) : (
-		// This part should be unreachable, but we make it meaningful just in case…
-		(...arguments_: Parameters<Function_>) => TypeToReturn
-	);

package/node_modules/boxen/node_modules/type-fest/source/shared-union-fields-deep.d.ts

@@ -1,178 +0,0 @@
-import type {NonRecursiveType, UnionMin, UnionMax, TupleLength, StaticPartOfArray, VariablePartOfArray, IsArrayReadonly, SetArrayAccess, ApplyDefaultOptions} from './internal';
-import type {IsNever} from './is-never';
-import type {UnknownArray} from './unknown-array';
-
-/**
-SharedUnionFieldsDeep options.
-
-@see {@link SharedUnionFieldsDeep}
-*/
-export type SharedUnionFieldsDeepOptions = {
-	/**
-	When set to true, this option impacts each element within arrays or tuples. If all union values are arrays or tuples, it constructs an array of the shortest possible length, ensuring every element exists in the union array.
-
-	@default false
- 	*/
-	recurseIntoArrays?: boolean;
-};
-
-type DefaultSharedUnionFieldsDeepOptions = {
-	recurseIntoArrays: false;
-};
-
-/**
-Create a type with shared fields from a union of object types, deeply traversing nested structures.
-
-Use the {@link SharedUnionFieldsDeepOptions `Options`} to specify the behavior for arrays.
-
-Use-cases:
-- You want a safe object type where each key exists in the union object.
-- You want to focus on the common fields of the union type and don't want to have to care about the other fields.
-
-@example
-```
-import type {SharedUnionFieldsDeep} from 'type-fest';
-
-type Cat = {
-	info: {
-		name: string;
-		type: 'cat';
-		catType: string;
-	};
-};
-
-type Dog = {
-	info: {
-		name: string;
-		type: 'dog';
-		dogType: string;
-	};
-};
-
-function displayPetInfo(petInfo: (Cat | Dog)['info']) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat';
-	// 	catType: string; // Needn't care about this field, because it's not a common pet info field.
-	// } | {
-	// 	name: string;
-	// 	type: 'dog';
-	// 	dogType: string; // Needn't care about this field, because it's not a common pet info field.
-	// }
-
-	// petInfo type is complex and have some needless fields
-
-	console.log('name: ', petInfo.name);
-	console.log('type: ', petInfo.type);
-}
-
-function displayPetInfo(petInfo: SharedUnionFieldsDeep<Cat | Dog>['info']) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat' | 'dog';
-	// }
-
-	// petInfo type is simple and clear
-
-	console.log('name: ', petInfo.name);
-	console.log('type: ', petInfo.type);
-}
-```
-
-@see SharedUnionFields
-
-@category Object
-@category Union
-*/
-export type SharedUnionFieldsDeep<Union, Options extends SharedUnionFieldsDeepOptions = {}> =
-	ApplyDefaultOptions<SharedUnionFieldsDeepOptions, DefaultSharedUnionFieldsDeepOptions, Options> extends infer OptionsWithDefaults extends Required<SharedUnionFieldsDeepOptions>
-	// `Union extends` will convert `Union`
-	// to a [distributive conditionaltype](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	// But this is not what we want, so we need to wrap `Union` with `[]` to prevent it.
-		? [Union] extends [NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>]
-			? Union
-			: [Union] extends [UnknownArray]
-				? OptionsWithDefaults['recurseIntoArrays'] extends true
-					? SetArrayAccess<SharedArrayUnionFieldsDeep<Union, OptionsWithDefaults>, IsArrayReadonly<Union>>
-					: Union
-				: [Union] extends [object]
-					? SharedObjectUnionFieldsDeep<Union, OptionsWithDefaults>
-					: Union
-		: never;
-
-/**
-Same as `SharedUnionFieldsDeep`, but accepts only `object`s and as inputs. Internal helper for `SharedUnionFieldsDeep`.
-*/
-type SharedObjectUnionFieldsDeep<Union, Options extends Required<SharedUnionFieldsDeepOptions>> =
-	// `keyof Union` can extract the same key in union type, if there is no same key, return never.
-	keyof Union extends infer Keys
-		? IsNever<Keys> extends false
-			? {
-				[Key in keyof Union]:
-				Union[Key] extends NonRecursiveType
-					? Union[Key]
-					// Remove `undefined` from the union to support optional
-					// fields, then recover `undefined` if union was already undefined.
-					: SharedUnionFieldsDeep<Exclude<Union[Key], undefined>, Options> | (
-						undefined extends Required<Union>[Key] ? undefined : never
-					)
-			}
-			: {}
-		: Union;
-
-/**
-Same as `SharedUnionFieldsDeep`, but accepts only `UnknownArray`s and as inputs. Internal helper for `SharedUnionFieldsDeep`.
-*/
-type SharedArrayUnionFieldsDeep<Union extends UnknownArray, Options extends Required<SharedUnionFieldsDeepOptions>> =
-	// Restore the readonly modifier of the array.
-	SetArrayAccess<
-	InternalSharedArrayUnionFieldsDeep<Union, Options>,
-	IsArrayReadonly<Union>
-	>;
-
-/**
-Internal helper for `SharedArrayUnionFieldsDeep`. Needn't care the `readonly` modifier of arrays.
-*/
-type InternalSharedArrayUnionFieldsDeep<
-	Union extends UnknownArray,
-	Options extends Required<SharedUnionFieldsDeepOptions>,
-	ResultTuple extends UnknownArray = [],
-> =
-	// We should build a minimum possible length tuple where each element in the tuple exists in the union tuple.
-	IsNever<TupleLength<Union>> extends true
-		// Rule 1: If all the arrays in the union have non-fixed lengths,
-		// like `Array<string> | [number, ...string[]]`
-		// we should build a tuple that is [the_fixed_parts_of_union, ...the_rest_of_union[]].
-		// For example: `InternalSharedArrayUnionFieldsDeep<Array<string> | [number, ...string[]]>`
-		// => `[string | number, ...string[]]`.
-		? ResultTuple['length'] extends UnionMax<StaticPartOfArray<Union>['length']>
-			? [
-				// The fixed-length part of the tuple.
-				...ResultTuple,
-				// The rest of the union.
-				// Due to `ResultTuple` is the maximum possible fixed-length part of the tuple,
-				// so we can use `StaticPartOfArray` to get the rest of the union.
-				...Array<
-				SharedUnionFieldsDeep<VariablePartOfArray<Union>[number], Options>
-				>,
-			]
-			// Build the fixed-length tuple recursively.
-			: InternalSharedArrayUnionFieldsDeep<
-			Union, Options,
-			[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
-			>
-		// Rule 2: If at least one of the arrays in the union have fixed lengths,
-		// like `Array<string> | [number, string]`,
-		// we should build a tuple of the smallest possible length to ensure any
-		// item in the result tuple exists in the union tuple.
-		// For example: `InternalSharedArrayUnionFieldsDeep<Array<string> | [number, string]>`
-		// => `[string | number, string]`.
-		: ResultTuple['length'] extends UnionMin<TupleLength<Union>>
-			? ResultTuple
-			// As above, build tuple recursively.
-			: InternalSharedArrayUnionFieldsDeep<
-			Union, Options,
-			[...ResultTuple, SharedUnionFieldsDeep<Union[ResultTuple['length']], Options>]
-			>;

package/node_modules/boxen/node_modules/type-fest/source/shared-union-fields.d.ts

@@ -1,76 +0,0 @@
-import type {NonRecursiveType, IsUnion} from './internal';
-import type {IsNever} from './is-never';
-import type {Simplify} from './simplify';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Create a type with shared fields from a union of object types.
-
-Use-cases:
-- You want a safe object type where each key exists in the union object.
-- You want to focus on the common fields of the union type and don't want to have to care about the other fields.
-
-@example
-```
-import type {SharedUnionFields} from 'type-fest';
-
-type Cat = {
-	name: string;
-	type: 'cat';
-	catType: string;
-};
-
-type Dog = {
-	name: string;
-	type: 'dog';
-	dogType: string;
-};
-
-function displayPetInfo(petInfo: Cat | Dog) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat';
-	// 	catType: string; // Needn't care about this field, because it's not a common pet info field.
-	// } | {
-	// 	name: string;
-	// 	type: 'dog';
-	// 	dogType: string; // Needn't care about this field, because it's not a common pet info field.
-	// }
-
-	// petInfo type is complex and have some needless fields
-
-	console.log('name: ', petInfo.name);
-	console.log('type: ', petInfo.type);
-}
-
-function displayPetInfo(petInfo: SharedUnionFields<Cat | Dog>) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat' | 'dog';
-	// }
-
-	// petInfo type is simple and clear
-
-	console.log('name: ', petInfo.name);
-	console.log('type: ', petInfo.type);
-}
-```
-
-@see SharedUnionFieldsDeep
-@see AllUnionFields
-
-@category Object
-@category Union
-*/
-export type SharedUnionFields<Union> =
-Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
-	? Exclude<Union, SkippedMembers> extends infer RelevantMembers
-		?
-		| SkippedMembers
-		| (IsNever<RelevantMembers> extends true
-			? never
-			: Simplify<Pick<RelevantMembers, keyof RelevantMembers>>)
-		: never
-	: never;

package/node_modules/boxen/node_modules/type-fest/source/simplify-deep.d.ts

@@ -1,115 +0,0 @@
-import type {ConditionalSimplifyDeep} from './conditional-simplify';
-import type {NonRecursiveType} from './internal';
-
-/**
-Deeply simplifies an object type.
-
-You can exclude certain types from being simplified by providing them in the second generic `ExcludeType`.
-
-Useful to flatten the type output to improve type hints shown in editors.
-
-@example
-```
-import type {SimplifyDeep} from 'type-fest';
-
-type PositionX = {
-	left: number;
-	right: number;
-};
-
-type PositionY = {
-	top: number;
-	bottom: number;
-};
-
-type Properties1 = {
-	height: number;
-	position: PositionY;
-};
-
-type Properties2 = {
-	width: number;
-	position: PositionX;
-};
-
-type Properties = Properties1 & Properties2;
-// In your editor, hovering over `Props` will show the following:
-//
-// type Properties = Properties1 & Properties2;
-
-type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2>;
-// But if wrapped in SimplifyDeep, hovering over `SimplifyDeepProperties` will show a flattened object with all the properties:
-//
-// SimplifyDeepProperties = {
-// 	height: number;
-// 	width: number;
-// 	position: {
-// 		top: number;
-// 		bottom: number;
-// 		left: number;
-// 		right: number;
-// 	};
-// };
-```
-
-@example
-```
-import type {SimplifyDeep} from 'type-fest';
-
-// A complex type that you don't want or need to simplify
-type ComplexType = {
-	a: string;
-	b: 'b';
-	c: number;
-	...
-};
-
-type PositionX = {
-	left: number;
-	right: number;
-};
-
-type PositionY = {
-	top: number;
-	bottom: number;
-};
-
-// You want to simplify all other types
-type Properties1 = {
-	height: number;
-	position: PositionY;
-	foo: ComplexType;
-};
-
-type Properties2 = {
-	width: number;
-	position: PositionX;
-	foo: ComplexType;
-};
-
-type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2, ComplexType>;
-// If wrapped in `SimplifyDeep` and set `ComplexType` to exclude, hovering over `SimplifyDeepProperties` will
-// show a flattened object with all the properties except `ComplexType`:
-//
-// SimplifyDeepProperties = {
-// 	height: number;
-// 	width: number;
-// 	position: {
-// 		top: number;
-// 		bottom: number;
-// 		left: number;
-// 		right: number;
-// 	};
-//	foo: ComplexType;
-// };
-```
-
-@see Simplify
-@category Object
-*/
-export type SimplifyDeep<Type, ExcludeType = never> =
-	ConditionalSimplifyDeep<
-	Type,
-	ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>,
-	object
-	>;

package/node_modules/boxen/node_modules/type-fest/source/simplify.d.ts

@@ -1,58 +0,0 @@
-/**
-Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-type PositionProps = {
-	top: number;
-	left: number;
-};
-
-type SizeProps = {
-	width: number;
-	height: number;
-};
-
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
-```
-
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
-
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-}
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-function fn(object: Record<string, unknown>): void {}
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
-@category Object
-*/
-export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};

package/node_modules/boxen/node_modules/type-fest/source/single-key-object.d.ts

@@ -1,29 +0,0 @@
-import type {IfEmptyObject} from './if-empty-object';
-import type {IsUnion} from './internal';
-
-/**
-Create a type that only accepts an object with a single key.
-
-@example
-```
-import type {SingleKeyObject} from 'type-fest';
-
-const someFunction = <T>(parameter: SingleKeyObject<T>) => {};
-
-someFunction({
-	value: true
-});
-
-someFunction({
-	value: true,
-	otherKey: true
-});
-// Error: Argument of type '{value: boolean; otherKey: boolean}' is not assignable to parameter of type 'never'.ts(2345)
-```
-
-@category Object
-*/
-export type SingleKeyObject<ObjectType> =
-	IsUnion<keyof ObjectType> extends true
-		? never
-		: IfEmptyObject<ObjectType, never, ObjectType>;

package/node_modules/boxen/node_modules/type-fest/source/snake-case.d.ts

@@ -1,45 +0,0 @@
-import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case';
-import type {ApplyDefaultOptions} from './internal';
-import type {WordsOptions} from './words';
-
-/**
-Convert a string literal to snake-case.
-
-This can be useful when, for example, converting a camel-cased object property to a snake-cased SQL column name.
-
-@example
-```
-import type {SnakeCase} from 'type-fest';
-
-// Simple
-
-const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
-const noSplitOnNumbers: SnakeCase<'p2pNetwork'> = 'p2p_network';
-const splitOnNumbers: SnakeCase<'p2pNetwork', {splitOnNumbers: true}> = 'p_2_p_network';
-
-// Advanced
-
-type SnakeCasedProperties<T> = {
-	[K in keyof T as SnakeCase<K>]: T[K]
-};
-
-interface ModelProps {
-	isHappy: boolean;
-	fullFamilyName: string;
-	foo: number;
-}
-
-const dbResult: SnakeCasedProperties<ModelProps> = {
-	'is_happy': true,
-	'full_family_name': 'Carla Smith',
-	foo: 123
-};
-```
-
-@category Change case
-@category Template literal
-*/
-export type SnakeCase<
-	Value,
-	Options extends WordsOptions = {},
-> = DelimiterCase<Value, '_', ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>;