opencode-vim 0.0.23 → 0.0.24

package/src/modules/vim/actions.ts

@@ -1,82 +0,0 @@
-import type { CursorStyleOptions, LineInfo, RGBA } from "@opentui/core"
-import type { VimCursorStyle } from "./config"
-
-type PromptInfo = {
-    input: string
-    mode: string
-    parts: unknown[]
-}
-
-type PromptRef = {
-    current: PromptInfo
-    set: (value: PromptInfo) => void
-    submit: () => void
-    blur: () => void
-}
-
-export type PromptContext = {
-    api: {
-        renderer: { currentFocusedRenderable?: unknown }
-        keymap: { dispatchCommand: (command: string) => { ok: boolean } }
-        theme: { current: { warning: RGBA; info: RGBA; background: RGBA } }
-    }
-    prompt: () => PromptRef | undefined
-    requestRender: () => void
-}
-
-export type EditBufferLike = {
-    isDestroyed?: boolean
-    cursorOffset?: number
-    plainText?: string
-    visualCursor?: VisualCursorLike
-    editorView?: { getLogicalLineInfo?: () => LineInfo; setSelection?: (start: number, end: number, bgColor?: RGBA, fgColor?: RGBA) => void; resetSelection?: () => void }
-    cursorStyle?: CursorStyleOptions
-    selectionBg?: RGBA
-    selectionFg?: RGBA
-    moveCursorLeft?: () => boolean
-    moveCursorRight?: () => boolean
-    moveCursorUp?: () => boolean
-    moveCursorDown?: () => boolean
-    setSelection?: (start: number, end: number) => void
-    insertText?: (text: string) => void
-    setSelectionInclusive?: (start: number, end: number) => void
-    clearSelection?: () => void
-    gotoLineEnd?: () => void
-}
-
-export type VisualCursorLike = {
-    visualRow?: number
-    visualCol?: number
-    logicalRow?: number
-    logicalCol?: number
-    offset?: number
-}
-
-export function applyVimCursorStyle(ctx: PromptContext, style: VimCursorStyle) {
-    const input = focusedInput(ctx)
-    if (!input) return false
-    input.cursorStyle = style
-    return true
-}
-
-export function focusedInput(ctx: PromptContext): EditBufferLike | undefined {
-    const focused = ctx.api.renderer.currentFocusedRenderable as EditBufferLike | null | undefined
-    if (!focused || !hasEditBufferMethods(focused)) return undefined
-    return focused
-}
-
-export function setInput(ref: PromptRef, input: string) {
-    ref.set(toPromptInfo(ref, input))
-}
-
-function hasEditBufferMethods(input: EditBufferLike) {
-    return typeof input.moveCursorLeft === "function" || typeof input.moveCursorRight === "function" || typeof input.moveCursorUp === "function" || typeof input.moveCursorDown === "function" || typeof input.gotoLineEnd === "function"
-}
-
-function toPromptInfo(ref: PromptRef, input: string): PromptInfo {
-    return {
-        input,
-        mode: ref.current.mode,
-        parts: [...ref.current.parts],
-    }
-}

package/src/modules/vim/config.ts

