@machine202502/types 1.0.0

package/README.md

@@ -0,0 +1,102 @@
+# @machine202502/types
+
+Type-only TypeScript package with **compile-time** integer math and number utilities.
+There is no runtime code — only `.d.ts` declarations.
+
+## Install
+
+```bash
+npm install @machine202502/types
+```
+
+Requires TypeScript 4.8+ (template literal types / recursive conditional types).
+
+## Imports
+
+| Entry | Purpose |
+|-------|---------|
+| `@machine202502/types/math` | Public integer/number math types |
+| `@machine202502/types/math/internal` | Lower-level helpers (digit tuples, boolean ops, string utils) |
+
+```ts
+import type {
+  NumberIntegerAdd,
+  NumberIntegerMultiply,
+  Trunc,
+  IsEven,
+} from "@machine202502/types/math";
+
+import type { And, Or, If, NumericalSign } from "@machine202502/types/math/internal";
+```
+
+## `@machine202502/types/math`
+
+### Number helpers
+
+| Type | Description |
+|------|-------------|
+| `IsFloat<N>` / `IsInteger<N>` | Whether `N` looks like a float / integer literal |
+| `IsOdd<N>` / `IsEven<N>` | Parity of truncated `N` |
+| `Abs<N>` / `Negate<N>` / `Sign<N>` | Absolute value, negation, sign (`-1 \| 0 \| 1`) |
+| `Signed<N, S>` | Apply sign `S` (or product of two signs) to `Abs<N>` |
+| `Trunc<N>` | Truncate toward zero via string split (drops fractional part) |
+| `NumberParts<N>` | `[sign, fixed, float]` parts of a number literal |
+
+### Integer compare
+
+| Type | Description |
+|------|-------------|
+| `NumberIntegerCompare<L, R>` | `-1 \| 0 \| 1` |
+| `NumberIntegerEq` / `Neq` / `Gt` / `Gte` / `Lt` / `Lte` | Boolean comparisons |
+| `NumberIntegerMin` / `Max` / `Clamp` | Min, max, clamp (values are truncated) |
+
+### Integer arithmetic
+
+Operands are truncated to integers. Results are **literal number types**.
+
+| Type | Description |
+|------|-------------|
+| `NumberIntegerAdd<L, R>` | `L + R` |
+| `NumberIntegerSubtract<L, R>` | `L - R` |
+| `NumberIntegerMultiply<L, R>` | `L * R` |
+| `NumberIntegerDivide<L, R>` | `[quotient, remainder]` or `null` on divide-by-zero |
+| `NumberIntegerPower<N, P>` | `N ** P` (`null` if `P < 0`) |
+
+```ts
+type A = NumberIntegerAdd<32, NumberIntegerMultiply<11, 11>>; // 153
+type P = NumberIntegerPower<2, 32>; // 4294967296
+type D = NumberIntegerDivide<100, 3>; // [33, 1]
+type T = Trunc<-234.601>; // -234
+```
+
+## `@machine202502/types/math/internal`
+
+Building blocks used by the public API. Prefer `@machine202502/types/math` in app code.
+
+| Group | Types |
+|-------|--------|
+| Boolean | `ToBoolean`, `Not`, `And`, `Or`, `If` |
+| Primitives | `NumericalDigit`, `NumericalDigitChar`, `NumericalSign`, `NumericalCompared`, `NumericalUintStringTuple` |
+| String | `StringLength`, `StringToTuple` |
+| Uint digit math | `NumberUintStringTupleAdd` / `Subtract` / `Multiply` / `Divide` / `Half` / `Power` / `Compare`, `NumberUintStringZeroLeftTrim`, `NumberUintStringZarr*`, conversion helpers |
+
+## Examples
+
+Runtime wrappers that *return* these types live in [`examples/`](./examples):
+
+- `examples/example-module.ts` — functions whose return types are the package types
+- `examples/example.ts` — end-to-end check (`npm run example`)
+
+```ts
+import type { NumberIntegerMultiply } from "@machine202502/types/math";
+
+function Multiply<L extends number, R extends number>(
+  l: L,
+  r: R,
+): NumberIntegerMultiply<L, R> {
+  return (Math.trunc(l) * Math.trunc(r)) as NumberIntegerMultiply<L, R>;
+}
+
+const n = Multiply(11, 11);
+//    ^? const n: 121
+```

