subagent-cli 0.3.0 → 0.3.1

package/src/ink/supports-hyperlinks.ts

@@ -1,57 +0,0 @@
-import supportsHyperlinksLib from 'supports-hyperlinks'
-
-// Additional terminals that support OSC 8 hyperlinks but aren't detected by supports-hyperlinks.
-// Checked against both TERM_PROGRAM and LC_TERMINAL (the latter is preserved inside tmux).
-export const ADDITIONAL_HYPERLINK_TERMINALS = [
-  'ghostty',
-  'Hyper',
-  'kitty',
-  'alacritty',
-  'iTerm.app',
-  'iTerm2',
-]
-
-type EnvLike = Record<string, string | undefined>
-
-type SupportsHyperlinksOptions = {
-  env?: EnvLike
-  stdoutSupported?: boolean
-}
-
-/**
- * Returns whether stdout supports OSC 8 hyperlinks.
- * Extends the supports-hyperlinks library with additional terminal detection.
- * @param options Optional overrides for testing (env, stdoutSupported)
- */
-export function supportsHyperlinks(
-  options?: SupportsHyperlinksOptions,
-): boolean {
-  const stdoutSupported =
-    options?.stdoutSupported ?? supportsHyperlinksLib.stdout
-  if (stdoutSupported) {
-    return true
-  }
-
-  const env = options?.env ?? process.env
-
-  // Check for additional terminals not detected by supports-hyperlinks
-  const termProgram = env['TERM_PROGRAM']
-  if (termProgram && ADDITIONAL_HYPERLINK_TERMINALS.includes(termProgram)) {
-    return true
-  }
-
-  // LC_TERMINAL is set by some terminals (e.g. iTerm2) and preserved inside tmux,
-  // where TERM_PROGRAM is overwritten to 'tmux'.
-  const lcTerminal = env['LC_TERMINAL']
-  if (lcTerminal && ADDITIONAL_HYPERLINK_TERMINALS.includes(lcTerminal)) {
-    return true
-  }
-
-  // Kitty sets TERM=xterm-kitty
-  const term = env['TERM']
-  if (term?.includes('kitty')) {
-    return true
-  }
-
-  return false
-}

package/src/ink/tabstops.ts

@@ -1,46 +0,0 @@
-// Tab expansion, inspired by Ghostty's Tabstops.zig
-// Uses 8-column intervals (POSIX default, hardcoded in terminals like Ghostty)
-
-import { stringWidth } from './stringWidth.js'
-import { createTokenizer } from './termio/tokenize.js'
-
-const DEFAULT_TAB_INTERVAL = 8
-
-export function expandTabs(
-  text: string,
-  interval = DEFAULT_TAB_INTERVAL,
-): string {
-  if (!text.includes('\t')) {
-    return text
-  }
-
-  const tokenizer = createTokenizer()
-  const tokens = tokenizer.feed(text)
-  tokens.push(...tokenizer.flush())
-
-  let result = ''
-  let column = 0
-
-  for (const token of tokens) {
-    if (token.type === 'sequence') {
-      result += token.value
-    } else {
-      const parts = token.value.split(/(\t|\n)/)
-      for (const part of parts) {
-        if (part === '\t') {
-          const spaces = interval - (column % interval)
-          result += ' '.repeat(spaces)
-          column += spaces
-        } else if (part === '\n') {
-          result += part
-          column = 0
-        } else {
-          result += part
-          column += stringWidth(part)
-        }
-      }
-    }
-  }
-
-  return result
-}

package/src/ink/terminal-focus-state.ts

@@ -1,47 +0,0 @@
-// Terminal focus state signal — non-React access to DECSET 1004 focus events.
-// 'unknown' is the default for terminals that don't support focus reporting;
-// consumers treat 'unknown' identically to 'focused' (no throttling).
-// Subscribers are notified synchronously when focus changes, used by
-// TerminalFocusProvider to avoid polling.
-export type TerminalFocusState = 'focused' | 'blurred' | 'unknown'
-
-let focusState: TerminalFocusState = 'unknown'
-const resolvers: Set<() => void> = new Set()
-const subscribers: Set<() => void> = new Set()
-
-export function setTerminalFocused(v: boolean): void {
-  focusState = v ? 'focused' : 'blurred'
-  // Notify useSyncExternalStore subscribers
-  for (const cb of subscribers) {
-    cb()
-  }
-  if (!v) {
-    for (const resolve of resolvers) {
-      resolve()
-    }
-    resolvers.clear()
-  }
-}
-
-export function getTerminalFocused(): boolean {
-  return focusState !== 'blurred'
-}
-
-export function getTerminalFocusState(): TerminalFocusState {
-  return focusState
-}
-
-// For useSyncExternalStore
-export function subscribeTerminalFocus(cb: () => void): () => void {
-  subscribers.add(cb)
-  return () => {
-    subscribers.delete(cb)
-  }
-}
-
-export function resetTerminalFocusState(): void {
-  focusState = 'unknown'
-  for (const cb of subscribers) {
-    cb()
-  }
-}

