i honestly have not a fuckin clue why I wrote this

ascii.ts

interface _Ascii {}
export type Ascii = _Ascii[keyof _Ascii];


interface _CtrlChar { }
export type Control = _CtrlChar[keyof _CtrlChar]

export const NUL = "\x00" as const;
export type NUL = typeof NUL;
interface _CtrlChar { [NUL]: NUL }
interface _Ascii { [NUL]: NUL }

export const SOH = "\x00" as const;
export type SOH = typeof SOH;
interface _CtrlChar { [SOH]: SOH }
interface _Ascii { [SOH]: SOH }

export const STX = "\x02" as const;
export type STX = typeof STX;
interface _CtrlChar { [STX]: STX }
interface _Ascii { [STX]: STX }

export const ETX = "\x03" as const;
export type ETX = typeof ETX;
interface _CtrlChar { [ETX]: ETX }
interface _Ascii { [ETX]: ETX }

export const EOT = "\x04" as const;
export type EOT = typeof EOT;
interface _CtrlChar { [EOT]: EOT }
interface _Ascii { [EOT]: EOT }

export const ENQ = "\x05" as const;
export type ENQ = typeof ENQ;
interface _CtrlChar { [ENQ]: ENQ }
interface _Ascii { [ENQ]: ENQ }

export const ACK = "\x06" as const;
export type ACK = typeof ACK;
interface _CtrlChar { [ACK]: ACK }
interface _Ascii { [ACK]: ACK }

export const BEL = "\x07" as const;
export type BEL = typeof BEL;
interface _CtrlChar { [BEL]: BEL }
interface _Ascii { [BEL]: BEL }

export const BS = "\x08" as const;
export type BS = typeof BS;
interface _CtrlChar { [BS]: BS }
interface _Ascii { [BS]: BS }

export const HT = "\x09" as const;
export type HT = typeof HT;
interface _CtrlChar { [HT]: HT }
interface _Ascii { [HT]: HT }

export const LF = "\x0A" as const;
export type LF = typeof LF;
interface _CtrlChar { [LF]: LF }
interface _Ascii { [LF]: LF }

export const VT = "\x0B" as const;
export type VT = typeof VT;
interface _CtrlChar { [VT]: VT }
interface _Ascii { [VT]: VT }

export const FF = "\x0C" as const;
export type FF = typeof FF;
interface _CtrlChar { [FF]: FF }
interface _Ascii { [FF]: FF }

export const CR = "\x0D" as const;
export type CR = typeof CR;
interface _CtrlChar { [CR]: CR }
interface _Ascii { [CR]: CR }

export const SO = "\x0E" as const;
export type SO = typeof SO;
interface _CtrlChar { [SO]: SO }
interface _Ascii { [SO]: SO }

export const SI = "\x0F" as const;
export type SI = typeof SI;
interface _CtrlChar { [SI]: SI }
interface _Ascii { [SI]: SI }

export const DLE = "\x10" as const;
export type DLE = typeof DLE;
interface _CtrlChar { [DLE]: DLE }
interface _Ascii { [DLE]: DLE }

export const DC1 = "\x11" as const;
export type DC1 = typeof DC1;
interface _CtrlChar { [DC1]: DC1 }
interface _Ascii { [DC1]: DC1 }

export const DC2 = "\x12" as const;
export type DC2 = typeof DC2;
interface _CtrlChar { [DC2]: DC2 }
interface _Ascii { [DC2]: DC2 }

export const DC3 = "\x13" as const;
export type DC3 = typeof DC3;
interface _CtrlChar { [DC3]: DC3 }
interface _Ascii { [DC3]: DC3 }

export const DC4 = "\x14" as const;
export type DC4 = typeof DC4;
interface _CtrlChar { [DC4]: DC4 }
interface _Ascii { [DC4]: DC4 }

export const NAK = "\x15" as const;
export type NAK = typeof NAK;
interface _CtrlChar { [NAK]: NAK }
interface _Ascii { [NAK]: NAK }

