@avstantso/ts 1.3.1 → 1.3.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.3.3] - 2026-01-15
+
+### Fixed
+
+- Fixed AI hallucinations in README.md
+
+## [1.3.2] - 2026-02-05
+
+### Changed
+
+- +String.Split
+
 
 ## [1.3.1] - 2026-02-04
 

package/README.md

@@ -73,22 +73,189 @@ const flattened = TS.flat({ a: 1, b: { c: 2 } }); // { a: 1, c: 2 }
 
 The `@avstantso/ts` package provides a comprehensive suite of type-level utilities organized into the following namespaces:
 
-- [TS.Extends](#tsextends) - Type extension checking
-- [TS.Increment / TS.Decrement](#tsincrement--tsdecrement) - Numeric type arithmetic
-- [TS.Func](#tsfunc) - Function type utilities
-- [TS.Union](#tsunion) - Union type manipulation
-- [TS.Array](#tsarray) - Array type utilities
-- [TS.ASCII](#tsascii) - ASCII character types and maps
-- [TS.Comparisons](#tscomparisons) - Type-level comparisons
-- [TS.String](#tsstring) - String type manipulation
-- [TS.Structure](#tsstructure) - Object structure utilities
-  - [Object Constructor Extensions](#object-constructor-extensions) - Typed Object.keys/values/entries
-- [TS.Boolean](#tsboolean) - Boolean logic types
-- [TS.Numeric](#tsnumeric) - Numeric literal utilities
-- [TS.Literal](#tsliteral) - Type literal definitions
-- [TS.Type](#tstype) - Type manipulation utilities
-- [TS.Resolve](#tsresolve) - Type literal resolution
-- [TS Utility Types](#ts-utility-types) - Miscellaneous utility types
+- [TS.Extends](#tsextends) — Type extension checking
+- [TS.Increment / TS.Decrement](#tsincrement--tsdecrement) — Numeric type arithmetic
+  - [TS.ArrN / TS.ArrM](#tsarrn-and-tsarrm) — Array type constraints
+- [TS.Func](#tsfunc) — Function type utilities
+  - [TS.Func.Nested](#tsfuncnesteddepth-r-p) — Nested function type
+- [TS.Union](#tsunion) — Union type manipulation
+  - [TS.Union.ToIntersection](#tsuniontointersectionu) — Union → intersection
+  - [TS.Union.Pop](#tsunionpopu) — Pop last from union
+  - [TS.Union.ToTuple](#tsuniontotupleu) — Union → tuple
+- [TS.IsUnion](#tsisuniont-iftrue--true-iffalse--false) — Test if union
+- [TS.Array](#tsarray) — Array type utilities
+  - Creation
+    - [TS.Array.Create](#tsarraycreatel-item) — Create array of length
+    - [TS.Array.Create.Optional](#tsarraycreateoptionald-item) — Create optional array
+    - [TS.Array.Numbers](#tsarraynumbersl) — Numeric literals array
+    - [TS.Array.Letters](#tsarraylettersl) — Letters array
+  - Analysis
+    - [TS.Array.Length](#tsarraylength-tarr) — Array length
+    - [TS.Array.Length.IfExeeded](#tsarraylengthifexeededtarr-n-iftrue--true-iffalse--false) — Test length exceeded
+  - Search
+    - [TS.Array.IndexOf](#tsarrayindexoftarr-item-i--0) — Find index of item
+    - [TS.Array.IfHasItem](#tsarrayifhasitemtarr-item-iftrue--true-iffalse--false) — Test has item
+    - [TS.Array.IfEach](#tsarrayifeachtarr-item-iftrue--true-iffalse--false) — Test each item
+    - [TS.Array.CountOf](#tsarraycountoftarr-item) — Count matching items
+  - Transformation
+    - [TS.Array.AddUnique](#tsarrayadduniquetarr-item) — Add unique item
+    - [TS.Array.MergeUnique](#tsarraymergeuniquetarr1-tarr2) — Merge without duplicates
+    - [TS.Array.Filter](#tsarrayfiltertarr-tfilter--undefined) — Filter items
+    - [TS.Array.Filter.Unique](#tsarrayfilteruniquetarr) — Remove duplicates
+    - [TS.Array.Sub](#tsarraysubtarr-start-end) — Sub-array
+    - [TS.Array.Remove](#tsarrayremovetarr-start-end) — Remove section
+    - [TS.Array.Reverse](#tsarrayreversetarr) — Reverse array
+    - [TS.Array.Join](#tsarrayjointarr) — Join to string
+    - [TS.Array.Cast](#tsarraycasttarr-item--any) — Cast items to type
+  - Map / Record
+    - [TS.Array.ToKey](#tsarraytokeytarr) — Array → key union
+    - [TS.Array.ToKey2Key](#tsarraytokey2keytarr) — Key-to-key record
+    - [TS.Array.ToRecord](#tsarraytorecordtarr-t) — Array → record
+    - [TS.Array.KeyValueMapFrom](#tsarraykeyvaluemapfromkeys-firstvalue--0) — Key-value map
+    - [TS.Array.ValueKeyMapFrom](#tsarrayvaluekeymapfromkeys-firstvalue--0) — Value-key map
+  - Min / Max / Sort
+    - [TS.Array.Min](#tsarraymintarr) — Find minimum
+    - [TS.Array.Min.Index](#tsarrayminindextarr) — Find minimum index
+    - [TS.Array.Max](#tsarraymaxtarr) — Find maximum
+    - [TS.Array.Max.Index](#tsarraymaxindextarr) — Find maximum index
+    - [TS.Array.Sort](#tsarraysorttarr-asc--true) — Sort array
+    - [TS.Array.Sort.Pair](#tsarraysortpairk) — Pair for key-based sorting
+    - [TS.Array.Sort.Desc](#tsarraysortdesctarr) — Sort descending
+  - Runtime
+    - [TS.Array.ToKey2Key()](#tsarraytokey2keyaarr-a) — Create key-to-key record (runtime)
+- [TS.ASCII](#tsascii) — ASCII character types and maps
+  - Letters
+    - [TS.ASCII.Letters](#tsasciilettersisuppertrue) — Letter array by case
+    - [TS.ASCII.Letters.Upper](#tsasciilettersupper) / [.Lower](#tsasciiletterslower) — Upper/lowercase letter arrays
+    - [TS.ASCII.Letter](#tsasciiletter) — Letter union by case
+    - [TS.ASCII.Letter.Upper](#tsasciiletterupper) / [.Lower](#tsasciiletterlower) — Upper/lowercase letter unions
+  - Character Arrays
+    - [TS.ASCII](#tsascii-2) — All ASCII characters
+    - [TS.ASCII.Control](#tsasciicontrol) / [.Printable](#tsasciiprintable) / [.Extended](#tsasciiextended) — Character subsets
+  - Maps
+    - [TS.ASCII.Map](#tsasciimap) — Character → code map
+    - [TS.ASCII.Map.Control](#tsasciimapcontrol) / [.Printable](#tsasciimapprintable) / [.Extended](#tsasciimapextended) — Subset maps
+  - [TS.ASCII.Code](#tsasciicode) — Character → code lookup
+  - [TS.ASCII.Character](#tsasciicharacter) — All ASCII characters union
+- **Type-level comparisons**
+  - [TS.LT](#tslt) — Less than
+  - [TS.LTE](#tslte) — Less than or equal
+  - [TS.GT](#tsgt) — Greater than
+  - [TS.GTE](#tsgte) — Greater than or equal
+- [TS.String](#tsstring) — String type manipulation
+  - [TS.String\<T, D\>](#tsstring-1) — Cast to string literal
+  - [TS.String.Possible](#tsstringpossible) — Convertible types
+  - [TS.String.Pattern](#tsstringpattern) — Regex pattern shortcuts
+  - Analysis
+    - [TS.String.Length](#tsstringlength) — String length
+    - [TS.String.IsLengthBetween](#tsstringislengthbetween) — Length in range
+    - [TS.String.SplitToChars](#tsstringsplittochars) — Split to characters
+    - [TS.String.Split](#tsstringsplits-separator) — Split by separator
+  - Manipulation
+    - [TS.String.Repeat](#tsstringrepeat) — Repeat N times
+    - [TS.String.Includes](#tsstringincludes) — Test includes pattern
+    - [TS.String.IndexOf](#tsstringindexof) — Find pattern index
+    - [TS.String.Replace](#tsstringreplace) — Replace matches
+    - [TS.String.Trim](#tsstringtrim) — Trim whitespace
+    - [TS.String.Trim.Start](#tsstringtrimstart) / [.End](#tsstringtrimend) — Trim start/end
+  - Case Conversion
+    - [TS.String.Case](#tsstringcasetype-s-r) — Generic case conversion
+    - [TS.String.Case.Camel](#tsstringcasecamels-r--removes) — camelCase
+    - [TS.String.Case.Pascal](#tsstringcasepascals-r--removes) — PascalCase
+    - [TS.String.Case.Snake](#tsstringcasesnakes-r--removes) — snake_case
+    - [TS.String.Case.Snake.Up](#tsstringcasesnakeups-r--removes) — UPPER_SNAKE_CASE
+    - [TS.String.Case.Kebab](#tsstringcasekebabs-r--removes) — kebab-case
+    - [TS.String.Case.Settings.Removes](#tsstringcasesettingsremoves) — Removal characters
+    - [TS.String.Case.Settings.Removes.Map](#tsstringcasesettingsremovesmap) — Extensible removal map
+- [TS.Structure](#tsstructure) — Object structure utilities
+  - Test
+    - [TS.Structure.IfStructure](#tsstructureifstructuret-iftrue--true-iffalse--false) — Test is structure
+    - [TS.Structure](#tsstructuret) — Structure constraint
+    - [TS.Structure.Wildcard](#tsstructurewildcard) / [.MapOfNotRules](#tsstructuremapofnotrules) / [.NotRules](#tsstructurenotrules) — Rules
+  - Conversion
+    - [TS.Structure.ToKeysArray](#tsstructuretokenysarrayo) — Keys tuple
+    - [TS.Structure.ToValuesArray](#tsstructuretovaluesarrayo) — Values tuple
+    - [TS.Structure.ToEntriesArray](#tsstructuretoentriesarrayo) — Entries tuple
+  - Manipulation
+    - [TS.Structure.Separate](#tsstructureseparatet) — Separate plain/structural
+    - [TS.Structure.Reverse](#tsstructurereverse) — Reverse to value-key map
+    - [TS.Structure.Split](#tsstructuresplito) — Split to single-field objects
+    - [TS.Structure.Combine](#tsstructurecombinea) — Combine objects
+  - Runtime
+    - [TS.Structure.is()](#tsstructureis) — Test is structure (runtime)
+    - [TS.Structure.keyByValue()](#tsstructurekeybyvalue) — Find key by value (runtime)
+    - [TS.Structure.reverse()](#tsstructurereverse-1) — Reverse structure (runtime)
+  - [Object Constructor Extensions](#object-constructor-extensions) — Typed Object.keys/values/entries
+    - [Object.keysEx](#objectkeyso)
+    - [Object.valuesEx](#objectvaluesexo)
+    - [Object.entriesEx](#objectentriesexo)
+- **Boolean logic types**
+  - [TS.If](#tsifcondition-iftrue--true-iffalse--false) — Conditional
+  - [TS.And](#tsandconditions-iftrue--true-iffalse--false) — Logical AND
+  - [TS.Or](#tsorconditions-iftrue--true-iffalse--false) — Logical OR
+  - [TS.Xor](#tsxorconditions-iftrue--true-iffalse--false) — Logical XOR
+- [TS.Numeric](#tsnumeric) — Numeric literal utilities
+  - Domain-Independent
+    - [TS.Numeric.IsPositive](#tsnumericispositive) / [.IsNegative](#tsnumericisnegative) — Sign tests
+    - [TS.Numeric.Positive.ToNegative](#tsnumericpositivetonegative) / [Numeric.Negative.ToPositive](#tsnumericnegativetopositive) — Sign conversion
+    - [TS.Numeric.Sign](#tsnumericsign) — Get sign
+    - [TS.Numeric.Digits](#tsnumericdigits) — Digit characters
+    - [TS.Numeric.Digits.Map](#tsnumericdigitsmap) / [.IsOdd](#tsnumericdigitsisodd) — Digit maps
+    - [TS.Numeric.Digits.Hex](#tsnumericdigitshex) / [.Hex.Map](#tsnumericdigitshexmap) — Hexadecimal digits
+    - [TS.Numeric.IsOdd](#tsnumericisodd) / [.IsEven](#tsnumericiseven) — Parity tests
+    - [TS.Numeric.IsNumber](#tsnumericisnumber) — String → number test
+    - [TS.Numeric.Parse](#tsnumericparse) — String → number literal
+  - Domain
+    - [TS.Numeric.Domain.Positive](#tsnumericdomainpositive) / [.Negative](#tsnumericdomainnegative) — Numeric ranges
+    - [TS.Numeric.Domain.Increment](#tsnumericdomainincrement) / [.Decrement](#tsnumericdomaindecrement) — Full-domain inc/dec
+  - Math
+    - [TS.Numeric.Abs](#tsnumericabsn) — Absolute value
+    - [TS.Numeric.Invert](#tsnumericinvertn) — Invert sign
+    - [TS.Numeric.Summ](#tsnumericsummx-y) — Addition
+    - [TS.Numeric.Diff](#tsnumericdiffx-y) — Subtraction
+    - [TS.Numeric.Multiply](#tsnumericmultiplyx-y) — Multiplication
+    - [TS.Numeric.Div](#tsnumericdivx-y) — Division
+    - [TS.Numeric.Power](#tsnumericpowerx-e) — Exponentiation
+- [TS.Literal](#tsliteral) — Type literal definitions
+  - [TS.Literal](#tsliteral-1) — Available literals union
+  - [TS.Literal.Map](#tsliteralmap) — Literal → type map
+  - [TS.Literal.NumberLike](#tsliteralnumberlike) / [.IsNumberLike](#tsliteralisnumberlike) — Number-like literals
+  - [TS.Literal.StringLike](#tsliteralstringlike) / [.IsStringLike](#tsliteralisstringlike) — String-like literals
+  - [TS.Literal.List](#tsliterallist) — Literals array
+  - [TS.Literal.Key2KeyRec](#tsliteralkey2keyrec) — Key-to-key record
+  - Runtime
+    - [TS.Literal.List](#tsliterallist-1) — Literals array (runtime)
+    - [TS.Literal.Empty()](#tsliteralemptytype) — Get empty value
+    - [TS.Literal.IsValue()](#tsliteralisvaluetype-value) — Type guard
+    - [TS.Literal._Register()](#tsliteral_registerliteral-empty) — Register custom literal
+- [TS.Type](#tstype) — Type manipulation utilities
+  - [TS.Type](#tstype-1) — Available types union
+  - [TS.Type.Not](#tstypenotfunction) — Exclude types
+  - [TS.Type.Def](#tstypedef) — Type definition structure
+  - [TS.Type.KeyDef](#tstypekeydef) — Keyed type definition
+  - [TS.Type.KLD](#tstypekld) — Key-literal-default array
+  - [TS.Type.Union](#tstypeunion) — Type union with literal
+  - Runtime
+    - [TS.Type.KeyDef()](#tstypekeydefkey-type) — Create keyed def (runtime)
+    - [TS.Type.KLD()](#tstypekldkey-type-def) — Create KLD (runtime)
+- [TS.Resolve](#tsresolve) — Type literal resolution
+- **Utility Types** — Miscellaneous utility types
+  - [TS.Alt](#tsaltt) — Alternative fields
+  - [TS.Flat](#tsflatt-depth--1) — Flatten structure
+  - [TS.IfDef](#tsifdef) / [TS.IfDefKey](#tsifdefkey) — Defined selection
+  - [TS.Opaque](#tsopaquetypemeta-t) — Opaque/nominal types
+  - [TS.Options](#tsoptionstypemap-tdefaults) — Options with defaults
+  - Override
+    - [TS.Override](#tsoverridetbase-textended-toptional--false) — Override properties
+    - [TS.IfIsOverrided](#tsifisoverrided) / [.IfIsOverridedKey](#tsifisoverridedkey) — Test overridden
+    - [TS.IfNotOverrided](#tsifnotoverrided) / [.IfNotOverridedKey](#tsifnotoverridedkey) — Select if not overridden
+    - [TS.OverrideIfNot](#tsoverrideifnot) — Conditional override
+  - [TS.ReplaceKey](#tsreplacekey) / [TS.ReplaceKeyOpt](#tsreplacekeyopt) — Replace key type
+  - [TS.RequiredKeys](#tsrequiredkeys) / [TS.OptionalKeys](#tsoptionalkeys) — Key extraction
+  - [TS.Merge](#tsmerge) / [TS.Merge.Fields](#tsmergefields) — Type merging
+  - Runtime
+    - [TS.isKey()](#tsiskeyk-extends-avstandsotskey) — Key type guard
+    - [TS.flat()](#tsflatstructure-depth--1) — Flatten structure (runtime)
 
 ---
 
@@ -252,7 +419,7 @@ type Union = 'a' | 'b' | 'c';
 type Tuple = TS.Union.ToTuple<Union>; // ['a', 'b', 'c'] (order may vary)
 ```
 
-### `TS.Union.IsUnion<T, IfTrue = true, IfFalse = false>`
+### `TS.IsUnion<T, IfTrue = true, IfFalse = false>`
 
 Test if type is a union.
 
@@ -263,10 +430,10 @@ import { TS } from '@avstantso/ts';
 type MyUnion = 'a' | 'b' | 'c';
 type NotUnion = string;
 
-type Check1 = TS.Union.IsUnion<MyUnion>; // true
-type Check2 = TS.Union.IsUnion<NotUnion>; // false
-type Check3 = TS.Union.IsUnion<never>; // false
-type Check4 = TS.Union.IsUnion<number | boolean>; // true
+type Check1 = TS.IsUnion<MyUnion>; // true
+type Check2 = TS.IsUnion<NotUnion>; // false
+type Check3 = TS.IsUnion<never>; // false
+type Check4 = TS.IsUnion<number | boolean>; // true
 ```
 
 ---
@@ -637,7 +804,7 @@ type Idx2 = TS.Array.Max.Index<[1, undefined, 2]>; // 2
 
 #### `TS.Array.Sort<TArr, Asc = true>`
 
-Sort array items. Allows sorting array of `Sort.Pair<K>` to sort any data by key. Based on [TS.Comparisons](#tscomparisons).
+Sort array items. Allows sorting array of `Sort.Pair<K>` to sort any data by key. Based on [type-level comparisons](#type-level-comparisons).
 
 **Example:**
 ```typescript
@@ -700,7 +867,7 @@ if (Field.version === field) {
 
 ## TS.ASCII
 
-ASCII character types and utilities based on [ascii-code.com](https://www.ascii-code.com/). Used in [TS.Comparisons](#tscomparisons) for string comparison operations.
+ASCII character types and utilities based on [ascii-code.com](https://www.ascii-code.com/). Used in [type-level comparisons](#type-level-comparisons) for string comparison operations.
 
 ### ASCII Types
 
@@ -809,15 +976,13 @@ console.log(TS.ASCII.length); // 256
 
 ---
 
-## TS.Comparisons
+## Type-level Comparisons
 
 Type-level number and string comparisons.
 
 String comparison is based on [TS.ASCII](#tsascii) character-to-number conversion. Number comparison splits numbers into digit arrays, compares lengths, then iterates through digits from most to least significant.
 
-### Comparison Types
-
-#### `TS.Comparisons.LT<A, B, IfTrue = true, IfFalse = false>`
+### `TS.LT<A, B, IfTrue = true, IfFalse = false>`
 
 Test if `A < B`.
 
@@ -825,12 +990,12 @@ Test if `A < B`.
 ```typescript
 import { TS } from '@avstantso/ts';
 
-type NumLess = TS.Comparisons.LT<1, 2>; // true
-type NumNotLess = TS.Comparisons.LT<2, 1>; // false
-type StrLess = TS.Comparisons.LT<'a', 'b'>; // true
+type NumLess = TS.LT<1, 2>; // true
+type NumNotLess = TS.LT<2, 1>; // false
+type StrLess = TS.LT<'a', 'b'>; // true
 ```
 
-#### `TS.Comparisons.LTE<A, B, IfTrue = true, IfFalse = false>`
+### `TS.LTE<A, B, IfTrue = true, IfFalse = false>`
 
 Test if `A <= B`.
 
@@ -838,11 +1003,11 @@ Test if `A <= B`.
 ```typescript
 import { TS } from '@avstantso/ts';
 
-type NumLessEq = TS.Comparisons.LTE<1, 1>; // true
-type StrLessEq = TS.Comparisons.LTE<'a', 'a'>; // true
+type NumLessEq = TS.LTE<1, 1>; // true
+type StrLessEq = TS.LTE<'a', 'a'>; // true
 ```
 
-#### `TS.Comparisons.GT<A, B, IfTrue = true, IfFalse = false>`
+### `TS.GT<A, B, IfTrue = true, IfFalse = false>`
 
 Test if `A > B`.
 
@@ -850,11 +1015,11 @@ Test if `A > B`.
 ```typescript
 import { TS } from '@avstantso/ts';
 
-type NumGreater = TS.Comparisons.GT<2, 1>; // true
-type StrGreater = TS.Comparisons.GT<'b', 'a'>; // true
+type NumGreater = TS.GT<2, 1>; // true
+type StrGreater = TS.GT<'b', 'a'>; // true
 ```
 
-#### `TS.Comparisons.GTE<A, B, IfTrue = true, IfFalse = false>`
+### `TS.GTE<A, B, IfTrue = true, IfFalse = false>`
 
 Test if `A >= B`.
 
@@ -862,8 +1027,8 @@ Test if `A >= B`.
 ```typescript
 import { TS } from '@avstantso/ts';
 
-type NumGreaterEq = TS.Comparisons.GTE<2, 2>; // true
-type StrGreaterEq = TS.Comparisons.GTE<'b', 'b'>; // true
+type NumGreaterEq = TS.GTE<2, 2>; // true
+type StrGreaterEq = TS.GTE<'b', 'b'>; // true
 ```
 
 ---
@@ -960,6 +1125,26 @@ type Single = TS.String.SplitToChars<'A'>; // ['A']
 type Multiple = TS.String.SplitToChars<'AB'>; // ['A', 'B']
 ```
 
+#### `TS.String.Split<S, Separator>`
+
+Split string literal into substrings array by `Separator`.
+
+**Type Parameters:**
+- `S` - String literal to split
+- `Separator` - ASCII character to split by
+
+**Returns:** Array of string literal substrings
+
+**Example:**
+```typescript
+import { TS } from '@avstantso/ts';
+
+type Empty = TS.String.Split<'', ASCII.Character>; // ['']
+type Pipe = TS.String.Split<'A|B', '|'>; // ['A', 'B']
+type NoMatch = TS.String.Split<'A|B', ','>; // ['A|B']
+type CSV = TS.String.Split<'First,Next', ','>; // ['First', 'Next']
+```
+
 ### String Manipulation Types
 
 #### `TS.String.Repeat<S, N>`
@@ -1524,7 +1709,7 @@ const stringified = mapObjectValues(user, (key, value) => {
 
 ---
 
-## TS.Boolean
+## Boolean Logic Types
 
 Boolean type utilities and logical operations.
 
@@ -1540,7 +1725,7 @@ type Yes = TS.If<true, 'yes', 'no'>; // 'yes'
 type No = TS.If<false, 'yes', 'no'>; // 'no'
 ```
 
-### `TS.If.And<Conditions, IfTrue = true, IfFalse = false>`
+### `TS.And<Conditions, IfTrue = true, IfFalse = false>`
 
 Logical AND on array of conditions.
 
@@ -1548,11 +1733,11 @@ Logical AND on array of conditions.
 ```typescript
 import { TS } from '@avstantso/ts';
 
-type AllTrue = TS.If.And<[true, true, true]>; // true
-type OneFalse = TS.If.And<[true, false, true]>; // false
+type AllTrue = TS.And<[true, true, true]>; // true
+type OneFalse = TS.And<[true, false, true]>; // false
 ```
 
-### `TS.If.Or<Conditions, IfTrue = true, IfFalse = false>`
+### `TS.Or<Conditions, IfTrue = true, IfFalse = false>`
 
 Logical OR on array of conditions.
 
@@ -1560,11 +1745,11 @@ Logical OR on array of conditions.
 ```typescript
 import { TS } from '@avstantso/ts';
 
-type HasTrue = TS.If.Or<[false, true, false]>; // true
-type AllFalse = TS.If.Or<[false, false, false]>; // false
+type HasTrue = TS.Or<[false, true, false]>; // true
+type AllFalse = TS.Or<[false, false, false]>; // false
 ```
 
-### `TS.If.Xor<Conditions, IfTrue = true, IfFalse = false>`
+### `TS.Xor<Conditions, IfTrue = true, IfFalse = false>`
 
 Logical XOR on array of conditions (true if exactly one condition is true).
 
@@ -1572,9 +1757,9 @@ Logical XOR on array of conditions (true if exactly one condition is true).
 ```typescript
 import { TS } from '@avstantso/ts';
 
-type OnlyOne = TS.If.Xor<[false, true, false]>; // true
-type Multiple = TS.If.Xor<[true, true, false]>; // false
-type None = TS.If.Xor<[false, false, false]>; // false
+type OnlyOne = TS.Xor<[false, true, false]>; // true
+type Multiple = TS.Xor<[true, true, false]>; // false
+type None = TS.Xor<[false, false, false]>; // false
 ```
 
 ---
@@ -2211,7 +2396,7 @@ type OnlyType = TS.Resolve<{ T: Function }>; // Function
 
 ---
 
-## TS Utility Types
+## Utility Types
 
 Miscellaneous utility types for advanced type manipulation.
 

package/dist/_global/string.d.ts

@@ -97,6 +97,31 @@ declare namespace AVStantso.TS.String {
      * type l2 = CheckType<SplitToChars<'AB'>, ['A', 'B']>;
      */
     export type SplitToChars<S extends string> = S extends undefined ? S : _SplitToChars<S>;
+    /**
+     * @summary Split `string` literal to substrings array by `Separator`.\
+     * ⚠ Unsafe, internal
+     * @example
+     * type n = CheckType<_Split<never, never>, never>;
+     * type u = CheckType<_Split<undefined, never>, [undefined]>; // ⚠
+     * 
+     * type l0 = CheckType<_Split<'', ASCII.Character>, ['']>;
+     * type l1 = CheckType<_Split<'A|B', '|'>, ['A', 'B']>;
+     * type l2 = CheckType<_Split<'A|B', ','>, ['A|B']>;
+     * type l3 = CheckType<_Split<'First,Next', ','>, ['First', 'Next']>;
+     */
+    export type _Split<S extends string, Separator extends ASCII.Character, R extends string[] = []> = S extends `${infer C}${Separator}${infer E}` ? _Split<E, Separator, [...R, C]> : [...R, S];
+    /**
+     * @summary Split `string` literal to substrings array by `Separator`
+     * @example
+     * type n = CheckType<Split<never, never>, never>;
+     * type u = CheckType<Split<undefined, never>, []>;
+     * 
+     * type l0 = CheckType<Split<'', ASCII.Character>, ['']>;
+     * type l1 = CheckType<Split<'A|B', '|'>, ['A', 'B']>;
+     * type l2 = CheckType<Split<'A|B', ','>, ['A|B']>;
+     * type l3 = CheckType<Split<'First,Next', ','>, ['First', 'Next']>;
+     */
+    export type Split<S extends string, Separator extends ASCII.Character> = S extends undefined ? S : Separator extends undefined ? Separator : _Split<S, Separator>;
     type _Repeat<S extends Possible, N extends number, R extends string = ''> = N extends 0 ? R : _Repeat<S, Decrement<N>, `${R}${S}`>;
     /**
      * @summary Repeat string possible `S` by `N` times

package/package.json

@@ -2,7 +2,7 @@
   "name": "@avstantso/ts",
   "license": "MIT",
   "author": "avstantso",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "TypeScript helpers",
   "keywords": [
     "TypeScript"