package/src/ink/terminal-querier.ts

@@ -1,212 +0,0 @@
-/**
- * Query the terminal and await responses without timeouts.
- *
- * Terminal queries (DECRQM, DA1, OSC 11, etc.) share the stdin stream
- * with keyboard input. Response sequences are syntactically
- * distinguishable from key events, so the input parser recognizes them
- * and dispatches them here.
- *
- * To avoid timeouts, each query batch is terminated by a DA1 sentinel
- * (CSI c) — every terminal since VT100 responds to DA1, and terminals
- * answer queries in order. So: if your query's response arrives before
- * DA1's, the terminal supports it; if DA1 arrives first, it doesn't.
- *
- * Usage:
- *   const [sync, grapheme] = await Promise.all([
- *     querier.send(decrqm(2026)),
- *     querier.send(decrqm(2027)),
- *     querier.flush(),
- *   ])
- *   // sync and grapheme are DECRPM responses or undefined if unsupported
- */
-
-import type { TerminalResponse } from './parse-keypress.js'
-import { csi } from './termio/csi.js'
-import { osc } from './termio/osc.js'
-
-/** A terminal query: an outbound request sequence paired with a matcher
- *  that recognizes the expected inbound response. Built by `decrqm()`,
- *  `oscColor()`, `kittyKeyboard()`, etc. */
-export type TerminalQuery<T extends TerminalResponse = TerminalResponse> = {
-  /** Escape sequence to write to stdout */
-  request: string
-  /** Recognizes the expected response in the inbound stream */
-  match: (r: TerminalResponse) => r is T
-}
-
-type DecrpmResponse = Extract<TerminalResponse, { type: 'decrpm' }>
-type Da1Response = Extract<TerminalResponse, { type: 'da1' }>
-type Da2Response = Extract<TerminalResponse, { type: 'da2' }>
-type KittyResponse = Extract<TerminalResponse, { type: 'kittyKeyboard' }>
-type CursorPosResponse = Extract<TerminalResponse, { type: 'cursorPosition' }>
-type OscResponse = Extract<TerminalResponse, { type: 'osc' }>
-type XtversionResponse = Extract<TerminalResponse, { type: 'xtversion' }>
-
-// -- Query builders --
-
-/** DECRQM: request DEC private mode status (CSI ? mode $ p).
- *  Terminal replies with DECRPM (CSI ? mode ; status $ y) or ignores. */
-export function decrqm(mode: number): TerminalQuery<DecrpmResponse> {
-  return {
-    request: csi(`?${mode}$p`),
-    match: (r): r is DecrpmResponse => r.type === 'decrpm' && r.mode === mode,
-  }
-}
-
-/** Primary Device Attributes query (CSI c). Every terminal answers this —
- *  used internally by flush() as a universal sentinel. Call directly if
- *  you want the DA1 params. */
-export function da1(): TerminalQuery<Da1Response> {
-  return {
-    request: csi('c'),
-    match: (r): r is Da1Response => r.type === 'da1',
-  }
-}
-
-/** Secondary Device Attributes query (CSI > c). Returns terminal version. */
-export function da2(): TerminalQuery<Da2Response> {
-  return {
-    request: csi('>c'),
-    match: (r): r is Da2Response => r.type === 'da2',
-  }
-}
-
-/** Query current Kitty keyboard protocol flags (CSI ? u).
- *  Terminal replies with CSI ? flags u or ignores. */
-export function kittyKeyboard(): TerminalQuery<KittyResponse> {
-  return {
-    request: csi('?u'),
-    match: (r): r is KittyResponse => r.type === 'kittyKeyboard',
-  }
-}
-
-/** DECXCPR: request cursor position with DEC-private marker (CSI ? 6 n).
- *  Terminal replies with CSI ? row ; col R. The `?` marker is critical —
- *  the plain DSR form (CSI 6 n → CSI row;col R) is ambiguous with
- *  modified F3 keys (Shift+F3 = CSI 1;2 R, etc.). */
-export function cursorPosition(): TerminalQuery<CursorPosResponse> {
-  return {
-    request: csi('?6n'),
-    match: (r): r is CursorPosResponse => r.type === 'cursorPosition',
-  }
-}
-
-/** OSC dynamic color query (e.g. OSC 11 for bg color, OSC 10 for fg).
- *  The `?` data slot asks the terminal to reply with the current value. */
-export function oscColor(code: number): TerminalQuery<OscResponse> {
-  return {
-    request: osc(code, '?'),
-    match: (r): r is OscResponse => r.type === 'osc' && r.code === code,
-  }
-}
-
-/** XTVERSION: request terminal name/version (CSI > 0 q).
- *  Terminal replies with DCS > | name ST (e.g. "xterm.js(5.5.0)") or ignores.
- *  This survives SSH — the query goes through the pty, not the environment,
- *  so it identifies the *client* terminal even when TERM_PROGRAM isn't
- *  forwarded. Used to detect xterm.js for wheel-scroll compensation. */
-export function xtversion(): TerminalQuery<XtversionResponse> {
-  return {
-    request: csi('>0q'),
-    match: (r): r is XtversionResponse => r.type === 'xtversion',
-  }
-}
-
-// -- Querier --
-
-/** Sentinel request sequence (DA1). Kept internal; flush() writes it. */
-const SENTINEL = csi('c')
-
-type Pending =
-  | {
-      kind: 'query'
-      match: (r: TerminalResponse) => boolean
-      resolve: (r: TerminalResponse | undefined) => void
-    }
-  | { kind: 'sentinel'; resolve: () => void }
-
-export class TerminalQuerier {
-  /**
-   * Interleaved queue of queries and sentinels in send order. Terminals
-   * respond in order, so each flush() barrier only drains queries queued
-   * before it — concurrent batches from independent callers stay isolated.
-   */
-  private queue: Pending[] = []
-
-  constructor(private stdout: NodeJS.WriteStream) {}
-
-  /**
-   * Send a query and wait for its response.
-   *
-   * Resolves with the response when `query.match` matches an incoming
-   * TerminalResponse, or with `undefined` when a flush() sentinel arrives
-   * before any matching response (meaning the terminal ignored the query).
-   *
-   * Never rejects; never times out on its own. If you never call flush()
-   * and the terminal doesn't respond, the promise remains pending.
-   */
-  send<T extends TerminalResponse>(
-    query: TerminalQuery<T>,
-  ): Promise<T | undefined> {
-    return new Promise(resolve => {
-      this.queue.push({
-        kind: 'query',
-        match: query.match,
-        resolve: r => resolve(r as T | undefined),
-      })
-      this.stdout.write(query.request)
-    })
-  }
-
-  /**
-   * Send the DA1 sentinel. Resolves when DA1's response arrives.
-   *
-   * As a side effect, all queries still pending when DA1 arrives are
-   * resolved with `undefined` (terminal didn't respond → doesn't support
-   * the query). This is the barrier that makes send() timeout-free.
-   *
-   * Safe to call with no pending queries — still waits for a round-trip.
-   */
-  flush(): Promise<void> {
-    return new Promise(resolve => {
-      this.queue.push({ kind: 'sentinel', resolve })
-      this.stdout.write(SENTINEL)
-    })
-  }
-
-  /**
-   * Dispatch a response parsed from stdin. Called by App.tsx's
-   * processKeysInBatch for every `kind: 'response'` item.
-   *
-   * Matching strategy:
-   * - First, try to match a pending query (FIFO, first match wins).
-   *   This lets callers send(da1()) explicitly if they want the DA1
-   *   params — a separate DA1 write means the terminal sends TWO DA1
-   *   responses. The first matches the explicit query; the second
-   *   (unmatched) fires the sentinel.
-   * - Otherwise, if this is a DA1, fire the FIRST pending sentinel:
-   *   resolve any queries queued before that sentinel with undefined
-   *   (the terminal answered DA1 without answering them → unsupported)
-   *   and signal its flush() completion. Only draining up to the first
-   *   sentinel keeps later batches intact when multiple callers have
-   *   concurrent queries in flight.
-   * - Unsolicited responses (no match, no sentinel) are silently dropped.
-   */
-  onResponse(r: TerminalResponse): void {
-    const idx = this.queue.findIndex(p => p.kind === 'query' && p.match(r))
-    if (idx !== -1) {
-      const [q] = this.queue.splice(idx, 1)
-      if (q?.kind === 'query') q.resolve(r)
-      return
-    }
-
-    if (r.type === 'da1') {
-      const s = this.queue.findIndex(p => p.kind === 'sentinel')
-      if (s === -1) return
-      for (const p of this.queue.splice(0, s + 1)) {
-        if (p.kind === 'query') p.resolve(undefined)
-        else p.resolve()
-      }
-    }
-  }
-}