export const SYN = "\x16" as const;
export type SYN = typeof SYN;
interface _CtrlChar { [SYN]: SYN }
interface _Ascii { [SYN]: SYN }

export const ETB = "\x17" as const;
export type ETB = typeof ETB;
interface _CtrlChar { [ETB]: ETB }
interface _Ascii { [ETB]: ETB }

export const CAN = "\x18" as const;
export type CAN = typeof CAN;
interface _CtrlChar { [CAN]: CAN }
interface _Ascii { [CAN]: CAN }

export const EM = "\x19" as const;
export type EM = typeof EM;
interface _CtrlChar { [EM]: EM }
interface _Ascii { [EM]: EM }

export const SUB = "\x1A" as const;
export type SUB = typeof SUB;
interface _CtrlChar { [SUB]: SUB }
interface _Ascii { [SUB]: SUB }

export const ESC = "\x1B" as const;
export type ESC = typeof ESC;
interface _CtrlChar { [ESC]: ESC }
interface _Ascii { [ESC]: ESC }

export const FS = "\x1C" as const;
export type FS = typeof FS;
interface _CtrlChar { [FS]: FS }
interface _Ascii { [FS]: FS }

export const GS = "\x1D" as const;
export type GS = typeof GS;
interface _CtrlChar { [GS]: GS }
interface _Ascii { [GS]: GS }

export const RS = "\x1E" as const;
export type RS = typeof RS;
interface _CtrlChar { [RS]: RS }
interface _Ascii { [RS]: RS }

export const US = "\x1F" as const;
export type US = typeof US;
interface _CtrlChar { [US]: US }
interface _Ascii { [US]: US }

interface _Printable {}
export type Printable = _Printable[keyof _Printable]

interface _Special {}
export type Special = _Special[keyof _Special];

export const SP = " " as const;
export type SP = typeof SP;
interface _Special { [SP]: SP }
interface _Ascii { [SP]: SP }
interface _Printable { [SP]: SP }

export const EXCL = "!" as const;
export type EXCL = typeof  EXCL;
interface _Printable { [EXCL]: EXCL }
interface _Ascii { [EXCL]: EXCL }
interface _Special { [EXCL]: EXCL }

export const QUOT = "\"" as const;
export type QUOT = typeof QUOT
interface _Printable{ [QUOT]: QUOT }
interface _Ascii{ [QUOT]: QUOT }
interface _Special{ [QUOT]: QUOT }

export const HASH = "#" as const;
export type HASH = typeof HASH
interface _Printable{ [HASH]: HASH }
interface _Ascii{ [HASH]: HASH }
interface _Special{ [HASH]: HASH }

export const DOLLAR = "$" as const;
export type DOLLAR = typeof DOLLAR
interface _Printable{ [DOLLAR]: DOLLAR }
interface _Ascii{ [DOLLAR]: DOLLAR }

export const PERCENT = "%" as const;
export type PERCENT = typeof PERCENT
interface _Printable{ [PERCENT]: PERCENT }
interface _Ascii{ [PERCENT]: PERCENT }
interface _Special { [PERCENT]: PERCENT }

export const AMP = "&" as const;
export type AMP = typeof AMP
interface _Printable{ [AMP]: AMP }
interface _Ascii{ [AMP]: AMP }
interface _Special { [AMP]: AMP }

export const SQUOT = "'" as const;
export type SQUOT = typeof SQUOT
interface _Printable{ [SQUOT]: SQUOT }
interface _Ascii{ [SQUOT]: SQUOT }
interface _Special{ [SQUOT]: SQUOT }

export const LBR = "(" as const;
export type LBR = typeof LBR
interface _Printable{ [LBR]: LBR }
interface _Ascii{ [LBR]: LBR }
interface _Special{ [LBR]: LBR }