package/dist/boolean/boolean.d.ts

@@ -0,0 +1,13 @@
+type _AcceptableFrom = boolean | string | number | bigint | undefined | null | object;
+type ToBoolean<B extends _AcceptableFrom> = B extends "" | 0 | 0n | false | undefined | null ? false : true;
+type Not<B extends _AcceptableFrom> = ToBoolean<B> extends true ? false : true;
+type And<L extends _AcceptableFrom, R extends _AcceptableFrom> = [
+    ToBoolean<L>,
+    ToBoolean<R>
+] extends [true, true] ? true : false;
+type Or<L extends _AcceptableFrom, R extends _AcceptableFrom> = [
+    ToBoolean<L>,
+    ToBoolean<R>
+] extends [false, true] | [true, true] | [true, false] ? true : false;
+type If<C extends _AcceptableFrom, TE, EE = void> = ToBoolean<C> extends true ? TE : EE;
+export { ToBoolean, Not, And, Or, If };

package/dist/common/types.d.ts

@@ -0,0 +1,7 @@
+type NumericalDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type NumericalCompared = -1 | 0 | 1;
+type NumericalSign = -1 | 0 | 1;
+type NumericalDigitChar = `${NumericalDigit}`;
+type NumericalUintStringTuple = NumericalDigitChar[];
+export { NumericalDigit, NumericalCompared, NumericalSign };
+export { NumericalDigitChar, NumericalUintStringTuple };

package/dist/math/index.d.ts

@@ -0,0 +1,3 @@
+export type { IsFloat, IsInteger, IsOdd, IsEven, Abs, Sign, Negate, Signed, Trunc, NumberParts, } from "../number/number";
+export type { NumberIntegerCompare, NumberIntegerGt, NumberIntegerGte, NumberIntegerLt, NumberIntegerLte, NumberIntegerMax, NumberIntegerMin, NumberIntegerEq, NumberIntegerNeq, NumberIntegerClamp, } from "../number-integer/number-integer-compare";
+export type { NumberIntegerAdd, NumberIntegerSubtract, NumberIntegerMultiply, NumberIntegerDivide, NumberIntegerPower, } from "../number-integer/number-integer-arithmetic";

package/dist/math/internal.d.ts

@@ -0,0 +1,13 @@
+export type { ToBoolean, Not, And, Or, If } from "../boolean/boolean";
+export type { NumericalCompared, NumericalDigit, NumericalDigitChar, NumericalSign, NumericalUintStringTuple, } from "../common/types";
+export type { StringLength, StringToTuple } from "../string/string";
+export type { NumberUintStringTupleCompare } from "../number-uint-string/number-uint-string-compare";
+export type { NumberUintStringTupleAdd } from "../number-uint-string/number-uint-string-arithmetic-add";
+export type { NumberUintStringTupleSubtract } from "../number-uint-string/number-uint-string-arithmetic-subtract";
+export type { NumberUintStringTupleDivide } from "../number-uint-string/number-uint-string-arithmetic-divide";
+export type { NumberUintStringTupleMultiply, NumberUintStringTupleMultiplyOnDigit, NumberUintStringTupleMultiplyOnEachDigit, } from "../number-uint-string/number-uint-string-arithmetic-multiply";
+export type { NumberUintStringTupleHalf } from "../number-uint-string/number-uint-string-arithmetic-half";
+export type { NumberUintStringTuplePower } from "../number-uint-string/number-uint-string-arithmetic-power";
+export type { NumberUintStringZeroLeftTrim } from "../number-uint-string/number-uint-string-trim";
+export type { NumberUintStringZarr, NumberUintStringZarrFixedMethod, NumberUintStringZarrIterationMethod, } from "../number-uint-string/number-uint-string-zarr";
+export type { NumberUintStringToTuple, NumberUintStringTupleToNumber, } from "../number-uint-string/number-uint-string-conversion";