package/src/ink/terminal.ts

@@ -1,248 +0,0 @@
-import { coerce } from 'semver'
-import type { Writable } from 'stream'
-import { env } from '../utils/env.js'
-import { gte } from '../utils/semver.js'
-import { getClearTerminalSequence } from './clearTerminal.js'
-import type { Diff } from './frame.js'
-import { cursorMove, cursorTo, eraseLines } from './termio/csi.js'
-import { BSU, ESU, HIDE_CURSOR, SHOW_CURSOR } from './termio/dec.js'
-import { link } from './termio/osc.js'
-
-export type Progress = {
-  state: 'running' | 'completed' | 'error' | 'indeterminate'
-  percentage?: number
-}
-
-/**
- * Checks if the terminal supports OSC 9;4 progress reporting.
- * Supported terminals:
- * - ConEmu (Windows) - all versions
- * - Ghostty 1.2.0+
- * - iTerm2 3.6.6+
- *
- * Note: Windows Terminal interprets OSC 9;4 as notifications, not progress.
- */
-export function isProgressReportingAvailable(): boolean {
-  // Only available if we have a TTY (not piped)
-  if (!process.stdout.isTTY) {
-    return false
-  }
-
-  // Explicitly exclude Windows Terminal, which interprets OSC 9;4 as
-  // notifications rather than progress indicators
-  if (process.env.WT_SESSION) {
-    return false
-  }
-
-  // ConEmu supports OSC 9;4 for progress (all versions)
-  if (
-    process.env.ConEmuANSI ||
-    process.env.ConEmuPID ||
-    process.env.ConEmuTask
-  ) {
-    return true
-  }
-
-  const version = coerce(process.env.TERM_PROGRAM_VERSION)
-  if (!version) {
-    return false
-  }
-
-  // Ghostty 1.2.0+ supports OSC 9;4 for progress
-  // https://ghostty.org/docs/install/release-notes/1-2-0
-  if (process.env.TERM_PROGRAM === 'ghostty') {
-    return gte(version.version, '1.2.0')
-  }
-
-  // iTerm2 3.6.6+ supports OSC 9;4 for progress
-  // https://iterm2.com/downloads.html
-  if (process.env.TERM_PROGRAM === 'iTerm.app') {
-    return gte(version.version, '3.6.6')
-  }
-
-  return false
-}
-
-/**
- * Checks if the terminal supports DEC mode 2026 (synchronized output).
- * When supported, BSU/ESU sequences prevent visible flicker during redraws.
- */
-export function isSynchronizedOutputSupported(): boolean {
-  // tmux parses and proxies every byte but doesn't implement DEC 2026.
-  // BSU/ESU pass through to the outer terminal but tmux has already
-  // broken atomicity by chunking. Skip to save 16 bytes/frame + parser work.
-  if (process.env.TMUX) return false
-
-  const termProgram = process.env.TERM_PROGRAM
-  const term = process.env.TERM
-
-  // Modern terminals with known DEC 2026 support
-  if (
-    termProgram === 'iTerm.app' ||
-    termProgram === 'WezTerm' ||
-    termProgram === 'WarpTerminal' ||
-    termProgram === 'ghostty' ||
-    termProgram === 'contour' ||
-    termProgram === 'vscode' ||
-    termProgram === 'alacritty'
-  ) {
-    return true
-  }
-
-  // kitty sets TERM=xterm-kitty or KITTY_WINDOW_ID
-  if (term?.includes('kitty') || process.env.KITTY_WINDOW_ID) return true
-
-  // Ghostty may set TERM=xterm-ghostty without TERM_PROGRAM
-  if (term === 'xterm-ghostty') return true
-
-  // foot sets TERM=foot or TERM=foot-extra
-  if (term?.startsWith('foot')) return true
-
-  // Alacritty may set TERM containing 'alacritty'
-  if (term?.includes('alacritty')) return true
-
-  // Zed uses the alacritty_terminal crate which supports DEC 2026
-  if (process.env.ZED_TERM) return true
-
-  // Windows Terminal
-  if (process.env.WT_SESSION) return true
-
-  // VTE-based terminals (GNOME Terminal, Tilix, etc.) since VTE 0.68
-  const vteVersion = process.env.VTE_VERSION
-  if (vteVersion) {
-    const version = parseInt(vteVersion, 10)
-    if (version >= 6800) return true
-  }
-
-  return false
-}
-
-// -- XTVERSION-detected terminal name (populated async at startup) --
-//
-// TERM_PROGRAM is not forwarded over SSH by default, so env-based detection
-// fails when claude runs remotely inside a VS Code integrated terminal.
-// XTVERSION (CSI > 0 q → DCS > | name ST) goes through the pty — the query
-// reaches the *client* terminal and the reply comes back through stdin.
-// App.tsx fires the query when raw mode enables; setXtversionName() is called
-// from the response handler. Readers should treat undefined as "not yet known"
-// and fall back to env-var detection.
-
-let xtversionName: string | undefined
-
-/** Record the XTVERSION response. Called once from App.tsx when the reply
- *  arrives on stdin. No-op if already set (defend against re-probe). */
-export function setXtversionName(name: string): void {
-  if (xtversionName === undefined) xtversionName = name
-}
-
-/** True if running in an xterm.js-based terminal (VS Code, Cursor, Windsurf
- *  integrated terminals). Combines TERM_PROGRAM env check (fast, sync, but
- *  not forwarded over SSH) with the XTVERSION probe result (async, survives
- *  SSH — query/reply goes through the pty). Early calls may miss the probe
- *  reply — call lazily (e.g. in an event handler) if SSH detection matters. */
-export function isXtermJs(): boolean {
-  if (process.env.TERM_PROGRAM === 'vscode') return true
-  return xtversionName?.startsWith('xterm.js') ?? false
-}
-
-// Terminals known to correctly implement the Kitty keyboard protocol
-// (CSI >1u) and/or xterm modifyOtherKeys (CSI >4;2m) for ctrl+shift+<letter>
-// disambiguation. We previously enabled unconditionally (#23350), assuming
-// terminals silently ignore unknown CSI — but some terminals honor the enable
-// and emit codepoints our input parser doesn't handle (notably over SSH and
-// in xterm.js-based terminals like VS Code). tmux is allowlisted because it
-// accepts modifyOtherKeys and doesn't forward the kitty sequence to the outer
-// terminal.
-const EXTENDED_KEYS_TERMINALS = [
-  'iTerm.app',
-  'kitty',
-  'WezTerm',
-  'ghostty',
-  'tmux',
-  'windows-terminal',
-]
-
-/** True if this terminal correctly handles extended key reporting
- *  (Kitty keyboard protocol + xterm modifyOtherKeys). */
-export function supportsExtendedKeys(): boolean {
-  return EXTENDED_KEYS_TERMINALS.includes(env.terminal ?? '')
-}
-
-/** True if the terminal scrolls the viewport when it receives cursor-up
- *  sequences that reach above the visible area. On Windows, conhost's
- *  SetConsoleCursorPosition follows the cursor into scrollback
- *  (microsoft/terminal#14774), yanking users to the top of their buffer
- *  mid-stream. WT_SESSION catches WSL-in-Windows-Terminal where platform
- *  is linux but output still routes through conhost. */
-export function hasCursorUpViewportYankBug(): boolean {
-  return process.platform === 'win32' || !!process.env.WT_SESSION
-}
-
-// Computed once at module load — terminal capabilities don't change mid-session.
-// Exported so callers can pass a sync-skip hint gated to specific modes.
-export const SYNC_OUTPUT_SUPPORTED = isSynchronizedOutputSupported()
-
-export type Terminal = {
-  stdout: Writable
-  stderr: Writable
-}
-
-export function writeDiffToTerminal(
-  terminal: Terminal,
-  diff: Diff,
-  skipSyncMarkers = false,
-): void {
-  // No output if there are no patches
-  if (diff.length === 0) {
-    return
-  }
-
-  // BSU/ESU wrapping is opt-out to keep main-screen behavior unchanged.
-  // Callers pass skipSyncMarkers=true when the terminal doesn't support
-  // DEC 2026 (e.g. tmux) AND the cost matters (high-frequency alt-screen).
-  const useSync = !skipSyncMarkers
-
-  // Buffer all writes into a single string to avoid multiple write calls
-  let buffer = useSync ? BSU : ''
-
-  for (const patch of diff) {
-    switch (patch.type) {
-      case 'stdout':
-        buffer += patch.content
-        break
-      case 'clear':
-        if (patch.count > 0) {
-          buffer += eraseLines(patch.count)
-        }
-        break
-      case 'clearTerminal':
-        buffer += getClearTerminalSequence()
-        break
-      case 'cursorHide':
-        buffer += HIDE_CURSOR
-        break
-      case 'cursorShow':
-        buffer += SHOW_CURSOR
-        break
-      case 'cursorMove':
-        buffer += cursorMove(patch.x, patch.y)
-        break
-      case 'cursorTo':
-        buffer += cursorTo(patch.col)
-        break
-      case 'carriageReturn':
-        buffer += '\r'
-        break
-      case 'hyperlink':
-        buffer += link(patch.uri)
-        break
-      case 'styleStr':
-        buffer += patch.str
-        break
-    }
-  }
-
-  // Add synchronized update end and flush buffer
-  if (useSync) buffer += ESU
-  terminal.stdout.write(buffer)
-}

