type-plus 3.13.0 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-plus",
-  "version": "3.13.0",
+  "version": "4.0.0",
   "description": "Provides additional types for `typescript`.",
   "homepage": "https://github.com/unional/type-plus",
   "bugs": {
@@ -16,30 +16,32 @@
     "email": "homawong@gmail.com"
   },
   "sideEffects": false,
-  "main": "lib/index.js",
-  "module": "libm/index.js",
-  "jsnext:main": "libm/index.js",
-  "typings": "lib/index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "jsnext:main": "esm/index.js",
+  "typings": "cjs/index.d.ts",
   "files": [
-    "lib",
-    "libm",
-    "src"
+    "cjs",
+    "esm",
+    "ts"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.es5.json && tsc -p tsconfig.esnext.json",
-    "clean": "rimraf coverage lib libm",
-    "codacy": "cat coverage/lcov.info | codacy-coverage",
-    "codecov": "codecov",
-    "coverage": "tsc -p tsconfig.json && jest --coverage",
-    "dc": "yarn dependency-check",
+    "build": "run-p build:cjs build:esm",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "clean": "rimraf cjs esm coverage lib libm",
+    "coverage": "jest --coverage",
     "depcheck": "yarn dependency-check",
-    "dependency-check": "dependency-check . --unused --no-dev -i ts-toolbelt -i typescript && dependency-check . --missing --no-dev",
+    "dependency-check": "run-p dependency-check:unused dependency-check:missing",
+    "dependency-check:missing": "dependency-check . --missing --no-dev",
+    "dependency-check:unused": "dependency-check . --unused --no-dev -i typescript",
     "lint": "eslint --ext=ts,js .",
     "nuke": "yarn clean && rimraf node_modules",
-    "semantic-release": "semantic-release",
-    "test": "tsc -p tsconfig.json && jest",
-    "verify": "yarn lint && yarn build && yarn dc && npx size-limit && yarn coverage",
-    "verify:ci": "yarn lint && yarn build && yarn dc && npx size-limit && yarn coverage --maxWorkers=2",
+    "release": "npx semantic-release",
+    "size-limit": "size-limit",
+    "test": "jest",
+    "verify": "run-p verify:build lint coverage",
+    "verify:build": "npm-run-all clean build --parallel dependency-check size-limit",
     "watch": "jest --watch"
   },
   "husky": {
@@ -48,48 +50,42 @@
     }
   },
   "dependencies": {
-    "tersify": "^3.7.8",
-    "unpartial": "^0.6.3"
+    "tersify": "^3.8.0",
+    "unpartial": "^0.6.4"
   },
   "devDependencies": {
-    "@babel/cli": "^7.14.3",
-    "@babel/core": "^7.14.3",
-    "@babel/plugin-proposal-class-properties": "^7.13.0",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.14.2",
-    "@babel/plugin-proposal-optional-chaining": "^7.14.2",
-    "@babel/preset-env": "^7.14.4",
-    "@babel/preset-typescript": "^7.13.0",
-    "@commitlint/cli": "^12.1.4",
-    "@commitlint/config-conventional": "^12.1.4",
-    "@size-limit/preset-small-lib": "^4.11.0",
-    "@types/jest": "^26.0.23",
+    "@babel/core": "^7.16.7",
+    "@babel/plugin-proposal-class-properties": "^7.16.7",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.7",
+    "@babel/plugin-proposal-optional-chaining": "^7.16.7",
+    "@babel/preset-env": "^7.16.7",
+    "@babel/preset-typescript": "^7.16.7",
+    "@commitlint/cli": "^16.0.1",
+    "@commitlint/config-conventional": "^16.0.0",
+    "@size-limit/preset-small-lib": "^7.0.5",
+    "@types/jest": "^27.4.0",
     "@unional/fixture": "^1.7.2",
-    "assertron": "^7.1.3",
-    "codecov": "^3.8.2",
-    "commitlint-circle": "^1.0.0",
+    "assertron": "^9.0.0",
     "dependency-check": "^4.1.0",
-    "eslint": "^7.28.0",
-    "eslint-plugin-harmony": "^5.1.0",
-    "husky": "^6.0.0",
-    "is-ci": "^3.0.0",
-    "jest": "^27.0.4",
-    "jest-junit": "^12.1.0",
-    "jest-progress-tracker": "^2.0.2",
-    "jest-validate": "^27.0.2",
+    "eslint": "^8.6.0",
+    "eslint-plugin-harmony": "^6.0.0",
+    "husky": "^7.0.4",
+    "jest": "^27.4.5",
+    "jest-progress-tracker": "^3.0.1",
+    "jest-validate": "^27.4.2",
+    "jest-watch-repeat": "^2.0.0",
     "jest-watch-suspend": "^1.1.2",
     "jest-watch-toggle-config": "^2.0.1",
-    "jest-watch-typeahead": "^0.6.4",
-    "npm-check-updates": "^11.6.0",
+    "jest-watch-typeahead": "^1.0.0",
+    "npm-run-all": "^4.1.5",
     "rimraf": "^3.0.2",
-    "satisfier": "^5.1.0",
-    "semantic-release": "^17.4.3",
-    "size-limit": "^4.11.0",
-    "ts-toolbelt": "^9.6.0",
-    "typescript": "^4.3.2"
+    "satisfier": "^5.1.1",
+    "size-limit": "^7.0.5",
+    "typescript": "^4.5.4"
   },
   "size-limit": [
     {
-      "limit": "10 kb"
+      "limit": "15 kb"
     }
   ]
 }