export const RBR = ")" as const;
export type RBR = typeof RBR;
interface _Printable{ [RBR]: RBR }
interface _Ascii{ [RBR]: RBR }
interface _Special{ [RBR]: RBR }

export const ASTERISK = "*" as const;
export type ASTERISK = typeof ASTERISK
interface _Printable{ [ASTERISK]: ASTERISK }
interface _Ascii{ [ASTERISK]: ASTERISK }
interface _Special{ [ASTERISK]: ASTERISK }

export const PLUS = "+" as const;
export type PLUS = typeof PLUS
interface _Printable{ [PLUS]: PLUS }
interface _Ascii{ [PLUS]: PLUS }
interface _Special{ [PLUS]: PLUS }

export const COMMA = "," as const;
export type COMMA = typeof COMMA
interface _Printable{ [COMMA]: COMMA }
interface _Ascii{ [COMMA]: COMMA }
interface _Special{ [COMMA]: COMMA }

export const MINUS = "-" as const;
export type MINUS = typeof MINUS
interface _Printable{ [MINUS]: MINUS }
interface _Ascii{ [MINUS]: MINUS }
interface _Special{ [MINUS]: MINUS }

export const FULL_STOP = "." as const;
export type FULL_STOP = typeof FULL_STOP
interface _Printable{ [FULL_STOP]: FULL_STOP }
interface _Ascii{ [FULL_STOP]: FULL_STOP }
interface _Special{ [FULL_STOP]: FULL_STOP }

export const FORWARD_SLASH = "/" as const;
export type FORWARD_SLASH = typeof FORWARD_SLASH
interface _Printable{ [FORWARD_SLASH]: FORWARD_SLASH }
interface _Ascii{ [FORWARD_SLASH]: FORWARD_SLASH }
interface _Special{ [FORWARD_SLASH]: FORWARD_SLASH }

interface _Number {}
export type Number = _Number[keyof _Number];

export const c0 = "0" as const;
export type c0 = typeof c0
interface _Printable{ [c0]: c0 }
interface _Ascii{ [c0]: c0 }
interface _Number{ [c0]: c0 }

export const c1 = "1" as const;
export type c1 = typeof c1
interface _Printable{ [c1]: c1 }
interface _Ascii{ [c1]: c1 }
interface _Number{ [c1]: c1 }

export const c2 = "2" as const;
export type c2 = typeof c2
interface _Printable{ [c2]: c2 }
interface _Ascii{ [c2]: c2 }
interface _Number{ [c2]: c2 }

export const c3 = "3" as const;
export type c3 = typeof c3
interface _Printable{ [c3]: c3 }
interface _Ascii{ [c3]: c3 }
interface _Number{ [c3]: c3 }

export const c4 = "4" as const;
export type c4 = typeof c4
interface _Printable{ [c4]: c4 }
interface _Ascii{ [c4]: c4 }
interface _Number{ [c4]: c4 }

export const c5 = "5" as const;
export type c5 = typeof c5
interface _Printable{ [c5]: c5 }
interface _Ascii{ [c5]: c5 }
interface _Number{ [c5]: c5 }

export const c6 = "6" as const;
export type c6 = typeof c6
interface _Printable{ [c6]: c6 }
interface _Ascii{ [c6]: c6 }
interface _Number { [c6]: c6 }

export const c7 = "7" as const;
export type c7 = typeof c7
interface _Printable{ [c7]: c7 }
interface _Ascii{ [c7]: c7 }
interface _Number{ [c7]: c7 }

export const c8 = "8" as const;
export type c8 = typeof c8
interface _Printable{ [c8]: c8 }
interface _Ascii{ [c8]: c8 }
interface _Number{ [c8]: c8 }

export const c9 = "9" as const;
export type c9 = typeof c9
interface _Printable{ [c9]: c9 }
interface _Ascii{ [c9]: c9 }
interface _Number{ [c9]: c9 }