@@ -1,137 +0,0 @@
-import { parseKeySequence } from "@vimee/core"
-import type { VimMode } from "./state"
-
-export type VimCursorStyle = {
-    style: "block" | "line" | "underline" | "default"
-    blinking?: boolean
-}
-
-export type VimConfig = {
-    defaultMode: VimMode
-    sessionKey: string
-    keymapTimeout: number
-    pendingDisplayDelay: number
-    cursorStyles: Record<VimMode, VimCursorStyle>
-    debug: boolean
-    debugPath?: string
-    keymaps: VimKeymaps
-}
-
-export type VimOptions = {
-    defaultMode?: VimMode
-    sessionKey?: string
-    keymapTimeout?: number
-    pendingDisplayDelay?: number
-    cursorStyles?: Partial<Record<VimMode, VimCursorStyle>>
-    debug?: boolean
-    debugPath?: string
-    keymaps?: VimKeymaps
-}
-
-export type VimKeymaps = Partial<Record<VimMode, Record<string, VimMappedAction>>>
-export type VimMappedAction = string
-
-const DEFAULT_CURSOR_STYLES: Record<VimMode, VimCursorStyle> = {
-    insert: { style: "line", blinking: true },
-    normal: { style: "block", blinking: true },
-    visual: { style: "block", blinking: true },
-    "visual-line": { style: "block", blinking: true },
-}
-
-export function createVimConfig(options: unknown): VimConfig {
-    const input = readOptions(options)
-    return {
-        defaultMode: input.defaultMode ?? "insert",
-        sessionKey: input.sessionKey ?? "s",
-        keymapTimeout: Math.max(0, input.keymapTimeout ?? 500),
-        pendingDisplayDelay: Math.max(0, input.pendingDisplayDelay ?? 120),
-        cursorStyles: {
-            insert: { ...DEFAULT_CURSOR_STYLES.insert, ...input.cursorStyles?.insert },
-            normal: { ...DEFAULT_CURSOR_STYLES.normal, ...input.cursorStyles?.normal },
-            visual: { ...DEFAULT_CURSOR_STYLES.visual, ...input.cursorStyles?.visual },
-            "visual-line": { ...DEFAULT_CURSOR_STYLES["visual-line"], ...input.cursorStyles?.["visual-line"] },
-        },
-        debug: input.debug ?? process.env.VIM_PROMPT_DEBUG === "1",
-        debugPath: input.debugPath,
-        keymaps: input.keymaps ?? {},
-    }
-}
-
-function readOptions(options: unknown): VimOptions {
-    if (!options || typeof options !== "object") return {}
-    const raw = "vim" in options ? (options as { vim?: unknown }).vim : options
-    if (!raw || typeof raw !== "object") return {}
-
-    const source = raw as Record<string, unknown>
-    return {
-        defaultMode: isMode(source.defaultMode) ? source.defaultMode : undefined,
-        sessionKey: readSessionKey(source.sessionKey),
-        keymapTimeout: readNumber(source.keymapTimeout),
-        pendingDisplayDelay: typeof source.pendingDisplayDelay === "number" ? source.pendingDisplayDelay : undefined,
-        cursorStyles: readCursorStyles(source.cursorStyles),
-        debug: typeof source.debug === "boolean" ? source.debug : undefined,
-        debugPath: typeof source.debugPath === "string" ? source.debugPath : undefined,
-        keymaps: readKeymaps(source.keymaps),
-    }
-}
-
-function readSessionKey(input: unknown): string | undefined {
-    if (typeof input !== "string") return
-    try {
-        if (parseKeySequence(input).length === 1) return input
-    } catch {}
-}
-
-function readKeymaps(input: unknown): VimKeymaps | undefined {
-    if (!input || typeof input !== "object") return undefined
-    const source = input as Record<string, unknown>
-    const keymaps: VimKeymaps = {}
-
-    for (const mode of ["insert", "normal", "visual", "visual-line"] as const) {
-        const raw = source[mode]
-        if (!raw || typeof raw !== "object") continue
-        keymaps[mode] = {}
-        for (const [key, action] of Object.entries(raw as Record<string, unknown>)) {
-            if (isMappedAction(action)) keymaps[mode][key] = action
-        }
-    }
-
-    return keymaps
-}
-
-function readCursorStyles(input: unknown): VimOptions["cursorStyles"] {
-    if (!input || typeof input !== "object") return undefined
-    const source = input as Record<string, unknown>
-    return {
-        insert: readCursorStyle(source.insert),
-        normal: readCursorStyle(source.normal),
-        visual: readCursorStyle(source.visual),
-        "visual-line": readCursorStyle(source["visual-line"]),
-    }
-}
-
-function readCursorStyle(input: unknown): VimCursorStyle | undefined {
-    if (!input || typeof input !== "object") return undefined
-    const source = input as Record<string, unknown>
-    if (!isCursorStyle(source.style)) return undefined
-    return {
-        style: source.style,
-        blinking: typeof source.blinking === "boolean" ? source.blinking : undefined,
-    }
-}
-
-function isCursorStyle(value: unknown): value is VimCursorStyle["style"] {
-    return value === "block" || value === "line" || value === "underline" || value === "default"
-}
-
-function isMode(value: unknown): value is VimMode {
-    return value === "insert" || value === "normal" || value === "visual" || value === "visual-line"
-}
-
-function isMappedAction(value: unknown): value is VimMappedAction {
-    return typeof value === "string" && value.length > 0
-}
-
-function readNumber(value: unknown) {
-    return typeof value === "number" ? value : undefined
-}