package/ts/ComposableTypes.spec.ts

@@ -0,0 +1,29 @@
+import { assertType, canAssign, ComposableTypes, NonComposableTypes } from '.'
+
+test('ComposableTypes includes object, array, and function', () => {
+  assertType<ComposableTypes>({})
+  assertType<ComposableTypes>([])
+  // function is composable because you can do
+  // `Object.assign(fn, { ... })
+  assertType<ComposableTypes>(() => { })
+
+  assertType.isTrue(canAssign<ComposableTypes>(false)(null))
+  assertType.isTrue(canAssign<ComposableTypes>(false)(undefined))
+  assertType.isTrue(canAssign<ComposableTypes>(false)(1))
+  assertType.isTrue(canAssign<ComposableTypes>(false)(true))
+  assertType.isTrue(canAssign<ComposableTypes>(false)(''))
+  assertType.isTrue(canAssign<ComposableTypes>(false)(Symbol()))
+})
+
+test('NonComposableType excludes object, array, and function', () => {
+  assertType<NonComposableTypes>(null)
+  assertType<NonComposableTypes>(undefined)
+  assertType<NonComposableTypes>(true)
+  assertType<NonComposableTypes>(1)
+  assertType<NonComposableTypes>('')
+  assertType<NonComposableTypes>(Symbol())
+
+  assertType.isTrue(canAssign<NonComposableTypes>(false)({}))
+  assertType.isTrue(canAssign<NonComposableTypes>(false)([]))
+  assertType.isTrue(canAssign<NonComposableTypes>(false)(() => { }))
+})

package/ts/ComposableTypes.ts

@@ -0,0 +1,10 @@
+/**
+ * Types that can contain custom properties.
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type ComposableTypes = object | Function
+
+/**
+ * Types that cannot contain custom properties.
+ */
+export type NonComposableTypes = boolean | number | string | symbol | bigint | undefined | null

package/ts/JSONTypes.spec.ts

@@ -0,0 +1,43 @@
+import { assertType } from './assertion'
+import { JSONObject, JSONTypes } from './JSONTypes'
+import { isType } from './predicates'
+
+test('empty object', () => {
+  assertType<JSONTypes>({})
+})
+
+test('empty array', () => {
+  assertType<JSONTypes>([])
+})
+
+test('string array', () => {
+  assertType<JSONTypes>(['a'])
+})
+
+test('JSONObject', () => {
+  isType<JSONObject>({})
+})
+
+describe('JSONTypes.get', () => {
+  test('cast to T | undefined without props', () => {
+    const a = JSONTypes.get<string>('abc')
+    isType<string | undefined>(a)
+    expect(a).toBe('abc')
+  })
+  test('get object props', () => {
+    const a = JSONTypes.get<string>({ a: { b: 'abc' } }, 'a', 'b')
+    isType<string | undefined>(a)
+    expect(a).toBe('abc')
+  })
+
+  test('get array entry', () => {
+    const a = JSONTypes.get<string>(['abc'], 0)
+    isType<string | undefined>(a)
+    expect(a).toBe('abc')
+  })
+  test('nested', () => {
+    const a = JSONTypes.get<string>({ a: { b: [{ c: 'abc' }] } }, 'a', 'b', 0, 'c')
+    isType<string | undefined>(a)
+    expect(a).toBe('abc')
+  })
+})