package/dist/number/number.d.ts

@@ -0,0 +1,19 @@
+import { NumericalSign } from "../common/types";
+type IsInteger<N extends number> = `${N}` extends `${number}.${number}` ? false : true;
+type IsFloat<N extends number> = `${N}` extends `${number}.${number}` ? true : false;
+type Sign<N extends number> = N extends 0 ? 0 : `${N}` extends `-${number}` ? -1 : 1;
+type _AbsInfer<N extends number> = `-${N}`;
+type Abs<N extends number> = N extends 0 ? 0 : `${N}` extends _AbsInfer<infer X> ? X : N;
+type _NegateInfer<N extends number> = `${N}`;
+type Negate<N extends number> = N extends 0 ? 0 : `-${N}` extends _NegateInfer<infer A> ? A : `${N}` extends _AbsInfer<infer A> ? A : N;
+type Signed<N extends number, S extends NumericalSign | [NumericalSign, NumericalSign]> = S extends 0 | [0, 0] | [0, 1] | [0, -1] | [1, 0] | [-1, 0] ? 0 : S extends 1 | [1, 1] | [-1, -1] ? Abs<N> : Negate<Abs<N>>;
+type _NumberPartsSign<N extends number> = N extends 0 ? [sign: 0, number: 0] : `${N}` extends `-${infer AN extends number}` ? [sign: -1, number: AN] : [sign: 1, number: N];
+type _NumberPartsSplit<N extends number> = `${N}` extends `${infer FixedString extends string}.${infer Float extends number}` ? FixedString extends `${infer Fixed extends number}` ? [fixed: Fixed, float: Float] : [fixed: 0, float: 0] : [fixed: N, float: 0];
+type NumberParts<N extends number> = _NumberPartsSign<N> extends [
+    infer S extends NumericalSign,
+    infer AbsN extends number
+] ? [sign: S, ..._NumberPartsSplit<AbsN>] : [sign: 0, fixed: 0, float: 0];
+type Trunc<N extends number> = _NumberPartsSplit<N>[0];
+type IsOdd<N extends number> = `${Trunc<N>}` extends `${string}${1 | 3 | 5 | 7 | 9}` ? true : false;
+type IsEven<N extends number> = IsOdd<N> extends true ? false : true;
+export { IsInteger, IsFloat, Sign, Abs, Negate, Signed, NumberParts, Trunc, IsOdd, IsEven, };

package/dist/number-integer/number-integer-arithmetic.d.ts