package/src/modules/vim/edit.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { editInput } from "./edit"
-
-describe("editInput", () => {
-    test("inserts without replacing unchanged placeholders", () => {
-        const fixture = createFixture("[Image 1] after")
-
-        editInput(fixture.input, "[Image 1] kafter")
-
-        expect(fixture.calls).toEqual([["cursor", 10], ["insert", "k"]])
-    })
-
-    test("uses display offsets for a minimal deletion", () => {
-        const fixture = createFixture("中 [Image 1] abc")
-
-        editInput(fixture.input, "中 [Image 1] ac")
-
-        expect(fixture.calls).toEqual([["selection", 14, 15], ["insert", ""]])
-    })
-
-    test("does not split graphemes", () => {
-        const fixture = createFixture("a👩‍💻b")
-
-        editInput(fixture.input, "axb")
-
-        expect(fixture.calls).toEqual([["selection", 1, 3], ["insert", "x"]])
-    })
-})
-
-function createFixture(plainText: string) {
-    const calls: Array<["cursor", number] | ["selection", number, number] | ["insert", string]> = []
-    let cursorOffset = 0
-    const input = {
-        plainText,
-        clearSelection() {},
-        get cursorOffset() {
-            return cursorOffset
-        },
-        set cursorOffset(value: number) {
-            cursorOffset = value
-            calls.push(["cursor", value])
-        },
-        setSelection(start: number, end: number) {
-            calls.push(["selection", start, end])
-        },
-        insertText(text: string) {
-            calls.push(["insert", text])
-        },
-    }
-    return { input, calls }
-}

package/src/modules/vim/edit.ts

@@ -1,33 +0,0 @@
-import { charToDisplay } from "./map"
-
-const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" })
-
-type Input = {
-    plainText: string
-    cursorOffset: number
-    setSelection: (start: number, end: number) => void
-    insertText: (text: string) => void
-    clearSelection: () => unknown
-}
-
-export function editInput(input: Input, value: string) {
-    if (input.plainText === value) return
-    input.clearSelection()
-
-    const before = [...graphemes.segment(input.plainText)]
-    const after = [...graphemes.segment(value)]
-    let prefix = 0
-    while (prefix < before.length && prefix < after.length && before[prefix].segment === after[prefix].segment) prefix++
-
-    let suffix = 0
-    while (suffix + prefix < before.length && suffix + prefix < after.length && before[before.length - suffix - 1].segment === after[after.length - suffix - 1].segment) suffix++
-
-    const start = before[prefix]?.index ?? input.plainText.length
-    const end = suffix ? before[before.length - suffix].index : input.plainText.length
-    const valueEnd = suffix ? after[after.length - suffix].index : value.length
-    const startOffset = charToDisplay(input.plainText, start)
-
-    if (start === end) input.cursorOffset = startOffset
-    else input.setSelection(startOffset, charToDisplay(input.plainText, end))
-    input.insertText(value.slice(start, valueEnd))
-}

package/src/modules/vim/graphemes.ts

@@ -1,38 +0,0 @@
-const segments = new Intl.Segmenter(undefined, { granularity: "grapheme" })
-
-// Vimee indexes JavaScript strings by UTF-16 code unit. Give each multi-unit
-// grapheme one private-use character so motions, operators and registers cannot
-// split it. The dictionary lives with the adapter, including its undo history.
-export function createGraphemeCodec() {
-    const encoded = new Map<string, string>()
-    const decoded = new Map<string, string>()
-    let next = 0xe000
-    return {
-        encode(text: string) {
-            let result = ""
-            for (const { segment } of segments.segment(text)) {
-                const code = segment.charCodeAt(0)
-                if (segment.length === 1 && (code < 0xe000 || code > 0xf8ff)) {
-                    result += segment
-                    continue
-                }
-                let token = encoded.get(segment)
-                if (!token) {
-                    if (next > 0xf8ff) throw new Error("Vim grapheme dictionary is full")
-                    token = String.fromCharCode(next++)
-                    encoded.set(segment, token)
-                    decoded.set(token, segment)
-                }
-                result += token
-            }
-            return result
-        },
-        decode(text: string) {
-            let result = ""
-            for (const token of text) result += decoded.get(token) ?? token
-            return result
-        },
-    }
-}
-
-export type GraphemeCodec = ReturnType<typeof createGraphemeCodec>