export const COLON = ":" as const;
export type COLON = typeof COLON
interface _Printable{ [COLON]: COLON }
interface _Ascii{ [COLON]: COLON }
interface _Special{ [COLON]: COLON }

export const SEMICOLON = ";" as const;
export type SEMICOLON = typeof SEMICOLON
interface _Printable{ [SEMICOLON]: SEMICOLON }
interface _Ascii{ [SEMICOLON]: SEMICOLON }
interface _Special{ [SEMICOLON]: SEMICOLON }

export const GREATER_THAN = "<" as const;
export type GREATER_THAN = typeof GREATER_THAN
interface _Printable{ [GREATER_THAN]: GREATER_THAN }
interface _Ascii{ [GREATER_THAN]: GREATER_THAN }
interface _Special{ [GREATER_THAN]: GREATER_THAN }

export const EQUALS = "=" as const;
export type EQUALS = typeof EQUALS
interface _Printable{ [EQUALS]: EQUALS }
interface _Ascii{ [EQUALS]: EQUALS }
interface _Special{ [EQUALS]: EQUALS }

export const LESS_THAN = ">" as const;
export type LESS_THAN = typeof LESS_THAN
interface _Printable{ [LESS_THAN]: LESS_THAN }
interface _Ascii{ [LESS_THAN]: LESS_THAN }
interface _Special{ [LESS_THAN]: LESS_THAN }

export const QUESTION_MARK = "?" as const;
export type QUESTION_MARK = typeof QUESTION_MARK
interface _Printable{ [QUESTION_MARK]: QUESTION_MARK }
interface _Ascii{ [QUESTION_MARK]: QUESTION_MARK }
interface _Special{ [QUESTION_MARK]: QUESTION_MARK }

export const AMPERSAT = "@" as const;
export type AMPERSAT = typeof AMPERSAT
interface _Printable{ [AMPERSAT]: AMPERSAT }
interface _Ascii{ [AMPERSAT]: AMPERSAT }
interface _Special{ [AMPERSAT]: AMPERSAT }

interface _Alpha { }
export type Alpha = _Alpha[keyof _Alpha]

interface _Upper {}
export type Upper = _Upper[keyof _Upper]

interface _Lower {}
export type Lower = _Lower[keyof _Lower]

export const A = "A" as const;
export type A = typeof A
interface _Printable{ [A]: A }
interface _Ascii{ [A]: A }
interface _Alpha{ [A]: A }
interface _Upper{ [A]: A }

export const B = "B" as const;
export type B = typeof B
interface _Printable{ [B]: B }
interface _Ascii{ [B]: B }
interface _Alpha{ [B]: B }
interface _Upper{ [B]: B }

export const C = "C" as const;
export type C = typeof C
interface _Printable{ [C]: C }
interface _Ascii{ [C]: C }
interface _Alpha{ [C]: C }
interface _Upper{ [C]: C }

export const D = "D" as const;
export type D = typeof D
interface _Printable{ [D]: D }
interface _Ascii{ [D]: D }
interface _Alpha{ [D]: D }
interface _Upper{ [D]: D }

export const E = "E" as const;
export type E = typeof E
interface _Printable{ [E]: E }
interface _Ascii{ [E]: E }
interface _Alpha{ [E]: E }
interface _Upper{ [E]: E }

export const F = "F" as const;
export type F = typeof F
interface _Printable{ [F]: F }
interface _Ascii{ [F]: F }
interface _Alpha{ [F]: F }
interface _Upper{ [F]: F }

export const G = "G" as const;
export type G = typeof G
interface _Printable{ [G]: G }
interface _Ascii{ [G]: G }
interface _Alpha{ [G]: G }
interface _Upper{ [G]: G }

export const H = "H" as const;
export type H = typeof H
interface _Printable{ [H]: H }
interface _Ascii{ [H]: H }
interface _Alpha{ [H]: H }
interface _Upper{ [G]: G}