@@ -0,0 +1,95 @@
+import { NumericalSign, NumericalUintStringTuple } from "../common/types";
+import { NumberUintStringToTuple, NumberUintStringTupleToNumber } from "../number-uint-string/number-uint-string-conversion";
+import { NumberUintStringTupleAdd } from "../number-uint-string/number-uint-string-arithmetic-add";
+import { NumberUintStringTupleSubtract } from "../number-uint-string/number-uint-string-arithmetic-subtract";
+import { NumberUintStringTupleMultiply } from "../number-uint-string/number-uint-string-arithmetic-multiply";
+import { NumberUintStringTupleDivide } from "../number-uint-string/number-uint-string-arithmetic-divide";
+import { NumberUintStringTupleCompare } from "../number-uint-string/number-uint-string-compare";
+import { NumberUintStringTuplePower } from "../number-uint-string/number-uint-string-arithmetic-power";
+import { Negate, Trunc } from "../number/number";
+import { IsEven } from "../number/number";
+import { NumberUintStringZarr } from "../number-uint-string/number-uint-string-zarr";
+type NumberIntegerAdd<L extends number, R extends number> = [
+    NumberUintStringToTuple<L>,
+    NumberUintStringToTuple<R>
+] extends [
+    [
+        infer LSign extends NumericalSign,
+        infer LTuple extends NumericalUintStringTuple
+    ],
+    [
+        infer RSign extends NumericalSign,
+        infer RTuple extends NumericalUintStringTuple
+    ]
+] ? [LSign, RSign] extends [0, 1 | -1] | [0, 0] ? Trunc<R> : [LSign, RSign] extends [1 | -1, 0] ? Trunc<L> : [LSign, RSign] extends [1, 1] | [-1, -1] ? NumberUintStringTupleToNumber<[
+    1,
+    NumberUintStringTupleAdd<LTuple, RTuple>
+]> : NumberUintStringTupleCompare<LTuple, RTuple> extends 1 ? NumberUintStringTupleToNumber<[
+    LSign,
+    NumberUintStringTupleSubtract<LTuple, RTuple>
+]> : NumberUintStringTupleToNumber<[
+    RSign,
+    NumberUintStringTupleSubtract<RTuple, LTuple>
+]> : 0;
+type NumberIntegerSubtract<L extends number, R extends number> = NumberIntegerAdd<L, Negate<R>>;
+type NumberIntegerMultiply<L extends number, R extends number> = [
+    NumberUintStringToTuple<L>,
+    NumberUintStringToTuple<R>
+] extends [
+    [
+        infer LSign extends NumericalSign,
+        infer LTuple extends NumericalUintStringTuple
+    ],
+    [
+        infer RSign extends NumericalSign,
+        infer RTuple extends NumericalUintStringTuple
+    ]
+] ? [LSign, RSign] extends [0, 0] | [1 | -1, 0] | [0, 1 | -1] ? 0 : [LSign, RSign] extends [1, 1] | [-1, -1] ? NumberUintStringTupleToNumber<[
+    1,
+    NumberUintStringTupleMultiply<LTuple, RTuple>
+]> : NumberUintStringTupleToNumber<[
+    -1,
+    NumberUintStringTupleMultiply<LTuple, RTuple>
+]> : 0;
+type NumberIntegerDivide<L extends number, R extends number> = [
+    NumberUintStringToTuple<L>,
+    NumberUintStringToTuple<R>
+] extends [
+    [
+        infer LSign extends NumericalSign,
+        infer LTuple extends NumericalUintStringTuple
+    ],
+    [
+        infer RSign extends NumericalSign,
+        infer RTuple extends NumericalUintStringTuple
+    ]
+] ? [LSign, RSign] extends [0, 0] | [1 | -1, 0] ? null : [LSign, RSign] extends [0, 1 | -1] ? [0, null] : NumberUintStringTupleDivide<LTuple, RTuple> extends [
+    infer QuotientNT extends NumericalUintStringTuple,
+    infer RemainderNT extends NumericalUintStringTuple
+] ? [LSign, RSign] extends [1, 1] | [-1, -1] ? [
+    quotient: NumberUintStringTupleToNumber<[1, QuotientNT]>,
+    remainder: NumberUintStringTupleToNumber<[LSign, RemainderNT]>
+] : [
+    quotient: NumberUintStringTupleToNumber<[-1, QuotientNT]>,
+    remainder: NumberUintStringTupleToNumber<[LSign, RemainderNT]>
+] : never : never;
+type NumberIntegerPower<N extends number, P extends number> = [
+    NumberUintStringToTuple<N>,
+    NumberUintStringToTuple<P>
+] extends [
+    [
+        infer NSign extends NumericalSign,
+        infer NTuple extends NumericalUintStringTuple
+    ],
+    [
+        infer PSign extends NumericalSign,
+        infer PTuple extends NumericalUintStringTuple
+    ]
+] ? PSign extends -1 ? null : PSign extends 0 ? 1 : IsEven<P> extends true ? NumberUintStringTupleToNumber<[
+    1,
+    NumberUintStringTuplePower<NTuple, NumberUintStringZarr<PTuple>>
+]> : NumberUintStringTupleToNumber<[
+    NSign,
+    NumberUintStringTuplePower<NTuple, NumberUintStringZarr<PTuple>>
+]> : 0;
+export { NumberIntegerAdd, NumberIntegerSubtract, NumberIntegerMultiply, NumberIntegerDivide, NumberIntegerPower, };

