(binary: (t: T, u: U) => V) => ((t: T, u: U) => V)
```
#### memoizeMore
```typescript
memoizeMore: (argCount: N, fn: (...args: P) => R) => ((...args: P) => R)
```
#### memoizeSupplier
```typescript
memoizeSupplier: (supplier: Supplier) => Supplier
```
Memoize the given supplier so that it is called at most once.
#### memoizeUnary
```typescript
memoizeUnary: (unary: (input: T) => U) => ((input: T) => U)
```
#### minMax
```typescript
function minMax(values: number[]): [number, number];
```
#### minMax
```typescript
function minMax(...values: number[]): [number, number];
```
#### optionalRegExp
```typescript
optionalRegExp: (pattern: RegExp) => RegExp
```
Modify a regular expression's pattern to make the entire expression optional, keeping any start/end anchors in place
#### parseDuration
```typescript
parseDuration: (text: string) => DurationWithText
```
Parse an ISO-8601 duration from the given text. If the text contains extra non-duration characters after, will only throw an error if they would produce an ambiguous result, or could indicate an incomplete duration.
#### parseLocalDate
```typescript
parseLocalDate: (text: string, config?: ParseLocalDateConfig) => Date
```
Parse an ISO-8860-like date, but do so assuming that the time is intended to be local, not UTC. But if allowed, the date could override this with specific time zone info.
#### positiveDiv
```typescript
positiveDiv: (num: number, divisor: number) => number
```
Modulo where the result is always positive.
#### positiveMod
```typescript
positiveMod: (num: number, divisor: number) => number
```
Modulo where the result is always positive.
#### priorityArray
```typescript
priorityArray: (comparator: Comparator) => Queue
```
Build a priority queue which uses an array as a backing store.
#### priorityLinkedList
```typescript
priorityLinkedList: (comparator: Comparator) => Queue
```
Build a priority queue which uses a linked list as a backing store.
#### randomNumberGenerator
```typescript
randomNumberGenerator: (seedOrOptions?: number | RNGOptions, presetName?: LCEPresetName | undefined) => RNG
```
https://en.wikipedia.org/wiki/Linear_congruential_generator
#### reduceToUnique
```typescript
reduceToUnique: () => [(prev: T[], cur: T) => T[], T[]]
```
Generate the args for an array reducer which keeps only distinct values.
#### reQuote
```typescript
reQuote: (text: string, options?: ReQuoteOptions) => string
```
Given a text, either wrap it in quotes which make the most sense for the text, or change the quotes to a different set.
#### resolvablePromise
```typescript
function resolvablePromise(): ResolvablePromise;
```
Build a promise which can be resolved from the outside.
#### roundTo
```typescript
roundTo: (value: number, resolution?: number) => number
```
Round a given number to the nearest unit of resolution. For resolution of 1, this is equal to `Math.round`.
#### secondsFromDuration
```typescript
secondsFromDuration: (duration: Partial) => number
```
Convert a given duration to an equivalent number of seconds.
#### shuffle
```typescript
shuffle: (list: T[], input?: ShuffleConfig) => T[]
```
Fisher-Yates shuffle. Defaults to in-place sorting, but can sort into a new one via into.
#### simpleStarMatch
```typescript
simpleStarMatch: (glob: string, text: string) => boolean
```
Match the given simple-* glob against the given text. This _does not_ use "filesystem glob" logic. That is, a `*` here will match anything, including `/`. Similarly, there is no `?` operator.
#### singleCharactersOf
```typescript
function singleCharactersOf(...its: StringIterable[]): Generator;
```
#### singleCharactersOfAsync
```typescript
function singleCharactersOfAsync(...its: AsyncStringIterable[]): AsyncGenerator;
```
#### singleLinkedList
```typescript
singleLinkedList: () => List
```
Builder for a single-linked list.
#### skipList
```typescript
skipList: (comparator: Comparator) => SkipList
```
Build a priority queue using a skip list implementation.
#### sleep
```typescript
function sleep(ms: number, value: T): Promise;
```
Sleep at least some number of ms, returning the supplied value when complete.
#### sleep
```typescript
function sleep(ms: number): Promise;
```
Sleep at least some number of ms.
#### splitFixed
```typescript
splitFixed: (text: string, width: number) => string[]
```
Split a string into fixed-width substrings. The last one may be short.
#### starMatchParts
```typescript
starMatchParts: (glob: string) => StarGlobPart[]
```
Parse a simple-* glob into its constituent tokens.
#### svgPathCommandsOf
```typescript
function svgPathCommandsOf(...d: StringIterable[]): Generator;
```
Parse an SVG `path` definition into drawing commands.
#### svgPathValuesOf
```typescript
function svgPathValuesOf(...d: StringIterable[]): Generator;
```
Tokenize an SVG `path` definition into `command`, `number`, and `space` tokens.
#### toBatches
```typescript
toBatches: (maxPerBatch: number, list: T[], mode?: ToBatchesMode) => T[][]
```
Group the given list into batches of the given maximum count, optionally using a given strategy.
#### toBatchesReducer
```typescript
toBatchesReducer: (maxPerBatch: number, mode?: ToBatchesMode) => [reduce: (prev: T[][], cur: T, index: number, list: T[]) => T[][], initial: T[][]]
```
Generate an array reducer which will group the given list into batches of the given maximum count, optionally using a given strategy.
#### toShuffled
```typescript
toShuffled: (list: T[], config?: Omit, "into"> | undefined) => T[]
```
Wrapper for the [shuffle](#api-shuffle) function which shuffles into a new array, leaving the original intact.
#### uniqueReducer
```typescript
uniqueReducer: () => (prev: T[], cur: T) => T[]
```
Generate a function for use in an array reducer which will track and only keep the first occurrence of each value.
#### window2
```typescript
function window2(items: Readonly): Generator, void, undefined>;
```
Generator for a sliding window of pairs of values from the given list. It yields each value in the list in a tuple with its successor. The last item wraps around to use the first item as its successor. The indices of the two values are also yielded after the values. For example:
```typescript
for (const [ x, y, xIndex, yIndex ] of window2([ "a", "b", "c" ])) {
console.log(x, y, xIndex, yIndex);
}
```
This would output: a, b, 0, 1 b, c, 1, 2 c, a, 2, 0
#### window3
```typescript
function window3(items: Readonly): Generator, void, undefined>;
```
Generator for a sliding window of triplets of values from the given list. It yields each value in the list in a tuple with its predecessor and successor. The first and last items wrap around to use the last and first items as their predecessor/successor. The indices of the values are also provided after the values. The middle value (y in the example below) is the "current" value, with the first value (x) being its predecessor and the third (z) its successor. That current value is the one which will be at index 0 for the first iteration of the loop. For example:
```typescript
for (const [ x, y, z, xIndex, yIndex, zIndex ] of window3([ "a", "b", "c" ])) {
console.log(x, y, z, xIndex, yIndex, zIndex);
}
```
This would output: c, a, b, 2, 0, 1 a, b, c, 0, 1, 2 b, c, a, 1, 2, 0
#### withLazyProperty
```typescript
withLazyProperty: (target: Target, name: Name, calculator: (t: Target) => Property) => WithProperty
```
Add a property to the given object which is calculated lazily, and only once.
#### withNullsFirst
```typescript
withNullsFirst: (comparator: Comparator) => Comparator
```
Wrap the given comparator to return null and undefined values before the others.
#### withNullsLast
```typescript
withNullsLast: (comparator: Comparator) => Comparator
```
Wrap the given comparator to return null and undefined values after the others.
#### withTimeout
```typescript
function withTimeout(options: WithTimeoutOptions): Promise;
```
Wrap a given block or promise in another promise which will resolve or reject if the first has not resolved within the specified time limit.
#### zeroPad
```typescript
zeroPad: (num: number, length: number, radix?: number) => string
```
Convert a number to a string and left-pad it out to the given length with zeroes.
### Interfaces
#### ArcSvgPathToken
```typescript
export interface ArcSvgPathToken extends SvgPathTokenBase<"arc">
```
#### AsyncIteratorTransformerOptions
```typescript
export interface AsyncIteratorTransformerOptions
```
Additional configuration for an asynchronous Iterator transformer.
#### BetterMapLike
```typescript
export interface BetterMapLike
```
A Map-like structure with several handy utility methods.
#### CatchAndOptions
```typescript
export interface CatchAndOptions
```
#### CloseSvgPathToken
```typescript
export interface CloseSvgPathToken extends SvgPathTokenBase<"close">
```
#### CommandSvgPathValue
```typescript
export interface CommandSvgPathValue extends SvgPathValueBase<"command">
```
#### ConsoleLike
```typescript
export interface ConsoleLike
```
#### CubicCurveSvgPathToken
```typescript
export interface CubicCurveSvgPathToken extends SvgPathTokenBase<"cubic">
```
#### DeepCopyOptions
```typescript
export interface DeepCopyOptions
```
#### DeepSortOptions
```typescript
export interface DeepSortOptions
```
#### Duration
```typescript
export interface Duration
```
ISO8601-like measure of a duration. Does not include any concept of being relative to any specific date.
#### DurationWithText
```typescript
export interface DurationWithText extends Duration
```
A duration parsed from text, which includes the extracted (serialized) duration text.
#### EmptyHolder
```typescript
export interface EmptyHolder extends Holder
```
A [Holder](#api-holder) without a value, yet.
#### FormatMarkdownTableOptions
```typescript
export interface FormatMarkdownTableOptions
```
Options for [formatMarkdownTable](#api-formatmarkdowntable).
#### Holder
```typescript
export interface Holder
```
A structure which can hold any value type, even undefined, and can itself be const, while still allowing the value to be added later.
#### IteratorTransformerMapResult
```typescript
export interface IteratorTransformerMapResult
```
#### JsonBooleanToken
```typescript
export interface JsonBooleanToken extends JsonTokenBase
```
#### JsonNullToken
```typescript
export interface JsonNullToken extends JsonTokenBase
```
#### JsonNumberToken
```typescript
export interface JsonNumberToken extends JsonTokenBase
```
#### JsonParseArrayState
```typescript
export interface JsonParseArrayState extends JsonParseStateBase
```
#### JsonParseItemState
```typescript
export interface JsonParseItemState extends JsonParseStateBase
```
#### JsonParseObjectState
```typescript
export interface JsonParseObjectState extends JsonParseStateBase
```
#### JsonParsePropertyState
```typescript
export interface JsonParsePropertyState extends JsonParseStateBase
```
#### JsonParseRootState
```typescript
export interface JsonParseRootState extends JsonParseStateBase
```
#### JsonParseStateBase
```typescript
export interface JsonParseStateBase
```
#### JsonPathAppendOptions
```typescript
export interface JsonPathAppendOptions
```
#### JsonPunctuationToken
```typescript
export interface JsonPunctuationToken extends JsonTokenBase
```
#### JsonSpaceToken
```typescript
export interface JsonSpaceToken extends JsonTokenBase
```
#### JsonStringToken
```typescript
export interface JsonStringToken extends JsonTokenBase
```
#### JsonTokenBase
```typescript
export interface JsonTokenBase
```
#### LineSvgPathToken
```typescript
export interface LineSvgPathToken extends SvgPathTokenBase<"line">
```
#### LogLike
```typescript
export interface LogLike
```
#### MoveSvgPathToken
```typescript
export interface MoveSvgPathToken extends SvgPathTokenBase<"move">
```
#### NumberSvgPathValue
```typescript
export interface NumberSvgPathValue extends SvgPathValueBase<"number">
```
#### QuadraticCurveSvgPathToken
```typescript
export interface QuadraticCurveSvgPathToken extends SvgPathTokenBase<"quad">
```
#### ResolvablePromise
```typescript
export interface ResolvablePromise extends Promise
```
A promise which can be resolved from the outside.
#### RNG
```typescript
export interface RNG
```
#### RNGOptions
```typescript
export interface RNGOptions
```
#### SpaceSvgPathValue
```typescript
export interface SpaceSvgPathValue extends SvgPathValueBase<"space">
```
#### SvgPathTokenBase
```typescript
export interface SvgPathTokenBase
```
#### SvgPathTokenByType
```typescript
export interface SvgPathTokenByType
```
#### SvgPathValueBase
```typescript
export interface SvgPathValueBase
```
#### SvgPathValueByType
```typescript
export interface SvgPathValueByType
```
#### UnknownErrorOptions
```typescript
export interface UnknownErrorOptions extends ErrorOptions
```
Options for [UnknownError](#api-unknownerror).
#### ValuedHolder
```typescript
export interface ValuedHolder extends Holder
```
A [Holder](#api-holder) whose value has been set.
#### WithTimeoutOptions
```typescript
export interface WithTimeoutOptions
```
Options for [withTimeout](#api-withtimeout).
### TypeAliases
#### AsyncIteratorTransformerConstructor
```typescript
type AsyncIteratorTransformerConstructor = AbstractConstructorLike<[iterator: AsyncIterator], AsyncIteratorTransformer>;
```
#### AsyncStringIterable
```typescript
type AsyncStringIterable = StringIterable | AsyncIterable | AsyncIterator;
```
#### BinaryIndexOfConfig
```typescript
type BinaryIndexOfConfig = {
firstNonUnique?: boolean;
initialLeft?: number;
initialRight?: number;
rangeCheck?: boolean;
};
```
Configuration options for [binaryIndexOf](#api-binaryindexof).
#### ChainableComparator
```typescript
type ChainableComparator = Comparator & {
get desc(): ChainableComparator;
get nullsFirst(): ChainableComparator;
get nullsLast(): ChainableComparator;
};
```
Mixin for a comparator with chaining functions to constrain the behavior of the comparator.
#### ComparatorBuilder
```typescript
type ComparatorBuilder = {
build(): Comparator;
get desc(): ComparatorBuilder;
get nullsFirst(): ComparatorBuilder;
get nullsLast(): ComparatorBuilder;
num(accessor: (t: T) => (undefined | number)): ComparatorBuilder;
str(accessor: (t: T) => (undefined | string)): ComparatorBuilder;
};
```
Build a comparator for the given type, which goes through the specified checks in the order they are defined.
#### DeepMerge
```typescript
type DeepMerge = Winner extends object ? Loser extends object ? ({
[K in keyof Loser as K extends keyof Winner ? never : K]: Loser[K];
} & {
[K in keyof Winner as K]: K extends keyof Loser ? DeepMerge : Winner[K];
}) : Winner : Winner;
```
Given two types, recursively compare and merge them with the following logic: 1. If the two types are different, Winner wins. 2. If either type is not a Record, Winner wins. 3. If both types are Records, each property, in the set of all keys from both, is compared using the same logic. A superset Record is created.
#### DoubleLinkedList
```typescript
type DoubleLinkedList = List & {
get tail(): T | undefined;
reverseValues(): Generator;
reverseValuesAndIndexes(): Generator<[T, number], void, undefined>;
reverseWalk(block: (value: T, index: number) => ListWalkDecision): void;
};
```
Mixin for additional methods available when the linked list is double-linked.
#### DurationDesignator
```typescript
type DurationDesignator = "Y" | "M" | "W" | "D" | "T" | "H" | "S";
```
ISO-8601 designator for a duration value.
#### FracTuple
```typescript
type FracTuple = [numerator: number, denominator: number];
```
A fraction represented as a tuple of numerator and denominator. The numerator is negative if the value is negative. The denominator is always positive, and at least 1. Both values are integers, though the numerator may be Infinity or NaN as the value requires.
#### GetPropertyDescriptor
```typescript
type GetPropertyDescriptor = PropertyDescriptorFlags & {
get(): T;
set?: never;
value?: never;
};
```
Partial property descriptor which includes only an accessor (getter) and not a mutator, and is thus read-only.
#### GetSetPropertyDescriptor
```typescript
type GetSetPropertyDescriptor = PropertyDescriptorFlags & {
get(): T;
set(t: T): void;
};
```
Partial property descriptor which includes both an accessor (getter) and mutator (setter), and is thus read-write.
#### IfReadOnlyDescriptor
```typescript
type IfReadOnlyDescriptor> = D extends ReadOnlyPropertyDescriptor | GetPropertyDescriptor ? T : never;
```
Filter type T based on whether the property descriptor D would produce a read-only property.
#### IfReadWriteDescriptor
```typescript
type IfReadWriteDescriptor> = D extends ReadOnlyPropertyDescriptor | GetPropertyDescriptor | SetPropertyDescriptor ? never : T;
```
Filter type T based on whether the property descriptor D would produce a read-write (or write-only) property.
#### IfWriteOnlyDescriptor
```typescript
type IfWriteOnlyDescriptor> = D extends SetPropertyDescriptor ? T : never;
```
Filter type T based on whether the property descriptor D would produce a write-only property. Note: JS has a concept of a write-only property, and the unit tests cover this. However, TS doesn't have a way of expressing it, at least as of v5.8. So for now, it goes into the read-write bucket, even though you can't actually read from it. The alternative would be to set it to `undefined`, to show you can't read from it ... but then you lose the type info for the setter. Yuck. For now ... The types below will, ahem, mangle the types they produce. Just a little. If you produce a setter-only property, it will end up looking like:
```typescript
const withSetterOnly: WithSetterOnly = addProperty({}, "whatever", { set: (value: string) => void(whatever(value)) });
type WithSetterOnly = {
whatever: string;
whateverIsWriteOnly?: undefined;
}
```
So you get a reminder without breaking anything too hard.
#### IntGenerator
```typescript
type IntGenerator = Generator & {
toArray(): number[];
};
```
Mixin for a generator which also has the ability to bundle its output into an array.
#### IntGeneratorTo
```typescript
type IntGeneratorTo = {
toExclusive(stopExclusive: number): IntGenerator;
toInclusive(stopInclusive: number): IntGenerator;
};
```
Partial for the last step of an [IntRange](#api-intrange) builder.
#### IntRange
```typescript
type IntRange = {
from(startInclusive: number): {
by(skip: number): IntGeneratorTo;
get down(): IntGeneratorTo;
get up(): IntGeneratorTo;
};
};
```
Integer range generators which (hopefully) make it super clear what your boundary, direction, and increment are.
#### IteratorTransformerConstructor
```typescript
type IteratorTransformerConstructor = SyncIteratorTransformerConstructor | AsyncIteratorTransformerConstructor;
```
#### IteratorTransformerMore
```typescript
type IteratorTransformerMore = () => Optional;
```
#### JsonParseEvent
```typescript
type JsonParseEvent = JsonParseBeginEvent | JsonParseEndEvent;
```
#### JsonParseState
```typescript
type JsonParseState = JsonParseObjectState | JsonParseArrayState | JsonParseItemState | JsonParsePropertyState | JsonParseRootState;
```
#### JsonParseTypeT
```typescript
type JsonParseTypeT = (typeof JsonParseType)[keyof typeof JsonParseType];
```
#### JsonPunctuation
```typescript
type JsonPunctuation = "{" | "}" | "[" | "]" | ":" | ",";
```
#### JsonToken
```typescript
type JsonToken = JsonNullToken | JsonBooleanToken | JsonNumberToken | JsonStringToken | JsonPunctuationToken | JsonSpaceToken;
```
#### JsonTokenTypeT
```typescript
type JsonTokenTypeT = (typeof JsonTokenType)[keyof typeof JsonTokenType];
```
#### LCEPresetName
```typescript
type LCEPresetName = keyof typeof LCE_PRESETS;
```
#### List
```typescript
type List = {
at(index: number): T | undefined;
get head(): T | undefined;
insertAt(index: number, value: T): void;
get isEmpty(): boolean;
get length(): number;
pop(): T | undefined;
push(value: T): void;
shift(): T | undefined;
toArray(): T[];
unshift(value: T): void;
values(): Generator;
valuesAndIndexes(): Generator<[T, number], void, undefined>;
walk(block: (value: T, index: number) => ListWalkDecision): void;
readonly [Symbol.toStringTag]: string;
};
```
Basic list-like structure.
#### ListWalkDecision
```typescript
type ListWalkDecision = {
deleteItem?: boolean;
insertAfter?: T;
insertBefore?: T;
keepWalking: boolean;
};
```
Controls how a [List](#api-list)'s walk operation behaves after each iteration.
#### Optional
```typescript
type Optional = {
value: T;
} | undefined;
```
#### ParseLocalDateConfig
```typescript
type ParseLocalDateConfig = {
offsetMinutes?: number;
time?: boolean;
timeDelimiters?: string[];
zone?: boolean;
};
```
Configuration for a [parseLocalDate](#api-parselocaldate) call.
#### PropertiesFromDescriptors
```typescript
type PropertiesFromDescriptors>> = {
readonly [K in ReadOnlyDescriptorsKeys]: R[K] extends TypedPropertyDescriptor ? V : never;
} & {
[K in ReadWriteDescriptorsKeys]: R[K] extends TypedPropertyDescriptor ? V : never;
} & {
[K in WriteOnlyDescriptorsKeys]: R[K] extends TypedPropertyDescriptor ? V : never;
} & {
[K in RenamedWriteOnlyDescriptorsKeys]?: undefined;
};
```
Produce an object with the properties described by the descriptors. See [RenameIfWriteOnlyDescriptor](#api-renameifwriteonlydescriptor) for details on the mangling of write-only properties.
#### PropertyDescriptorFlags
```typescript
type PropertyDescriptorFlags = {
configurable?: boolean;
enumerable?: boolean;
writable?: boolean;
};
```
Basic flags for any property descriptor.
#### PropertyFromDescriptor
```typescript
type PropertyFromDescriptor> = D extends TypedPropertyDescriptor ? ({
readonly [key in IfReadOnlyDescriptor]: V;
} & {
[key in IfReadWriteDescriptor]: V;
} & {
[key in IfWriteOnlyDescriptor]: V;
} & {
[key in RenameIfWriteOnlyDescriptor]?: undefined;
}) : never;
```
Produce a single-property object type for the given property descriptor. Note: will produce an additional mangled pseudo-property for write-only properties. See [RenameIfWriteOnlyDescriptor](#api-renameifwriteonlydescriptor) for details on the mangling.
#### Queue
```typescript
type Queue = {
add(value: T): void;
peek(): T | undefined;
remove(value: T): void;
get length(): number;
take(): T | undefined;
toArray(): T[];
values(): Generator;
};
```
Basic interface for a queue.
#### ReadOnlyDescriptorsKeys
```typescript
type ReadOnlyDescriptorsKeys = R extends Record> ? {
[key in K]: IfReadOnlyDescriptor;
}[K] : never;
```
Produce the keys for the given property descriptors record which would produce read-only properties.
#### ReadOnlyPropertyDescriptor
```typescript
type ReadOnlyPropertyDescriptor = {
writable: false;
};
```
Partial property descriptor which has been marked as non-writable.
#### ReadWriteDescriptorsKeys
```typescript
type ReadWriteDescriptorsKeys = R extends Record> ? {
[key in K]: IfReadWriteDescriptor;
}[K] : never;
```
Produce the keys for the given property descriptors record which would produce read-write (or write-only) properties.
#### RenamedWriteOnlyDescriptorsKeys
```typescript
type RenamedWriteOnlyDescriptorsKeys = R extends Record> ? {
[key in string & K]: RenameIfWriteOnlyDescriptor;
}[string & K] : never;
```
Produce the mangled keys for the given property descriptors record which would produce write-only properties. See [RenameIfWriteOnlyDescriptor](#api-renameifwriteonlydescriptor) for details on the mangling.
#### RenameIfWriteOnlyDescriptor
```typescript
type RenameIfWriteOnlyDescriptor> = D extends SetPropertyDescriptor ? `${Key}IsWriteOnly` : never;
```
Mangle the given Key to $\{Key\}IsWriteOnly if property descriptor D would produce a write-only property.
#### ReQuoteOptions
```typescript
type ReQuoteOptions = {
auto?: true;
quotes?: never;
} | {
auto?: never;
quotes?: string;
};
```
#### SearchResult
```typescript
type SearchResult = {
before?: undefined;
comparisons: number;
exists: true;
index: number;
} | {
before: number;
comparisons: number;
exists: false;
index?: undefined;
};
```
A result of a search through a list. If the value was found, its index is returned. Otherwise, the before value is the index before which the value could be inserted. For troubleshooting and instrumentation, also returns the number of comparisons it took to find the value.
#### SetPropertyDescriptor
```typescript
type SetPropertyDescriptor = PropertyDescriptorFlags & {
get?: never;
set(t: T): void;
};
```
Partial property descriptor which includes only a mutator (setter) and not an accessor (getter), and is thus write-only. Note: TypeScript support for these kinds of properties is very poor as of v5.7.
#### ShuffleConfig
```typescript
type ShuffleConfig = {
into?: T[] | undefined;
random01?: () => number;
};
```
Configuration options for the [shuffle](#api-shuffle) function.
#### StarGlobPart
```typescript
type StarGlobPart = StarGlobText | StarGlobStar;
```
#### StringIterable
```typescript
type StringIterable = string | Iterable | Iterator;
```
#### SvgAbsolutePathCommand
```typescript
type SvgAbsolutePathCommand = "M" | "L" | "H" | "V" | "Z" | "C" | "S" | "Q" | "T" | "A";
```
#### SvgPathCommand
```typescript
type SvgPathCommand = SvgAbsolutePathCommand | SvgRelativePathCommand;
```
#### SvgPathToken
```typescript
type SvgPathToken = SvgPathTokenByType[keyof SvgPathTokenByType];
```
#### SvgPathValue
```typescript
type SvgPathValue = SvgPathValueByType[SvgPathValueType];
```
#### SvgPathValueType
```typescript
type SvgPathValueType = keyof SvgPathValueByType;
```
#### SvgRelativePathCommand
```typescript
type SvgRelativePathCommand = Lowercase;
```
#### SyncIteratorTransformerConstructor
```typescript
type SyncIteratorTransformerConstructor = AbstractConstructorLike<[iterator: Iterator], IteratorTransformer>;
```
#### ToBatchesMode
```typescript
type ToBatchesMode = typeof SPREAD_BATCHES | typeof FILL_BATCHES;
```
Strategy for grouping array items into batches.
#### TypedPropertyDescriptor_2
```typescript
type TypedPropertyDescriptor = ValuePropertyDescriptor | GetPropertyDescriptor | SetPropertyDescriptor | GetSetPropertyDescriptor;
```
Union for reasonable configurations of property descriptors which could affect the type for the property.
#### ValuePropertyDescriptor
```typescript
type ValuePropertyDescriptor = PropertyDescriptorFlags & {
get?: never;
set?: never;
value: T;
};
```
Partial property descriptor which contains a static value, instead of an accessor and/or mutator.
#### WriteOnlyDescriptorsKeys
```typescript
type WriteOnlyDescriptorsKeys = R extends Record> ? {
[key in string & K]: IfWriteOnlyDescriptor;
}[string & K] : never;
```
Produce the non-mangled keys for the given property descriptors record which would produce write-only properties.
### Variables
#### con
```typescript
con: ConsoleLike
```
#### DQ
```typescript
DQ: "\""
```
#### DURATION_DATE_DESIGNATORS
```typescript
DURATION_DATE_DESIGNATORS: readonly DurationDesignator[]
```
#### DURATION_DESIGNATORS
```typescript
DURATION_DESIGNATORS: readonly DurationDesignator[]
```
#### DURATION_KEY_BY_DESIGNATOR
```typescript
DURATION_KEY_BY_DESIGNATOR: Readonly<{
readonly Y: "year";
readonly D: "day";
readonly H: "hour";
readonly S: "second";
readonly W: "week";
}>
```
Map between [DurationDesignator](#api-durationdesignator) and [Duration](#api-duration) property name. Does not include `M`, which is ambiguous, nor `T` which does not correspond to a property.
#### DURATION_KEY_SECONDS
```typescript
DURATION_KEY_SECONDS: Readonly>>
```
Lookup table for the conversion of a [Duration](#api-duration) property value to seconds. Does not include `month` or `year`, which have variable numbers of days.
#### DURATION_TIME_DESIGNATORS
```typescript
DURATION_TIME_DESIGNATORS: readonly DurationDesignator[]
```
#### ecmaKeySort
```typescript
ecmaKeySort: Comparator
```
Comparator for Object keys in ECMA "correct" order. Don't read the history on this. It will only depress you.
#### FILL_BATCHES
```typescript
FILL_BATCHES = "fill"
```
Fill each batch to the maximum, except possibly the last. That is, if the list has 11 items with a `maxPerBatch` of 5, you would get `[5, 5, 1]`.
#### INDEX_KEY_PATTERN
```typescript
INDEX_KEY_PATTERN: RegExp
```
Pattern for an array index key, basically any integer.
#### INFINITY_SIGIL
```typescript
INFINITY_SIGIL = "∞"
```
Text used for displaying human-readable infinity.
#### INT_SET_SIGIL
```typescript
INT_SET_SIGIL = "ℤ"
```
#### intRange
```typescript
intRange: IntRange
```
Start generating a range of integers.
#### JSON_PATH_ROOT
```typescript
JSON_PATH_ROOT: "$"
```
#### JSON_PUNCTUATION
```typescript
JSON_PUNCTUATION: readonly JsonPunctuation[]
```
#### JsonParseTransition
```typescript
JsonParseTransition: Readonly<{
readonly Begin: "begin";
readonly End: "end";
}>
```
#### JsonParseType
```typescript
JsonParseType: Readonly<{
readonly Arr: "array";
readonly Item: "item";
readonly Obj: "object";
readonly Prop: "property";
readonly Root: "root";
}>
```
#### JsonTokenType
```typescript
JsonTokenType: Readonly<{
Boo: "boolean";
Nul: "null";
Num: "number";
Pun: "pun";
Spc: "space";
Str: "string";
}>
```
Discriminators for each of the `type` values for [JsonToken](#api-jsontoken).
#### LCE_PRESET_NAMES
```typescript
LCE_PRESET_NAMES: LCEPresetName[]
```
#### LCE_PRESETS
```typescript
LCE_PRESETS: {
ansiC: (seed: number | bigint | undefined) => {
a: number;
c: number;
m: number;
seed: number | bigint | undefined;
width: number;
};
borlandC: (seed: number | bigint | undefined) => {
a: number;
c: number;
m: number;
seed: number | bigint | undefined;
width: number;
};
c88: (seed: number | bigint | undefined) => {
a: number;
c: number;
m: number;
seed: number | bigint | undefined;
};
c93: (seed: number | bigint | undefined) => {
a: number;
c: number;
m: number;
seed: number | bigint | undefined;
};
delphi: (seed: number | bigint | undefined) => {
a: number;
c: number;
m: number;
seed: number | bigint | undefined;
width: number;
};
glibc: (seed: number | bigint | undefined) => {
a: number;
c: number;
m: number;
seed: number | bigint | undefined;
width: number;
};
java: (seed?: number | bigint | undefined) => RNGOptions;
knuth: (seed: number | bigint | undefined) => {
a: bigint;
c: number;
m: bigint;
seed: number | bigint | undefined;
width: number;
};
visualC: (seed: number | bigint | undefined) => {
a: number;
c: number;
m: number;
floor: number;
seed: number | bigint | undefined;
width: number;
};
}
```
#### METRIC_PREFIXES
```typescript
METRIC_PREFIXES: readonly string[]
```
List of metric prefixes, where the index is its base-1000 or base-1024 offset.
#### NEG_INFINITY_SIGIL
```typescript
NEG_INFINITY_SIGIL = "-∞"
```
Text used for displaying human-readable negative infinity.
#### numberAsc
```typescript
numberAsc: Comparator
```
Numeric comparator which sorts lower values before higher ones.
#### numberDesc