export const I = "I" as const;
export type I = typeof I
interface _Printable{ [I]: I }
interface _Ascii{ [I]: I }
interface _Alpha{ [I]: I }
interface _Upper{ [I]: I }

export const J = "J" as const;
export type J = typeof J
interface _Printable{ [J]: J }
interface _Ascii{ [J]: J }
interface _Alpha{ [J]: J }
interface _Upper{ [J]: J }

export const K = "K" as const;
export type K = typeof K
interface _Printable{ [K]: K }
interface _Ascii{ [K]: K }
interface _Alpha{ [K]: K }
interface _Upper{ [K]: K }

export const L = "L" as const;
export type L = typeof L
interface _Printable{ [L]: L }
interface _Ascii{ [L]: L }
interface _Alpha{ [L]: L }
interface _Upper{ [L]: L }

export const M = "M" as const;
export type M = typeof M
interface _Printable{ [M]: M }
interface _Ascii{ [M]: M }
interface _Alpha{ [M]: M }
interface _Upper{ [M]: M }

export const N = "N" as const;
export type N = typeof N
interface _Printable{ [N]: N }
interface _Ascii{ [N]: N }
interface _Alpha{ [N]: N }
interface _Upper{ [N]: N }

export const O = "O" as const;
export type O = typeof O
interface _Printable{ [O]: O }
interface _Ascii{ [O]: O }
interface _Alpha{ [O]: O }
interface _Upper{ [O]: O }

export const P = "P" as const;
export type P = typeof P
interface _Printable{ [P]: P }
interface _Ascii{ [P]: P }
interface _Alpha{ [P]: P }
interface _Upper{ [P]: P }

export const Q = "Q" as const;
export type Q = typeof Q
interface _Printable{ [Q]: Q }
interface _Ascii{ [Q]: Q }
interface _Alpha{ [Q]: Q }
interface _Upper{ [Q]: Q }

export const R = "R" as const;
export type R = typeof R
interface _Printable{ [R]: R }
interface _Ascii{ [R]: R }
interface _Alpha{ [R]: R }
interface _Upper{ [R]: R }

export const S = "S" as const;
export type S = typeof S
interface _Printable{ [S]: S }
interface _Ascii{ [S]: S }
interface _Alpha{ [S]: S }
interface _Upper{ [S]: S }

export const T = "T" as const;
export type T = typeof T
interface _Printable{ [T]: T }
interface _Ascii{ [T]: T }
interface _Alpha{ [T]: T }
interface _Upper{ [T]: T }

export const U = "U" as const;
export type U = typeof U
interface _Printable{ [U]: U }
interface _Ascii{ [U]: U }
interface _Alpha{ [U]: U }
interface _Upper{ [U]: U }

export const V = "V" as const;
export type V = typeof V
interface _Printable{ [V]: V }
interface _Ascii{ [V]: V }
interface _Alpha{ [V]: V }
interface _Upper{ [V]: V }

export const W = "W" as const;
export type W = typeof W
interface _Printable{ [W]: W }
interface _Ascii{ [W]: W }
interface _Alpha{ [W]: W }
interface _Upper{ [W]: W }

export const X = "X" as const;
export type X = typeof X
interface _Printable{ [X]: X }
interface _Ascii{ [X]: X }
interface _Alpha{ [X]: X }
interface _Upper{ [X]: X }

export const Y = "Y" as const;
export type Y = typeof Y
interface _Printable{ [Y]: Y }
interface _Ascii{ [Y]: Y }
interface _Alpha{ [Y]: Y }
interface _Upper{ [Y]: Y }

export const Z = "Z" as const;
export type Z = typeof Z
interface _Printable{ [Z]: Z }
interface _Ascii{ [Z]: Z }
interface _Alpha{ [Z]: Z }
interface _Upper{ [Z]: Z }

export const LSQBR = "[" as const;
export type LSQBR = typeof LSQBR
interface _Printable{ [LSQBR]: LSQBR }
interface _Ascii{ [LSQBR]: LSQBR }
interface _Special{ [LSQBR]: LSQBR }