package/ts/JSONTypes.ts

@@ -0,0 +1,18 @@
+
+export type JSONTypes = JSONPrimitive | JSONObject | JSONArray
+
+export type JSONPrimitive = boolean | number | string | null
+
+export type JSONObject = { [key in string]?: JSONTypes }
+
+export type JSONArray = Array<JSONTypes>
+
+export const JSONTypes = { get }
+
+function get<T extends JSONTypes>(obj: JSONTypes, ...props: Array<string | number>): T | undefined {
+  if (props.length === 0) return obj as T
+  if (typeof obj !== 'object' || obj === null) return undefined
+  const p = props.shift()!
+  // @ts-ignore
+  return get(obj[p], ...props) as T
+}

package/ts/PrimitiveTypes.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type PrimitiveTypes = boolean | number | string | object | symbol | bigint | Function | undefined | null

package/ts/UnionToIntersection.ts

@@ -0,0 +1,7 @@
+// from jcalz, https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type/50375286#50375286
+// istanbul ignore file
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never
+
+export function toIntersection<U>(union: U): UnionToIntersection<U> {
+  return union as any as UnionToIntersection<U>
+}

package/ts/array/CommonPropKeys.spec.ts

@@ -0,0 +1,20 @@
+import { assertType, CommonPropKeys, Equal } from '..'
+
+test('no common key returns never', () => {
+  type S = [{ a: number }, { b: number }]
+  type A = CommonPropKeys<S>
+  assertType.isTrue(true as Equal<A, never>)
+})
+
+test('single common key', () => {
+  type S = [{ a: number, c: number }, { a: number, b: number }]
+  type A = CommonPropKeys<S>
+  assertType.isTrue(true as Equal<A, 'a'>)
+})
+
+test('multiple common keys', () => {
+  type S = [{ a: number, b: number }, { a: number, b: number }]
+
+  type A = CommonPropKeys<S>
+  assertType.isTrue(true as Equal<A, 'a' | 'b'>)
+})

package/ts/array/CommonPropKeys.ts

@@ -0,0 +1,18 @@
+import { Tail } from './Tail'
+
+/**
+ * Gets the common property keys of the elements in `A`.
+ */
+export type CommonPropKeys<A extends Record<string, unknown>[]> = A['length'] extends 0
+  ? never
+  : (A['length'] extends 1
+    ? keyof A[0]
+    : (A['length'] extends 2
+      ? keyof A[0] & keyof A[1]
+      : keyof A[0] & keyof A[1] & CommonPropKeys<Tail<Tail<A>>>))
+
+/**
+ * Gets the common property keys of the elements in `A`.
+ * This will be deprecated in 4.0. Please use CommonPropKeys instead.
+ */
+export type CommonKeys<A extends Record<string, any>[]> = CommonPropKeys<A>

package/ts/array/Concat.spec.ts

@@ -0,0 +1,21 @@
+import { Concat, Equal, isType } from '..'
+
+test('concat array', () => {
+  type A = Concat<string[], boolean[]>
+  isType.t<Equal<Array<string | boolean>, A>>()
+})
+
+test('concat tuples', () => {
+  type A = Concat<[1, 2, 3], [4, 5]>
+  isType.t<Equal<[1, 2, 3, 4, 5], A>>()
+})
+
+test('concat array to tuple', () => {
+  type A = Concat<string[], [1, 2, 3]>
+  isType.t<Equal<Array<string | 1 | 2 | 3>, A>>()
+})
+
+test('concat tuple to array', () => {
+  type A = Concat<[1, 2, 3], string[]>
+  isType.t<Equal<[1, 2, 3, ...string[]], A>>()
+})

