@fncts/base 0.0.1

package/_src/typeclass/WitherableWithIndex.ts

@@ -0,0 +1,359 @@
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { FilterableWithIndexMin } from "@fncts/base/typeclass/FilterableWithIndex";
+import type { TraversableWithIndexMin } from "@fncts/base/typeclass/TraversableWithIndex";
+import type { WitherableMin } from "@fncts/base/typeclass/Witherable";
+
+import { FilterableWithIndex } from "@fncts/base/typeclass/FilterableWithIndex";
+import { TraversableWithIndex } from "@fncts/base/typeclass/TraversableWithIndex";
+import { Witherable } from "@fncts/base/typeclass/Witherable";
+
+/**
+ * @tsplus type fncts.WitherableWithIndex
+ */
+export interface WitherableWithIndex<F extends HKT, FC = HKT.None>
+  extends FilterableWithIndex<F, FC>,
+    TraversableWithIndex<F, FC>,
+    Witherable<F, FC> {
+  readonly witherWithIndex_: witherWithIndex_<F, FC>;
+  readonly witherWithIndex: witherWithIndex<F, FC>;
+  readonly wiltWithIndex_: wiltWithIndex_<F, FC>;
+  readonly wiltWithIndex: wiltWithIndex<F, FC>;
+}
+
+/**
+ * @tsplus type fncts.WitherableWithIndexOps
+ */
+export interface WitherableWithIndexOps {}
+
+export const WitherableWithIndex: WitherableWithIndexOps = {};
+
+export type WitherableWithIndexMin<F extends HKT, FC = HKT.None> = FilterableWithIndexMin<F, FC> &
+  TraversableWithIndexMin<F, FC> &
+  WitherableMin<F, FC> & {
+    readonly witherWithIndex_: witherWithIndex_<F, FC>;
+    readonly wiltWithIndex_: wiltWithIndex_<F, FC>;
+  };
+
+/**
+ * @tsplus static fncts.WitherableWithIndexOps __call
+ */
+export function mkWitherableWithIndex<F extends HKT, FC = HKT.None>(
+  F: WitherableWithIndexMin<F, FC>,
+): WitherableWithIndex<F, FC> {
+  return HKT.instance({
+    ...FilterableWithIndex(F),
+    ...TraversableWithIndex(F),
+    ...Witherable(F),
+    wiltWithIndex_: F.wiltWithIndex_,
+    wiltWithIndex: <G extends HKT, CG = HKT.None>(AG: Applicative<G, CG>) => {
+      const wiltWithIndex_ = F.wiltWithIndex_(AG);
+      return <KG, QG, WG, XG, IG, SG, RG, EG, A, B, B1, KF>(
+          f: (
+            k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>,
+            a: A,
+          ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
+        ) =>
+        <QF, WF, XF, IF, SF, RF, EF>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) =>
+          wiltWithIndex_(wa, f);
+    },
+    witherWithIndex_: F.witherWithIndex_,
+    witherWithIndex: <G extends HKT, CG = HKT.None>(AG: Applicative<G, CG>) => {
+      const witherWithIndex_ = F.witherWithIndex_(AG);
+      return <KG, QG, WG, XG, IG, SG, RG, EG, A, B, KF>(
+          f: (
+            k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>,
+            a: A,
+          ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
+        ) =>
+        <QF, WF, XF, IF, SF, RF, EF>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) =>
+          witherWithIndex_(wa, f);
+    },
+  });
+}
+
+export interface witherWithIndex<F extends HKT, FC = HKT.None> {
+  <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B, KF>(
+    f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
+  ) => <QF, WF, XF, IF, SF, RF, EF>(
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+}
+
+export interface witherWithIndex_<F extends HKT, FC = HKT.None> {
+  <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <
+    KF,
+    QF,
+    WF,
+    XF,
+    IF,
+    SF,
+    RF,
+    EF,
+    KG,
+    QG,
+    WG,
+    XG,
+    IG,
+    SG,
+    RG,
+    EG,
+    A,
+    B,
+  >(
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+    f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
+  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+}
+
+export interface witherWithIndexSelf<F extends HKT, FC = HKT.None> {
+  <KF, QF, WF, XF, IF, SF, RF, EF, A>(self: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <
+    G extends HKT,
+    GC = HKT.None,
+  >(
+    F: Applicative<G, GC>,
+  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
+    f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
+  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+}
+
+export function mkWitherWithIndex<F extends HKT, FC = HKT.None>(): (
+  i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, G>(_: {
+    A: A;
+    B: B;
+    G: G;
+    FK: KF;
+    FQ: QF;
+    FW: WF;
+    FX: XF;
+    FI: IF;
+    FS: SF;
+    FR: RF;
+    FE: EF;
+  }) => (
+    G: Applicative<HKT.F<G>>,
+  ) => (
+    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Maybe<B>>,
+  ) => (
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  ) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>,
+) => witherWithIndex<F, FC>;
+export function mkWitherWithIndex() {
+  return (i: any) => i();
+}
+
+export function mkWitherWithIndex_<F extends HKT, FC = HKT.None>(): (
+  i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, G>(_: {
+    A: A;
+    B: B;
+    G: G;
+    FK: KF;
+    FQ: QF;
+    FW: WF;
+    FX: XF;
+    FI: IF;
+    FS: SF;
+    FR: RF;
+    FE: EF;
+  }) => (
+    G: Applicative<HKT.F<G>>,
+  ) => (
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Maybe<B>>,
+  ) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>,
+) => witherWithIndex_<F, FC>;
+export function mkWitherWithIndex_() {
+  return (i: any) => i();
+}
+
+export interface wiltWithIndex<F extends HKT, FC = HKT.None> {
+  <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B, B2, KF>(
+    f: (
+      k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>,
+      a: A,
+    ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>,
+  ) => <QF, WF, XF, IF, SF, RF, EF>(
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  ) => HKT.Kind<
+    G,
+    GC,
+    KG,
+    QG,
+    WG,
+    XG,
+    IG,
+    SG,
+    RG,
+    EG,
+    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
+  >;
+}
+
+export interface wiltWithIndex_<F extends HKT, FC = HKT.None> {
+  <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <
+    KF,
+    QF,
+    WF,
+    XF,
+    IF,
+    SF,
+    RF,
+    EF,
+    KG,
+    QG,
+    WG,
+    XG,
+    IG,
+    SG,
+    RG,
+    EG,
+    A,
+    B,
+    B2,
+  >(
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+    f: (
+      k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>,
+      a: A,
+    ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>,
+  ) => HKT.Kind<
+    G,
+    GC,
+    KG,
+    QG,
+    WG,
+    XG,
+    IG,
+    SG,
+    RG,
+    EG,
+    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
+  >;
+}
+
+export interface wiltWithIndexSelf<F extends HKT, FC = HKT.None> {
+  <KF, QF, WF, XF, IF, SF, RF, EF, A>(self: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <
+    G extends HKT,
+    GC = HKT.None,
+  >(
+    F: Applicative<G, GC>,
+  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B1, B2>(
+    f: (
+      k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>,
+      a: A,
+    ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B1, B2>>,
+  ) => HKT.Kind<
+    G,
+    GC,
+    KG,
+    QG,
+    WG,
+    XG,
+    IG,
+    SG,
+    RG,
+    EG,
+    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
+  >;
+}
+
+export function mkWiltWithIndex<F extends HKT, FC = HKT.None>(): (
+  i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B2, G>(_: {
+    A: A;
+    B: B;
+    B2: B2;
+    G: G;
+    FK: KF;
+    FQ: QF;
+    FW: WF;
+    FX: XF;
+    FI: IF;
+    FS: SF;
+    FR: RF;
+    FE: EF;
+  }) => (
+    G: Applicative<HKT.F<G>>,
+  ) => (
+    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Either<B, B2>>,
+  ) => (
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  ) => HKT.FK1<
+    G,
+    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
+  >,
+) => wiltWithIndex<F, FC>;
+export function mkWiltWithIndex() {
+  return (i: any) => i();
+}
+
+export function mkWiltWithIndex_<F extends HKT, FC = HKT.None>(): (
+  i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B1, B2, G>(_: {
+    G: G;
+    FK: KF;
+    FQ: QF;
+    FW: WF;
+    FX: XF;
+    FI: IF;
+    FS: SF;
+    FR: RF;
+    FE: EF;
+    A: A;
+    B: B1;
+    B2: B2;
+  }) => (
+    G: Applicative<HKT.F<G>>,
+  ) => (
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Either<B1, B2>>,
+  ) => HKT.FK1<
+    G,
+    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
+  >,
+) => wiltWithIndex_<F, FC>;
+export function mkWiltWithIndex_() {
+  return (i: any) => i();
+}
+
+export interface FilterWithIndexAFn_<F extends HKT, CF = HKT.None> {
+  <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <
+    KF,
+    QF,
+    WF,
+    XF,
+    IF,
+    SF,
+    RF,
+    EF,
+    AF,
+    KG,
+    QG,
+    WG,
+    XG,
+    IG,
+    SG,
+    RG,
+    EG,
+  >(
+    fa: HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
+    p: (i: HKT.IndexFor<F, HKT.OrFix<CF, "K", KF>>, a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
+  ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
+}
+
+export function filterWithIndexAF_<F extends HKT, CF = HKT.None>(
+  F: WitherableWithIndexMin<F, CF>,
+): FilterWithIndexAFn_<F, CF> {
+  return (G) => (fa, p) => F.witherWithIndex_(G)(fa, (i, a) => G.map_(p(i, a), (bb) => (bb ? Just(a) : Nothing())));
+}
+
+export interface filterWithIndexA<F extends HKT, CF = HKT.None> {
+  <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <KF, AF, KG, QG, WG, XG, IG, SG, RG, EG>(
+    p: (i: HKT.IndexFor<F, HKT.OrFix<CF, "K", KF>>, a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
+  ) => <QF, WF, XF, IF, SF, RF, EF>(
+    fa: HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
+  ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
+}
+
+export function filterWithIndexAF<F extends HKT, CF = HKT.None>(
+  F: WitherableWithIndexMin<F, CF>,
+): filterWithIndexA<F, CF> {
+  return (G) => (p) => (fa) => filterWithIndexAF_(F)(G)(fa, p);
+}

package/_src/typeclass/builtin/Symbol.ts

@@ -0,0 +1,8 @@
+declare global {
+  /**
+   * @tsplus type fncts.builtin.SymbolOps
+   */
+  export interface SymbolConstructor {}
+}
+
+export {};

package/_src/typeclass/builtin.ts

@@ -0,0 +1,3 @@
+// codegen:start { preset: barrel, include: ./builtin/*.ts }
+export * from "./builtin/Symbol.js";
+// codegen:end

package/_src/typeclass.ts

@@ -0,0 +1,38 @@
+// codegen:start { preset: barrel, include: ./typeclass/*.ts, exclude: ./typeclass/Showable.ts }
+export * from "./typeclass/Align.js";
+export * from "./typeclass/Alt.js";
+export * from "./typeclass/Alternative.js";
+export * from "./typeclass/Applicative.js";
+export * from "./typeclass/ApplicativeExcept.js";
+export * from "./typeclass/Apply.js";
+export * from "./typeclass/builtin.js";
+export * from "./typeclass/Chain.js";
+export * from "./typeclass/Closure.js";
+export * from "./typeclass/Eq.js";
+export * from "./typeclass/Equatable.js";
+export * from "./typeclass/Fail.js";
+export * from "./typeclass/Filterable.js";
+export * from "./typeclass/FilterableWithIndex.js";
+export * from "./typeclass/Foldable.js";
+export * from "./typeclass/FoldableWithIndex.js";
+export * from "./typeclass/Functor.js";
+export * from "./typeclass/FunctorWithIndex.js";
+export * from "./typeclass/Has.js";
+export * from "./typeclass/Hash.js";
+export * from "./typeclass/Hashable.js";
+export * from "./typeclass/HashEq.js";
+export * from "./typeclass/Monad.js";
+export * from "./typeclass/MonadExcept.js";
+export * from "./typeclass/Monoid.js";
+export * from "./typeclass/Nil.js";
+export * from "./typeclass/Ord.js";
+export * from "./typeclass/Ordering.js";
+export * from "./typeclass/Pointed.js";
+export * from "./typeclass/Semialign.js";
+export * from "./typeclass/Semigroup.js";
+export * from "./typeclass/Semimonoidal.js";
+export * from "./typeclass/Traversable.js";
+export * from "./typeclass/TraversableWithIndex.js";
+export * from "./typeclass/Witherable.js";
+export * from "./typeclass/WitherableWithIndex.js";
+// codegen:end

package/_src/types/extractions.ts

@@ -0,0 +1,11 @@
+export type ExtractContravariantPhantom<A, P extends PropertyKey> = [A] extends [{ [K in P]: (_: infer T) => void }]
+  ? T
+  : never;
+export type ExtractCovariantPhantom<A, P extends PropertyKey> = [A] extends [{ [K in P]: () => infer T }] ? T : never;
+
+export type _W<A> = ExtractCovariantPhantom<A, "_W">;
+export type _S1<A> = ExtractContravariantPhantom<A, "_S1">;
+export type _S2<A> = ExtractCovariantPhantom<A, "_S2">;
+export type _R<A> = ExtractContravariantPhantom<A, "_R">;
+export type _E<A> = ExtractCovariantPhantom<A, "_E">;
+export type _A<A> = ExtractCovariantPhantom<A, "_A">;

package/_src/types/utility.ts

@@ -0,0 +1,9 @@
+export type Primitive = string | number | boolean | null | symbol;
+
+export type Constructor<A> = { new (...args: any[]): A };
+
+export type Nullable<A> = A | null | undefined;
+
+export type IsInt<N extends number> = N & (`${N}` extends `${bigint}` ? N : never);
+
+export interface Spreadable extends Record<PropertyKey, any> {}

package/_src/types.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: types/*.ts }
+export * from "./types/extractions.js";
+export * from "./types/test.js";
+export * from "./types/utility.js";
+// codegen:end

package/_src/util/AnsiFormat.ts

@@ -0,0 +1,259 @@
+const ANSI_BACKGROUND_OFFSET = 10;
+const ANSI_BRIGHT_OFFSET     = 60;
+
+export const {
+  reset,
+  bold,
+  dim,
+  italic,
+  underline,
+  blink,
+  reversed,
+  invisible,
+  strikethrough,
+  black,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  brightBlack,
+  brightRed,
+  brightGreen,
+  brightYellow,
+  brightBlue,
+  brightMagenta,
+  brightCyan,
+  brightWhite,
+  bgBlack,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  bgBrightBlack,
+  bgBrightRed,
+  bgBrightGreen,
+  bgBrightYellow,
+  bgBrightBlue,
+  bgBrightMagenta,
+  bgBrightCyan,
+  bgBrightWhite,
+} = generateStyles();
+
+function _rgb(offset = 0) {
+  return (r: number, g: number, b: number) => (s: string) =>
+    `\u001b[${38 + offset};2;${r};${g};${b}m${s}${offset === ANSI_BACKGROUND_OFFSET ? RESET_BG : RESET_FG}`;
+}
+
+export function rgb(r: number, g: number, b: number): (s: string) => string {
+  return _rgb(0)(r, g, b);
+}
+
+export function bg_rgb(r: number, g: number, b: number): (s: string) => string {
+  return _rgb(ANSI_BACKGROUND_OFFSET)(r, g, b);
+}
+
+/**
+ * Foreground color for ANSI black
+ */
+export const BLACK = escape(30);
+
+/**
+ * Foreground color for ANSI red
+ */
+export const RED = escape(31);
+
+/**
+ * Foreground color for ANSI green
+ */
+export const GREEN = escape(32);
+
+/**
+ * Foreground color for ANSI yellow
+ */
+export const YELLOW = escape(33);
+
+/**
+ * Foreground color for ANSI blue
+ */
+export const BLUE = escape(34);
+
+/**
+ * Foreground color for ANSI magenta
+ */
+export const MAGENTA = escape(35);
+
+/**
+ * Foreground color for ANSI cyan
+ */
+export const CYAN = escape(36);
+
+/**
+ * Foreground color for ANSI white
+ */
+export const WHITE = escape(37);
+
+/**
+ * Background color for ANSI black
+ */
+export const BLACK_B = escape(40);
+
+/**
+ * Background color for ANSI red
+ */
+export const RED_B = escape(41);
+
+/**
+ * Background color for ANSI green
+ */
+export const GREEN_B = escape(42);
+
+/**
+ * Background color for ANSI yellow
+ */
+export const YELLOW_B = escape(43);
+
+/**
+ * Background color for ANSI blue
+ */
+export const BLUE_B = escape(44);
+
+/**
+ * Background color for ANSI magenta
+ */
+export const MAGENTA_B = escape(45);
+
+/**
+ * Background color for ANSI cyan
+ */
+export const CYAN_B = escape(46);
+
+/**
+ * Background color for ANSI white
+ */
+export const WHITE_B = escape(47);
+
+/**
+ * Reset ANSI styles
+ */
+export const RESET = escape(0);
+
+/**
+ * ANSI bold
+ */
+export const BOLD = escape(1);
+
+/**
+ * ANSI underline
+ */
+export const UNDERLINE = escape(4);
+
+/**
+ * ANSI blink
+ */
+export const BLINK = escape(5);
+
+/**
+ * ANSI reversed
+ */
+export const REVERSED = escape(7);
+
+/**
+ * ANSI invisible
+ */
+export const INVISIBLE = escape(8);
+
+/**
+ * Reset ANSI foreground
+ */
+export const RESET_FG = escape(39);
+
+/**
+ * Reset ANSI background
+ */
+export const RESET_BG = escape(49);
+
+/**
+ * ANSI 24bit foreground
+ */
+export const RGB = <r extends number, g extends number, b extends number>(r: r, g: g, b: b) =>
+  `\u001b[38;2;${r};${g};${b}m` as const;
+
+/**
+ * ANSI 24bit background
+ */
+export const RGB_B = <r extends number, g extends number, b extends number>(r: r, g: g, b: b) =>
+  `\u001b[48;2;${r};${g};${b}m` as const;
+
+/*
+ * -------------------------------------------------------------------------------------------------
+ * Internal
+ * -------------------------------------------------------------------------------------------------
+ */
+
+function style(open: number, close: number) {
+  return (s: string) => escape(open) + s + escape(close);
+}
+
+function generateStyles() {
+  const modifiers = {
+    reset: [0, 0],
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    blink: [5, 25],
+    reversed: [7, 27],
+    invisible: [8, 28],
+    strikethrough: [9, 29],
+  } as const;
+
+  const colors = {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+  } as const;
+
+  const colorsBright: {
+    [K in keyof typeof colors as `bright${Capitalize<K>}`]: [number, number];
+  } = Dictionary.get(colors).foldLeftWithIndex({} as any, (k, b, [c, r]) => ({
+    ...b,
+    [`bright${k.capitalize}`]: [c + ANSI_BRIGHT_OFFSET, r],
+  }));
+
+  const colorsBg: {
+    [K in keyof typeof colors as `bg${Capitalize<K>}`]: [number, number];
+  } = Dictionary.get(colors).foldLeftWithIndex({} as any, (k, b, [c, r]) => ({
+    ...b,
+    [`bg${k.capitalize}`]: [c + ANSI_BACKGROUND_OFFSET, r + ANSI_BACKGROUND_OFFSET],
+  }));
+
+  const colorsBrightBg: {
+    [K in keyof typeof colors as `bgBright${Capitalize<K>}`]: [number, number];
+  } = Dictionary.get(colors).foldLeftWithIndex({} as any, (k, b, [c, r]) => ({
+    ...b,
+    [`bgBright${k.capitalize}`]: [c + ANSI_BRIGHT_OFFSET + ANSI_BACKGROUND_OFFSET, r + ANSI_BACKGROUND_OFFSET],
+  }));
+
+  return {
+    ...Struct.get(modifiers).map(([open, close]) => style(open, close)).reverseGet,
+    ...Struct.get(colors).map(([open, close]) => style(open, close)).reverseGet,
+    ...Struct.get(colorsBright).map(([open, close]) => style(open, close)).reverseGet,
+    ...Struct.get(colorsBg).map(([open, close]) => style(open, close)).reverseGet,
+    ...Struct.get(colorsBrightBg).map(([open, close]) => style(open, close)).reverseGet,
+  };
+}
+
+function escape<style extends number>(style: style): `\u001b[${style}m` {
+  return `\u001b[${style}m` as any;
+}