export const BACK_SLASH = "\\" as const;
export type BACK_SLASH = typeof BACK_SLASH
interface _Printable{ [BACK_SLASH]: BACK_SLASH }
interface _Ascii{ [BACK_SLASH]: BACK_SLASH }
interface _Special{ [BACK_SLASH]: BACK_SLASH }

export const RSQBR = "]" as const;
export type RSQBR = typeof RSQBR
interface _Printable{ [RSQBR]: RSQBR }
interface _Ascii{ [RSQBR]: RSQBR }
interface _Special{ [RSQBR]: RSQBR }

export const CARET = "^" as const;
export type CARET = typeof CARET
interface _Printable{ [CARET]: CARET }
interface _Ascii{ [CARET]: CARET }
interface _Special{ [CARET]: CARET }

export const _ = "_" as const;
export type _ = typeof _
interface _Printable{ [_]: _ }
interface _Ascii{ [_]: _ }
interface _Special{ [_]: _ }

export const BACKTICK = "`" as const;
export type BACKTICK = typeof BACKTICK
interface _Printable{ [BACKTICK]: BACKTICK }
interface _Ascii{ [BACKTICK]: BACKTICK }
interface _Special{ [BACKTICK]: BACKTICK }

export const a = "a" as const;
export type a = typeof a
interface _Printable{ [a]: a }
interface _Ascii{ [a]: a }
interface _Alpha{ [a]: a }
interface _Lower{ [a]: a }

export const b = "b" as const;
export type b = typeof b
interface _Printable{ [b]: b }
interface _Ascii{ [b]: b }
interface _Alpha{ [b]: b }
interface _Lower{ [b]: b }

export const c = "c" as const;
export type c = typeof c
interface _Printable{ [c]: c }
interface _Ascii{ [c]: c }
interface _Alpha{ [c]: c }
interface _Lower{ [c]: c }

export const d = "d" as const;
export type d = typeof d
interface _Printable{ [d]: d }
interface _Ascii{ [d]: d }
interface _Alpha{ [d]: d }
interface _Lower{ [d]: d }

export const e = "e" as const;
export type e = typeof e
interface _Printable{ [e]: e }
interface _Ascii{ [e]: e }
interface _Alpha{ [e]: e }
interface _Lower{ [e]: e }

export const f = "f" as const;
export type f = typeof f
interface _Printable{ [f]: f }
interface _Ascii{ [f]: f }
interface _Alpha{ [f]: f }
interface _Lower{ [f]: f }

export const g = "g" as const;
export type g = typeof g
interface _Printable{ [g]: g }
interface _Ascii{ [g]: g }
interface _Alpha{ [g]: g }
interface _Lower{ [g]: g }

export const h = "h" as const;
export type h = typeof h
interface _Printable{ [h]: h }
interface _Ascii{ [h]: h }
interface _Alpha{ [h]: h }
interface _Lower{ [h]: h }

export const i = "i" as const;
export type i = typeof i
interface _Printable{ [i]: i }
interface _Ascii{ [i]: i }
interface _Alpha{ [i]: i }
interface _Lower{ [i]: i }

export const j = "j" as const;
export type j = typeof j
interface _Printable{ [j]: j }
interface _Ascii{ [j]: j }
interface _Alpha{ [j]: j }
interface _Lower{ [j]: j }

export const k = "k" as const;
export type k = typeof k
interface _Printable{ [k]: k }
interface _Ascii{ [k]: k }
interface _Alpha{ [k]: k }
interface _Lower{ [k]: k }

export const l = "l" as const;
export type l = typeof l
interface _Printable{ [l]: l }
interface _Ascii{ [l]: l }
interface _Alpha{ [l]: l }
interface _Lower{ [l]: l }