package/ts/array/Concat.ts

@@ -0,0 +1 @@
+export type Concat<A extends any[], B extends any[]> = [...A, ...B]

package/ts/array/CreateTuple.spec.ts

@@ -0,0 +1,21 @@
+import { CreateTuple, isType } from '..'
+
+test('create empty tuple', () => {
+  isType.equal<true, [], CreateTuple<0>>()
+})
+
+test('single element', () => {
+  isType.equal<true, [any], CreateTuple<1>>()
+})
+
+test('multiple elements', () => {
+  isType.equal<true, [any, any, any], CreateTuple<3>>()
+})
+
+test('override element type', () => {
+  isType.equal<true, [1, 1, 1, 1, 1], CreateTuple<5, 1>>()
+})
+
+test('negative length gets never', () => {
+  isType.equal<true, never, CreateTuple<-1>>()
+})

package/ts/array/CreateTuple.ts

@@ -0,0 +1,7 @@
+import { IsPositive } from '../math'
+
+export type CreateTuple<L extends number, T = any> =
+  IsPositive<L> extends true ? Device<[], L, T> : never
+
+type Device<R extends any[], L extends number, T> =
+  R['length'] extends L ? R : Device<[T, ...R], L, T>

package/ts/array/DropFirst.spec.ts

@@ -0,0 +1,21 @@
+import { DropFirst, isType } from '..'
+
+test('drop from empty gets itself', () => {
+  isType.equal<true, string[], DropFirst<string[]>>()
+})
+
+test('drop first value type from tuple', () => {
+  type Actual = DropFirst<[true, 1, 'x', 3]>
+  isType.equal<true, [1, 'x', 3], Actual>()
+})
+
+test('drop only value gets never[]', () => {
+  type Actual = DropFirst<['x']>
+  isType.equal<true, never[], Actual>()
+})
+
+test('array type gets itself', () => {
+  const s: string[] = ['a', 'b', 'c']
+  type Actual = DropFirst<typeof s>
+  isType.equal<true, string[], Actual>()
+})

package/ts/array/DropFirst.ts

@@ -0,0 +1,9 @@
+export type DropFirst<A extends any[]> = number extends A['length']
+  ? A
+  : (A['length'] extends 0
+    ? never[]
+    : (A['length'] extends 1
+      ? never[]
+      : (A extends [any, ...infer Tail]
+        ? Tail
+        : never)))

package/ts/array/DropLast.spec.ts

@@ -0,0 +1,21 @@
+import { DropLast, isType } from '..'
+
+test('drop from empty gets itself', () => {
+  isType.equal<true, string[], DropLast<string[]>>()
+})
+
+test('drop first value type from tuple', () => {
+  type Actual = DropLast<[true, 1, 'x', 3]>
+  isType.equal<true, [true, 1, 'x'], Actual>()
+})
+
+test('drop only value gets never[]', () => {
+  type Actual = DropLast<['x']>
+  isType.equal<true, never[], Actual>()
+})
+
+test('array type gets itself', () => {
+  const s: string[] = ['a', 'b', 'c']
+  type Actual = DropLast<typeof s>
+  isType.equal<true, string[], Actual>()
+})

package/ts/array/DropLast.ts

@@ -0,0 +1,9 @@
+export type DropLast<A extends any[]> = number extends A['length']
+  ? A
+  : (A['length'] extends 0
+    ? never[]
+    : (A['length'] extends 1
+      ? never[]
+      : (A extends [...infer Heads, any]
+        ? Heads
+        : never)))

package/ts/array/Filter.spec.ts

@@ -0,0 +1,21 @@
+import { assertType, Equal, Filter } from '..'
+
+test('array matching criteria gets itself', () => {
+  type Actual = Filter<string[], string>
+  assertType.isTrue(true as Equal<string[], Actual>)
+})
+
+test('array not matching criteria gets never[]', () => {
+  type Actual = Filter<string[], number>
+  assertType.isTrue(true as Equal<never[], Actual>)
+})
+
+test('tuple filters to those matching criteria', () => {
+  type Actual = Filter<[1, 2, 3, 4], 2 | 4>
+  assertType.isTrue(true as Equal<[2, 4], Actual>)
+})
+
+test('tuple not value match criteria gets never[]', () => {
+  type Actual = Filter<[1, 2, 3, 4], 5>
+  assertType.isTrue(true as Equal<never[], Actual>)
+})