package/src/ink/termio/ansi.ts

@@ -1,75 +0,0 @@
-/**
- * ANSI Control Characters and Escape Sequence Introducers
- *
- * Based on ECMA-48 / ANSI X3.64 standards.
- */
-
-/**
- * C0 (7-bit) control characters
- */
-export const C0 = {
-  NUL: 0x00,
-  SOH: 0x01,
-  STX: 0x02,
-  ETX: 0x03,
-  EOT: 0x04,
-  ENQ: 0x05,
-  ACK: 0x06,
-  BEL: 0x07,
-  BS: 0x08,
-  HT: 0x09,
-  LF: 0x0a,
-  VT: 0x0b,
-  FF: 0x0c,
-  CR: 0x0d,
-  SO: 0x0e,
-  SI: 0x0f,
-  DLE: 0x10,
-  DC1: 0x11,
-  DC2: 0x12,
-  DC3: 0x13,
-  DC4: 0x14,
-  NAK: 0x15,
-  SYN: 0x16,
-  ETB: 0x17,
-  CAN: 0x18,
-  EM: 0x19,
-  SUB: 0x1a,
-  ESC: 0x1b,
-  FS: 0x1c,
-  GS: 0x1d,
-  RS: 0x1e,
-  US: 0x1f,
-  DEL: 0x7f,
-} as const
-
-// String constants for output generation
-export const ESC = '\x1b'
-export const BEL = '\x07'
-export const SEP = ';'
-
-/**
- * Escape sequence type introducers (byte after ESC)
- */
-export const ESC_TYPE = {
-  CSI: 0x5b, // [ - Control Sequence Introducer
-  OSC: 0x5d, // ] - Operating System Command
-  DCS: 0x50, // P - Device Control String
-  APC: 0x5f, // _ - Application Program Command
-  PM: 0x5e, // ^ - Privacy Message
-  SOS: 0x58, // X - Start of String
-  ST: 0x5c, // \ - String Terminator
-} as const
-
-/** Check if a byte is a C0 control character */
-export function isC0(byte: number): boolean {
-  return byte < 0x20 || byte === 0x7f
-}
-
-/**
- * Check if a byte is an ESC sequence final byte (0-9, :, ;, <, =, >, ?, @ through ~)
- * ESC sequences have a wider final byte range than CSI
- */
-export function isEscFinal(byte: number): boolean {
-  return byte >= 0x30 && byte <= 0x7e
-}