package/dist/number-integer/number-integer-compare.d.ts

@@ -0,0 +1,27 @@
+import { NumericalSign, NumericalUintStringTuple } from "../common/types";
+import { NumberUintStringToTuple } from "../number-uint-string/number-uint-string-conversion";
+import { NumberUintStringTupleCompare } from "../number-uint-string/number-uint-string-compare";
+import { Trunc } from "../number/number";
+type NumberIntegerCompare<L extends number, R extends number> = [
+    NumberUintStringToTuple<L>,
+    NumberUintStringToTuple<R>
+] extends [
+    [
+        infer LSign extends NumericalSign,
+        infer LTuple extends NumericalUintStringTuple
+    ],
+    [
+        infer RSign extends NumericalSign,
+        infer RTuple extends NumericalUintStringTuple
+    ]
+] ? [LSign, RSign] extends [-1, 0] | [-1, 1] | [0, 1] ? -1 : [LSign, RSign] extends [1, -1] | [1, 0] | [0, -1] ? 1 : [LSign, RSign] extends [1, 1] ? NumberUintStringTupleCompare<LTuple, RTuple> : NumberUintStringTupleCompare<RTuple, LTuple> : 0;
+type NumberIntegerGt<L extends number, R extends number> = NumberIntegerCompare<L, R> extends 1 ? true : false;
+type NumberIntegerGte<L extends number, R extends number> = NumberIntegerCompare<L, R> extends 1 | 0 ? true : false;
+type NumberIntegerLt<L extends number, R extends number> = NumberIntegerCompare<L, R> extends -1 ? true : false;
+type NumberIntegerLte<L extends number, R extends number> = NumberIntegerCompare<L, R> extends -1 | 0 ? true : false;
+type NumberIntegerEq<L extends number, R extends number> = NumberIntegerCompare<L, R> extends 0 ? true : false;
+type NumberIntegerNeq<L extends number, R extends number> = NumberIntegerCompare<L, R> extends 1 | -1 ? true : false;
+type NumberIntegerMin<L extends number, R extends number> = NumberIntegerLt<L, R> extends true ? Trunc<L> : Trunc<R>;
+type NumberIntegerMax<L extends number, R extends number> = NumberIntegerGt<L, R> extends true ? Trunc<L> : Trunc<R>;
+type NumberIntegerClamp<N extends number, Min extends number, Max extends number> = NumberIntegerMax<NumberIntegerMin<N, Max>, Min>;
+export { NumberIntegerCompare, NumberIntegerGt, NumberIntegerGte, NumberIntegerLt, NumberIntegerLte, NumberIntegerEq, NumberIntegerNeq, NumberIntegerMin, NumberIntegerMax, NumberIntegerClamp, };

package/dist/number-uint-string/number-uint-string-arithmetic-add.d.ts