package/src/modules/vim/index.tsx

@@ -1,200 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import type { KeyEvent, ParsedKey } from "@opentui/core"
-import { onCleanup } from "solid-js"
-import type { Accessor } from "solid-js"
-import type { PromptContext, PromptModule } from "../../prompt/types"
-import type { SnippetController } from "../snippets/types"
-import { applyVimCursorStyle, focusedInput } from "./actions"
-import type { VimConfig } from "./config"
-import { createVimConfig } from "./config"
-import { displayToChar } from "./map"
-import { keyNotation } from "./keys"
-import { createVimLog } from "./log"
-import type { VimLog } from "./log"
-import { createVimState } from "./state"
-import { createVimeeAdapter } from "./vimee"
-import { VimStatus } from "./view"
-
-export function createVimModule(options?: unknown, enabled: Accessor<boolean> = () => true, snippets?: SnippetController): PromptModule {
-    const config = createVimConfig(options)
-    const log = createVimLog(config)
-    const state = createVimState(config.defaultMode, log)
-    log("module.create", { defaultMode: config.defaultMode, keymapTimeout: config.keymapTimeout })
-
-    return {
-        id: "vim",
-        order: 0,
-        setup(ctx) {
-            log("module.setup", { kind: ctx.kind, sessionID: ctx.sessionID, workspaceID: ctx.workspaceID })
-        },
-        renderAbove(ctx) {
-            return <VimKeyboard ctx={ctx} config={config} state={state} snippets={snippets} enabled={enabled} log={log} />
-        },
-        renderRight(ctx) {
-            return <VimStatus mode={state.mode} pending={() => readablePending(state.pending())} subscribe={state.subscribe} enabled={enabled} theme={ctx.api.theme.current} pendingDisplayDelay={config.pendingDisplayDelay} disabled={ctx.disabled} log={log} requestRender={ctx.requestRender} />
-        },
-    }
-}
-
-function VimKeyboard(props: { ctx: PromptContext; config: VimConfig; state: ReturnType<typeof createVimState>; snippets?: SnippetController; enabled: Accessor<boolean>; log: VimLog }) {
-    let cursorStyleMode = ""
-    const vimee = createVimeeAdapter(props.state, props.config, props.log)
-    props.log("keyboard.mount", { kind: props.ctx.kind })
-
-    const cursorStyleTimer = setInterval(syncCursorStyle, 50)
-    const offKeyboard = props.ctx.api.keymap.intercept("key", ({ event }) => {
-        props.log("keyboard.event", {
-            name: event.name,
-            ctrl: event.ctrl,
-            meta: event.meta,
-            shift: event.shift,
-            defaultPrevented: event.defaultPrevented,
-            propagationStopped: event.propagationStopped,
-            mode: props.state.mode(),
-            pending: props.state.pending(),
-        })
-
-        if (!canHandleKeys(props)) {
-            props.log("keyboard.skip", { enabled: props.enabled(), disabled: props.ctx.disabled, visible: props.ctx.visible, dialogOpen: props.ctx.api.ui.dialog.open })
-            return
-        }
-
-        const key = keyNotation(event)
-        if (!key) {
-            props.log("keyboard.no_key")
-            return
-        }
-
-        if (passThroughKey(event, key, props.state.mode())) return
-
-        if (key === "<Esc>" && props.state.mode() === "normal" && !props.state.pending()) {
-            props.log("keyboard.fallthrough", { key, mode: props.state.mode() })
-            return
-        }
-
-        if (sendNavigationKey(event, props.ctx, key, props.state.mode(), props.snippets)) {
-            syncCursorStyle(true)
-            props.ctx.requestRender()
-            return
-        }
-
-        const modeBefore = props.state.mode()
-        let consumed = false
-        try {
-            consumed = vimee.handle(event, key, props.ctx)
-        } finally {
-            if (consumed || props.state.mode() !== modeBefore) {
-                event.preventDefault()
-                event.stopPropagation()
-            }
-        }
-        if (consumed) {
-            syncCursorStyle(true)
-            props.ctx.requestRender()
-        }
-    })
-
-    onCleanup(() => {
-        props.log("keyboard.cleanup", { kind: props.ctx.kind })
-        offKeyboard()
-        vimee.cleanup()
-        clearInterval(cursorStyleTimer)
-    })
-
-    return <box height={0} />
-
-    function syncCursorStyle(force = false) {
-        const mode = props.state.mode()
-        if (!force && cursorStyleMode === mode) return
-        if (applyVimCursorStyle(props.ctx, props.config.cursorStyles[mode])) {
-            cursorStyleMode = mode
-            props.log("cursor.style", { mode, style: props.config.cursorStyles[mode].style, blinking: props.config.cursorStyles[mode].blinking })
-        }
-    }
-}
-
-function canHandleKeys(props: { ctx: PromptContext; enabled: Accessor<boolean> }) {
-    return props.enabled() && !props.ctx.disabled && props.ctx.visible !== false && !props.ctx.api.ui.dialog.open
-}
-
-function readablePending(sequence: string) {
-    if (!sequence) return undefined
-    return sequence.replaceAll("><", " ")
-}
-
-function passThroughKey(event: KeyEvent, key: string, mode: string) {
-    if (mode !== "normal") return false
-    return event.super === true || isArrowKey(key) || key === "<C-c>"
-}
-
-function sendNavigationKey(event: KeyEvent, ctx: PromptContext, key: string, mode: string, snippets?: SnippetController) {
-    if (mode !== "normal") return false
-    const delta = snippetNavigationDelta(key)
-    if (delta !== 0 && snippets?.navigate?.(delta)) {
-        event.preventDefault()
-        event.stopPropagation()
-        return true
-    }
-
-    const forwarded = commandNavigationKey(ctx, key)
-    if (!forwarded) return false
-
-    event.preventDefault()
-    event.stopPropagation()
-    ctx.api.renderer.keyInput.processParsedKey(forwarded)
-    return true
-}
-
-function snippetNavigationDelta(key: string) {
-    if (key === "j") return 1
-    if (key === "k") return -1
-    return 0
-}
-
-function commandNavigationKey(ctx: PromptContext, key: string): ParsedKey | undefined {
-    if (!isPromptFocused(ctx)) return navigationKey(key)
-    if (!isNativeCompletionToken(ctx)) return undefined
-    if (key === "j") return arrowKey("down", "\u001B[B")
-    if (key === "k") return arrowKey("up", "\u001B[A")
-    return undefined
-}
-
-function isPromptFocused(ctx: PromptContext) {
-    return ctx.prompt()?.focused === true && !!focusedInput(ctx)
-}
-
-function isNativeCompletionToken(ctx: PromptContext) {
-    const text = ctx.prompt()?.current.input ?? focusedInput(ctx)?.plainText ?? ""
-    const input = focusedInput(ctx)
-    const charIdx = displayToChar(text, Math.max(0, input?.cursorOffset ?? 0))
-    const beforeCursor = text.slice(0, Math.min(charIdx + 1, text.length))
-    return /^\/\S*$/.test(beforeCursor) || /(?:^|\s)@\S*$/.test(beforeCursor)
-}
-
-function navigationKey(key: string): ParsedKey | undefined {
-    if (key === "h") return arrowKey("left", "\u001B[D")
-    if (key === "j") return arrowKey("down", "\u001B[B")
-    if (key === "k") return arrowKey("up", "\u001B[A")
-    if (key === "l") return arrowKey("right", "\u001B[C")
-    return undefined
-}
-
-function isArrowKey(key: string) {
-    return key === "<Left>" || key === "<Down>" || key === "<Up>" || key === "<Right>"
-}
-
-function arrowKey(name: string, sequence: string): ParsedKey {
-    return {
-        name,
-        ctrl: false,
-        meta: false,
-        shift: false,
-        option: false,
-        sequence,
-        number: false,
-        raw: sequence,
-        eventType: "press",
-        source: "raw",
-        super: false,
-    }
-}