package/ts/array/Filter.ts

@@ -0,0 +1,12 @@
+export type Filter<A extends Array<any>, Criteria> =
+  number extends A['length']
+  ? (A[0] extends Criteria ? A : never[])
+  : (A['length'] extends 0
+    ? never
+    : (A extends [infer Head, ...infer Tail]
+      ? (Tail['length'] extends 0
+        ? (Head extends Criteria ? [Head] : never[])
+        : (Head extends Criteria
+          ? [Head, ...Filter<Tail, Criteria>]
+          : Filter<Tail, Criteria>))
+      : never))

package/ts/array/FindFirst.spec.ts

@@ -0,0 +1,27 @@
+import { assertType, Equal, FindFirst } from '..'
+
+test('pick first type matching criteria', () => {
+  type Actual = FindFirst<[true, 1, 'x', 3], number>
+  assertType.isTrue(true as Equal<1, Actual>)
+})
+
+test('no match gets never', () => {
+  type Actual = FindFirst<[true, 1, 'x'], 2>
+  assertType.isTrue(true as Equal<never, Actual>)
+})
+
+test('pick object', () => {
+  type Actual = FindFirst<[
+    { name: 'a', type: 1 },
+    { name: 'b', type: 2 },
+    { name: 'c', type: 3 },
+    { name: 'b', type: 4 },
+  ], { name: 'b' }>['type']
+  assertType.isTrue(true as Equal<2, Actual>)
+})
+
+test('generic', () => {
+  const s: string[] = ['a', 'b', 'c']
+  type Actual = FindFirst<typeof s, string>
+  assertType.isTrue(true as Equal<string, Actual>)
+})

package/ts/array/FindFirst.ts

@@ -0,0 +1,13 @@
+export type FindFirst<A extends Array<any>, Criteria> = (
+  number extends A['length']
+  ? A[0] extends Criteria ? A[0] : never
+  : (A['length'] extends 0
+    ? never
+    : (A extends [any, ...infer Tail]
+      ? A[0] extends Criteria ? A[0] : FindFirst<Tail, Criteria>
+      : never)))
+
+/**
+ * @deprecated use FindFirst
+ */
+export type First<A extends any[], Criteria> = FindFirst<A, Criteria>

package/ts/array/FindLast.spec.ts

@@ -0,0 +1,27 @@
+import { assertType, Equal, FindLast } from '..'
+
+test('pick last type matching criteria', () => {
+  type Actual = FindLast<[true, 1, 'x', 3], number>
+  assertType.isTrue(true as Equal<3, Actual>)
+})
+
+test('no match gets never', () => {
+  type Actual = FindLast<[true, 1, 'x'], 2>
+  assertType.isTrue(true as Equal<never, Actual>)
+})
+
+test('pick object', () => {
+  type Actual = FindLast<[
+    { name: 'a', type: 1 },
+    { name: 'b', type: 2 },
+    { name: 'c', type: 3 },
+    { name: 'b', type: 4 },
+  ], { name: 'b' }>['type']
+  assertType.isTrue(true as Equal<4, Actual>)
+})
+
+test('works on array type', () => {
+  const s: string[] = ['a', 'b', 'c']
+  type Actual = FindLast<typeof s, string>
+  assertType.isTrue(true as Equal<string, Actual>)
+})

package/ts/array/FindLast.ts

@@ -0,0 +1,8 @@
+export type FindLast<A extends Array<any>, Criteria> =
+  number extends A['length']
+  ? A[0] extends Criteria ? A[0] : never
+  : (A['length'] extends 0
+    ? never
+    : (A extends [...infer Heads, infer Last]
+      ? Last extends Criteria ? Last : FindLast<Heads, Criteria>
+      : never))

package/ts/array/Head.spec.ts