@@ -0,0 +1,222 @@
+import { NumericalDigitChar, NumericalUintStringTuple } from "../common/types";
+import { NumberUintCharge } from "./number-uint-string-common";
+interface NumberUintAddMap {
+    "0,0,0": ["0", "0"];
+    "0,0,1": ["0", "1"];
+    "0,1,0": ["0", "1"];
+    "0,1,1": ["0", "2"];
+    "0,2,0": ["0", "2"];
+    "0,2,1": ["0", "3"];
+    "0,3,0": ["0", "3"];
+    "0,3,1": ["0", "4"];
+    "0,4,0": ["0", "4"];
+    "0,4,1": ["0", "5"];
+    "0,5,0": ["0", "5"];
+    "0,5,1": ["0", "6"];
+    "0,6,0": ["0", "6"];
+    "0,6,1": ["0", "7"];
+    "0,7,0": ["0", "7"];
+    "0,7,1": ["0", "8"];
+    "0,8,0": ["0", "8"];
+    "0,8,1": ["0", "9"];
+    "0,9,0": ["0", "9"];
+    "0,9,1": ["1", "0"];
+    "1,0,0": ["0", "1"];
+    "1,0,1": ["0", "2"];
+    "1,1,0": ["0", "2"];
+    "1,1,1": ["0", "3"];
+    "1,2,0": ["0", "3"];
+    "1,2,1": ["0", "4"];
+    "1,3,0": ["0", "4"];
+    "1,3,1": ["0", "5"];
+    "1,4,0": ["0", "5"];
+    "1,4,1": ["0", "6"];
+    "1,5,0": ["0", "6"];
+    "1,5,1": ["0", "7"];
+    "1,6,0": ["0", "7"];
+    "1,6,1": ["0", "8"];
+    "1,7,0": ["0", "8"];
+    "1,7,1": ["0", "9"];
+    "1,8,0": ["0", "9"];
+    "1,8,1": ["1", "0"];
+    "1,9,0": ["1", "0"];
+    "1,9,1": ["1", "1"];
+    "2,0,0": ["0", "2"];
+    "2,0,1": ["0", "3"];
+    "2,1,0": ["0", "3"];
+    "2,1,1": ["0", "4"];
+    "2,2,0": ["0", "4"];
+    "2,2,1": ["0", "5"];
+    "2,3,0": ["0", "5"];
+    "2,3,1": ["0", "6"];
+    "2,4,0": ["0", "6"];
+    "2,4,1": ["0", "7"];
+    "2,5,0": ["0", "7"];
+    "2,5,1": ["0", "8"];
+    "2,6,0": ["0", "8"];
+    "2,6,1": ["0", "9"];
+    "2,7,0": ["0", "9"];
+    "2,7,1": ["1", "0"];
+    "2,8,0": ["1", "0"];
+    "2,8,1": ["1", "1"];
+    "2,9,0": ["1", "1"];
+    "2,9,1": ["1", "2"];
+    "3,0,0": ["0", "3"];
+    "3,0,1": ["0", "4"];
+    "3,1,0": ["0", "4"];
+    "3,1,1": ["0", "5"];
+    "3,2,0": ["0", "5"];
+    "3,2,1": ["0", "6"];
+    "3,3,0": ["0", "6"];
+    "3,3,1": ["0", "7"];
+    "3,4,0": ["0", "7"];
+    "3,4,1": ["0", "8"];
+    "3,5,0": ["0", "8"];
+    "3,5,1": ["0", "9"];
+    "3,6,0": ["0", "9"];
+    "3,6,1": ["1", "0"];
+    "3,7,0": ["1", "0"];
+    "3,7,1": ["1", "1"];
+    "3,8,0": ["1", "1"];
+    "3,8,1": ["1", "2"];
+    "3,9,0": ["1", "2"];
+    "3,9,1": ["1", "3"];
+    "4,0,0": ["0", "4"];
+    "4,0,1": ["0", "5"];
+    "4,1,0": ["0", "5"];
+    "4,1,1": ["0", "6"];
+    "4,2,0": ["0", "6"];
+    "4,2,1": ["0", "7"];
+    "4,3,0": ["0", "7"];
+    "4,3,1": ["0", "8"];
+    "4,4,0": ["0", "8"];
+    "4,4,1": ["0", "9"];
+    "4,5,0": ["0", "9"];
+    "4,5,1": ["1", "0"];
+    "4,6,0": ["1", "0"];
+    "4,6,1": ["1", "1"];
+    "4,7,0": ["1", "1"];
+    "4,7,1": ["1", "2"];
+    "4,8,0": ["1", "2"];
+    "4,8,1": ["1", "3"];
+    "4,9,0": ["1", "3"];
+    "4,9,1": ["1", "4"];
+    "5,0,0": ["0", "5"];
+    "5,0,1": ["0", "6"];
+    "5,1,0": ["0", "6"];
+    "5,1,1": ["0", "7"];
+    "5,2,0": ["0", "7"];
+    "5,2,1": ["0", "8"];
+    "5,3,0": ["0", "8"];
+    "5,3,1": ["0", "9"];
+    "5,4,0": ["0", "9"];
+    "5,4,1": ["1", "0"];
+    "5,5,0": ["1", "0"];
+    "5,5,1": ["1", "1"];
+    "5,6,0": ["1", "1"];
+    "5,6,1": ["1", "2"];
+    "5,7,0": ["1", "2"];
+    "5,7,1": ["1", "3"];
+    "5,8,0": ["1", "3"];
+    "5,8,1": ["1", "4"];
+    "5,9,0": ["1", "4"];
+    "5,9,1": ["1", "5"];
+    "6,0,0": ["0", "6"];
+    "6,0,1": ["0", "7"];
+    "6,1,0": ["0", "7"];
+    "6,1,1": ["0", "8"];
+    "6,2,0": ["0", "8"];
+    "6,2,1": ["0", "9"];
+    "6,3,0": ["0", "9"];
+    "6,3,1": ["1", "0"];
+    "6,4,0": ["1", "0"];
+    "6,4,1": ["1", "1"];
+    "6,5,0": ["1", "1"];
+    "6,5,1": ["1", "2"];
+    "6,6,0": ["1", "2"];
+    "6,6,1": ["1", "3"];
+    "6,7,0": ["1", "3"];
+    "6,7,1": ["1", "4"];
+    "6,8,0": ["1", "4"];
+    "6,8,1": ["1", "5"];
+    "6,9,0": ["1", "5"];
+    "6,9,1": ["1", "6"];
+    "7,0,0": ["0", "7"];
+    "7,0,1": ["0", "8"];
+    "7,1,0": ["0", "8"];
+    "7,1,1": ["0", "9"];
+    "7,2,0": ["0", "9"];
+    "7,2,1": ["1", "0"];
+    "7,3,0": ["1", "0"];
+    "7,3,1": ["1", "1"];
+    "7,4,0": ["1", "1"];
+    "7,4,1": ["1", "2"];
+    "7,5,0": ["1", "2"];
+    "7,5,1": ["1", "3"];
+    "7,6,0": ["1", "3"];
+    "7,6,1": ["1", "4"];
+    "7,7,0": ["1", "4"];
+    "7,7,1": ["1", "5"];
+    "7,8,0": ["1", "5"];
+    "7,8,1": ["1", "6"];
+    "7,9,0": ["1", "6"];
+    "7,9,1": ["1", "7"];
+    "8,0,0": ["0", "8"];
+    "8,0,1": ["0", "9"];
+    "8,1,0": ["0", "9"];
+    "8,1,1": ["1", "0"];
+    "8,2,0": ["1", "0"];
+    "8,2,1": ["1", "1"];
+    "8,3,0": ["1", "1"];
+    "8,3,1": ["1", "2"];
+    "8,4,0": ["1", "2"];
+    "8,4,1": ["1", "3"];
+    "8,5,0": ["1", "3"];
+    "8,5,1": ["1", "4"];
+    "8,6,0": ["1", "4"];
+    "8,6,1": ["1", "5"];
+    "8,7,0": ["1", "5"];
+    "8,7,1": ["1", "6"];
+    "8,8,0": ["1", "6"];
+    "8,8,1": ["1", "7"];
+    "8,9,0": ["1", "7"];
+    "8,9,1": ["1", "8"];
+    "9,0,0": ["0", "9"];
+    "9,0,1": ["1", "0"];
+    "9,1,0": ["1", "0"];
+    "9,1,1": ["1", "1"];
+    "9,2,0": ["1", "1"];
+    "9,2,1": ["1", "2"];
+    "9,3,0": ["1", "2"];
+    "9,3,1": ["1", "3"];
+    "9,4,0": ["1", "3"];
+    "9,4,1": ["1", "4"];
+    "9,5,0": ["1", "4"];
+    "9,5,1": ["1", "5"];
+    "9,6,0": ["1", "5"];
+    "9,6,1": ["1", "6"];
+    "9,7,0": ["1", "6"];
+    "9,7,1": ["1", "7"];
+    "9,8,0": ["1", "7"];
+    "9,8,1": ["1", "8"];
+    "9,9,0": ["1", "8"];
+    "9,9,1": ["1", "9"];
+}
+type _NumberUintStringTupleAdd<LNT extends NumericalUintStringTuple, RNT extends NumericalUintStringTuple, ResultNT extends NumericalUintStringTuple, ResultCharge extends NumberUintCharge> = [LNT, RNT] extends [
+    [
+        ...infer LNTRest extends NumericalUintStringTuple,
+        infer LNTDigit extends NumericalDigitChar
+    ],
+    [
+        ...infer RNTRest extends NumericalUintStringTuple,
+        infer RNTDigit extends NumericalDigitChar
+    ]
+] ? NumberUintAddMap[`${LNTDigit},${RNTDigit},${ResultCharge}`] extends [
+    infer AddCharge extends NumberUintCharge,
+    infer AddDigit extends NumericalDigitChar
+] ? _NumberUintStringTupleAdd<LNTRest, RNTRest, [
+    AddDigit,
+    ...ResultNT
+], AddCharge> : [] : ResultCharge extends "0" ? [...LNT, ...RNT, ...ResultNT] : _NumberUintStringTupleAdd<[...LNT, ...RNT], ["1"], ResultNT, "0">;
+type NumberUintStringTupleAdd<LNT extends NumericalUintStringTuple, RNT extends NumericalUintStringTuple> = _NumberUintStringTupleAdd<LNT, RNT, [], "0">;
+export { NumberUintAddMap, NumberUintStringTupleAdd };