package/src/modules/vim/keys.ts

@@ -1,38 +0,0 @@
-import type { KeyEvent } from "@opentui/core"
-
-const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" })
-
-const NAMED_KEYS: Record<string, string> = {
-    escape: "<Esc>",
-    esc: "<Esc>",
-    return: "<CR>",
-    enter: "<CR>",
-    tab: "<Tab>",
-    backspace: "<BS>",
-    delete: "<Del>",
-    space: "<Space>",
-    up: "<Up>",
-    down: "<Down>",
-    left: "<Left>",
-    right: "<Right>",
-    home: "<Home>",
-    end: "<End>",
-    pageup: "<PageUp>",
-    pagedown: "<PageDown>",
-}
-
-export function keyNotation(event: KeyEvent) {
-    const name = event.name?.toLowerCase()
-    if (!name) return undefined
-
-    if (event.ctrl) return `<C-${ctrlKey(name)}>`
-    if (event.meta) return `<M-${name}>`
-    if ([...graphemes.segment(name)].length === 1) return event.shift ? name.toUpperCase() : name
-    return NAMED_KEYS[name] ?? `<${name}>`
-}
-
-function ctrlKey(name: string) {
-    if (name === "escape" || name === "esc") return "["
-    if (name.length === 1) return name
-    return name
-}