@@ -0,0 +1,21 @@
+import { assertType, Equal, Head } from '..'
+
+test('get first type', () => {
+  type S = [1, 'a', 'b']
+  type A = Head<S>
+
+  assertType.isTrue(true as Equal<A, 1>)
+})
+
+test('empty tuple gets never', () => {
+  type S = []
+  type A = Head<S>
+
+  assertType.isTrue(true as Equal<A, never>)
+})
+
+test('array gets same type', () => {
+  type A = Head<string[]>
+
+  assertType.isTrue(true as Equal<A, string>)
+})

package/ts/array/Head.ts

@@ -0,0 +1 @@
+export type Head<T extends any[]> = T['length'] extends 0 ? never : T[0]

package/ts/array/IntersectOfProps.spec.ts

@@ -0,0 +1,14 @@
+import { assertType, Equal, IntersectOfProps } from '..'
+
+test('get property from single value tuple', () => {
+  type S = [{ a: number }]
+  type A = IntersectOfProps<S, 'a'>
+
+  assertType.isTrue(true as Equal<A, number>)
+})
+
+test('get property from multiple values', () => {
+  type S = [{ a: { x: number } }, { a: { y: string } }]
+  type A = IntersectOfProps<S, 'a'>
+  assertType.isTrue(true as Equal<A, { x: number } & { y: string }>)
+})

package/ts/array/IntersectOfProps.ts

@@ -0,0 +1,20 @@
+import { KeyTypes } from '../object'
+import { Tail } from './Tail'
+
+/**
+ * Gets the intersect of properties of the elements in `A`
+ */
+export type IntersectOfProps<
+  A extends Record<any, unknown>[],
+  P extends KeyTypes
+  > = A['length'] extends 0
+  ? never
+  : (A['length'] extends 1
+    ? A[0][P]
+    : A[0][P] & IntersectOfProps<Tail<A>, P>)
+
+/**
+ * Gets the intersect of properties of the elements in `A`
+ * This will be deprecated in 4.0. Please use IntersectOfProps instead.
+ */
+export type MapToProp<A extends Record<any, any>[], P extends KeyTypes> = IntersectOfProps<A, P>

package/ts/array/IsArray.ts

@@ -0,0 +1 @@
+export type IsArray<T, Then = true, Else = false> = T extends any[] ? Then : Else

package/ts/array/PadLeft.spec.ts

@@ -0,0 +1,26 @@
+import { isType, PadLeft } from '..'
+
+test('zero length returns the same', () => {
+  isType.equal<true, [], PadLeft<[], 0>>()
+})
+
+test('pad with any by default', () => {
+  isType.equal<true, [any, any], PadLeft<[], 2>>()
+  isType.equal<true, [any, any, 1, 2, 3], PadLeft<[1, 2, 3], 5>>()
+})
+
+test('pad length less than tuple length is ignored', () => {
+  isType.equal<true, [1, 2, 3], PadLeft<[1, 2, 3], 2>>()
+})
+
+test('pad elements before array', () => {
+  isType.equal<true, [any, any, any, ...string[]], PadLeft<string[], 3>>()
+})
+
+test('override PadWith', () => {
+  isType.equal<true, [{ a: 1 }, { a: 1 }, 1, 2, 3], PadLeft<[1, 2, 3], 5, { a: 1 }>>()
+})
+
+test('pad and array value type is the same returns array', () => {
+  isType.equal<true, string[], PadLeft<string[], 3, string>>()
+})

package/ts/array/PadLeft.ts

@@ -0,0 +1,16 @@
+import { Equal, IsAny } from '../predicates'
+import { CreateTuple } from './CreateTuple'
+import { UnionOfValues } from './UnionOfValues'
+
+export type PadLeft<A extends any[], Total extends number, PadWith = any> =
+  number extends A['length']
+  ? (IsAny<UnionOfValues<A>> extends true
+    ? A
+    : (Equal<UnionOfValues<A>, PadWith> extends true
+      ? A
+      : PadLeft<[...CreateTuple<Total, PadWith>, ...A], Total, PadWith>))
+  : (CreateTuple<Total, any> extends [...infer U, ...A]
+    ? (number extends U['length']
+      ? A
+      : [...CreateTuple<U['length'], PadWith>, ...A])
+    : A)