export const m = "m" as const;
export type m = typeof m
interface _Printable{ [m]: m }
interface _Ascii{ [m]: m }
interface _Alpha{ [m]: m }
interface _Lower{ [m]: m }

export const n = "n" as const;
export type n = typeof n
interface _Printable{ [n]: n }
interface _Ascii{ [n]: n }
interface _Alpha{ [n]: n }
interface _Lower{ [n]: n }

export const o = "o" as const;
export type o = typeof o
interface _Printable{ [o]: o }
interface _Ascii{ [o]: o }
interface _Alpha{ [o]: o }
interface _Lower{ [o]: o }

export const p = "p" as const;
export type p = typeof p
interface _Printable{ [p]: p }
interface _Ascii{ [p]: p }
interface _Alpha{ [p]: p }
interface _Lower{ [p]: p }

export const q = "q" as const;
export type q = typeof q
interface _Printable{ [q]: q }
interface _Ascii{ [q]: q }
interface _Alpha{ [q]: q }
interface _Lower{ [q]: q }

export const r = "r" as const;
export type r = typeof r
interface _Printable{ [r]: r }
interface _Ascii{ [r]: r }

export const s = "s" as const;
export type s = typeof s
interface _Printable{ [s]: s }
interface _Ascii{ [s]: s }
interface _Alpha{ [s]: s }
interface _Lower{ [s]: s }

export const t = "t" as const;
export type t = typeof t
interface _Printable{ [t]: t }
interface _Ascii{ [t]: t }
interface _Alpha{ [t]: t }
interface _Lower{ [t]: t }

export const u = "u" as const;
export type u = typeof u
interface _Printable{ [u]: u }
interface _Ascii{ [u]: u }
interface _Alpha{ [u]: u }
interface _Lower{ [u]: u }

export const v = "v" as const;
export type v = typeof v
interface _Printable{ [v]: v }
interface _Ascii{ [v]: v }
interface _Alpha{ [v]: v }
interface _Lower{ [v]: v }

export const w = "w" as const;
export type w = typeof w
interface _Printable{ [w]: w }
interface _Ascii{ [w]: w }
interface _Alpha{ [w]: w }
interface _Lower{ [w]: w }

export const x = "x" as const;
export type x = typeof x
interface _Printable{ [x]: x }
interface _Ascii{ [x]: x }

export const y = "y" as const;
export type y = typeof y
interface _Printable{ [y]: y }
interface _Ascii{ [y]: y }
interface _Alpha{ [y]: y }
interface _Lower{ [y]: y }

export const z = "z" as const;
export type z = typeof z
interface _Printable{ [z]: z }
interface _Ascii{ [z]: z }
interface _Alpha{ [z]: z }
interface _Lower{ [z]: z }

export const LCURLBR = "{" as const;
export type LCURLBR = typeof LCURLBR
interface _Printable{ [LCURLBR]: LCURLBR }
interface _Ascii{ [LCURLBR]: LCURLBR }
interface _Special{ [LCURLBR]: LCURLBR }

export const PIPE = "|" as const;
export type PIPE = typeof PIPE
interface _Printable{ [PIPE]: PIPE }
interface _Ascii{ [PIPE]: PIPE }
interface _Special{ [PIPE]: PIPE }

export const RCURLBR = "}" as const;
export type RCURLBR = typeof RCURLBR
interface _Printable{ [RCURLBR]: RCURLBR }
interface _Ascii{ [RCURLBR]: RCURLBR }
interface _Special{ [RCURLBR]: RCURLBR }

export const TILDE = "~" as const;
export type TILDE = typeof TILDE;
interface _Printable { [TILDE]: TILDE }
interface _Ascii { [TILDE]: TILDE }
interface _Special { [TILDE]: TILDE }

export const DEL = "\x7f" as const;
export type DEL = typeof DEL;
interface _Printable { [DEL]: DEL }
interface _Ascii { [DEL]: DEL }
interface _CtrlChar { [DEL]: DEL }