package/src/modules/vim/log.ts

@@ -1,37 +0,0 @@
-import { appendFile, mkdir } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import type { VimConfig } from "./config"
-
-export type VimLog = (event: string, data?: Record<string, unknown>) => void
-
-export function createVimLog(config: VimConfig): VimLog {
-    if (!config.debug) return () => {}
-
-    const path = config.debugPath ?? defaultPath()
-    void append(path, `\n--- opencode-vim debug ${new Date().toISOString()} ---\n`)
-
-    return (event, data) => {
-        const suffix = data ? ` ${safeJson(data)}` : ""
-        void append(path, `${new Date().toISOString()} ${event}${suffix}\n`)
-    }
-}
-
-function defaultPath() {
-    const home = process.env.HOME
-    return home ? join(home, ".cache/opencode/opencode-vim.log") : "/tmp/opencode-vim.log"
-}
-
-async function append(path: string, text: string) {
-    try {
-        await mkdir(dirname(path), { recursive: true })
-        await appendFile(path, text)
-    } catch {}
-}
-
-function safeJson(data: Record<string, unknown>) {
-    try {
-        return JSON.stringify(data)
-    } catch {
-        return "{}"
-    }
-}

package/src/modules/vim/map.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { charToDisplay, displayToChar, displayWidth } from "./map"
-
-describe("vim display offsets", () => {
-    test("maps ASCII and CJK offsets", () => {
-        const text = "a中b"
-
-        expect(displayWidth(text)).toBe(4)
-        expect(charToDisplay(text, 2)).toBe(3)
-        expect(displayToChar(text, 2)).toBe(1)
-        expect(displayToChar(text, 3)).toBe(2)
-    })
-
-    test("does not split supplementary characters", () => {
-        const text = "𠀀x"
-
-        expect(displayWidth(text)).toBe(3)
-        expect(charToDisplay(text, 1)).toBe(0)
-        expect(charToDisplay(text, 2)).toBe(2)
-        expect(displayToChar(text, 1)).toBe(0)
-        expect(displayToChar(text, 2)).toBe(2)
-    })
-
-    test("does not split grapheme clusters", () => {
-        const emoji = "👨‍👩‍👧‍👦"
-        const accent = "e\u0301"
-
-        expect(displayWidth(emoji)).toBe(2)
-        expect(charToDisplay(emoji, 1)).toBe(0)
-        expect(displayToChar(emoji, 1)).toBe(0)
-        expect(displayToChar(emoji, 2)).toBe(emoji.length)
-        expect(displayWidth(accent)).toBe(1)
-        expect(charToDisplay(accent, 1)).toBe(0)
-        expect(displayToChar(accent, 1)).toBe(accent.length)
-    })
-
-    test("counts newlines as textarea offsets", () => {
-        const text = "中\nx"
-
-        expect(displayWidth(text)).toBe(4)
-        expect(displayToChar(text, 2)).toBe(1)
-        expect(displayToChar(text, 3)).toBe(2)
-        expect(charToDisplay(text, 2)).toBe(3)
-    })
-})