package/dist/number-uint-string/number-uint-string-arithmetic-divide.d.ts

@@ -0,0 +1,13 @@
+import { NumericalUintStringTuple } from "../common/types";
+import { NumberUintStringTupleCompare } from "./number-uint-string-compare";
+import { NumberUintStringTupleAdd } from "./number-uint-string-arithmetic-add";
+import { NumberUintStringTupleSubtract } from "./number-uint-string-arithmetic-subtract";
+import { NumberUintStringTupleMultiply } from "./number-uint-string-arithmetic-multiply";
+import { NumberUintStringTupleHalf } from "./number-uint-string-arithmetic-half";
+import { NumberUintStringZeroLeftTrim } from "./number-uint-string-trim";
+type _NumberUintStringTupleDivideBinary<LNT extends NumericalUintStringTuple, RNT extends NumericalUintStringTuple, LowNT extends NumericalUintStringTuple, HighNT extends NumericalUintStringTuple> = NumberUintStringTupleCompare<LowNT, HighNT> extends 0 | -1 ? NumberUintStringTupleHalf<NumberUintStringTupleAdd<LowNT, HighNT>> extends infer MidNT extends NumericalUintStringTuple ? NumberUintStringTupleMultiply<MidNT, RNT> extends infer MultipliedNT extends NumericalUintStringTuple ? NumberUintStringTupleCompare<MultipliedNT, LNT> extends 0 | -1 ? _NumberUintStringTupleDivideBinary<LNT, RNT, NumberUintStringTupleAdd<MidNT, ["1"]>, HighNT> : _NumberUintStringTupleDivideBinary<LNT, RNT, LowNT, NumberUintStringTupleSubtract<MidNT, ["1"]>> : never : never : [
+    quotient: HighNT,
+    remainder: NumberUintStringZeroLeftTrim<NumberUintStringTupleSubtract<LNT, NumberUintStringTupleMultiply<HighNT, RNT>>>
+];
+type NumberUintStringTupleDivide<LNT extends NumericalUintStringTuple, RNT extends NumericalUintStringTuple> = NumberUintStringTupleCompare<RNT, ["0"]> extends 0 ? null : _NumberUintStringTupleDivideBinary<LNT, RNT, ["0"], LNT>;
+export { NumberUintStringTupleDivide };