@ssebastien/tcmd 0.0.0-stage → 0.1.0

package/src/js/tcmd/core/directory.js

@@ -0,0 +1,194 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-09-27
+
+// Module: tcmd/core/directory
+// A Directory is the per-pane state: the current path, the entries read from
+// the filesystem, the derived (filtered + sorted) view, the cursor, the disk
+// figures, the selection buffer and the navigation history (back/forward).
+// A pane owns exactly one directory — the
+// former multi-tab model is gone — and the pane's cells proxy it directly.
+
+import { cell, derived, effect } from "select/state/cells"
+import { viewEntries } from "./entries.js"
+import { clampCursor, currentEntry, toggleMark } from "./selection.js"
+import { SEP, parent as parentPath, split, prefix } from "./path.js"
+
+// Function: enrichEntry
+// Merges `stat` details (ctime, mode, uid, gid) the listing may not carry.
+async function enrichEntry(fs, entry) {
+	if (!entry) return null
+	const stats = await fs.stat(entry.path).catch(() => null)
+	if (!stats) return entry
+	return {
+		...entry,
+		size: entry.isDir ? 0 : (stats.size ?? entry.size),
+		mtimeMs: stats.mtimeMs ?? entry.mtimeMs,
+		ctimeMs: stats.ctimeMs ?? entry.ctimeMs,
+		mode: stats.mode ?? entry.mode,
+		uid: stats.uid ?? entry.uid,
+		gid: stats.gid ?? entry.gid,
+	}
+}
+
+// Function: createDirectory
+// Creates the directory state for one pane, bound to a filesystem adapter.
+//
+// Example:
+// ```javascript
+// const dir = createDirectory({ fs: createNodeFs(), path: "/home" })
+// await dir.refresh()
+// dir.entries.value // sorted, filtered FileEntry[]
+// ```
+function createDirectory({ fs, path: initialPath }) {
+	const dir = { fs }
+	dir.path = cell(initialPath)
+	dir.rawEntries = cell([])
+	dir.loading = cell(false)
+	dir.error = cell(null)
+	dir.filter = cell("")
+	dir.sort = cell({ key: "name", dir: 1 })
+	dir.entries = derived([dir.rawEntries, dir.filter, dir.sort], ([raw, filter, sort]) =>
+		viewEntries(raw, filter, sort),
+	)
+	dir.cursor = cell(0)
+	dir.disk = cell(null)
+	// Stat details (ctime, mode, uid, gid) for the entry under the cursor,
+	// fetched lazily: listings only carry size/mtime, so the pane detail line
+	// re-stats the selected path when the cursor moves (cached by path).
+	dir.cursorStat = cell(null)
+	let cursorStatPath = null
+	// Selection buffer for this directory (the pane's marked paths).
+	dir.marked = cell(new Set())
+	// Navigation history: visited paths with the current one at
+	// `history.index`, so back/forward walk the stack like a browser.
+	dir.history = { stack: [initialPath], index: 0 }
+
+	// A changing filter re-ranks the listing: snap the cursor back to the top
+	// match. Disposed with the directory (see `dispose`).
+	const stopFilterWatch = effect([dir.filter], () => dir.cursor.set(0))
+
+	// Re-stat the cursor entry on movement; cache by path so a re-render that
+	// does not move the cursor does not hit the filesystem again.
+	const stopCursorWatch = effect([dir.entries, dir.cursor], () => {
+		const entry = currentEntry(dir.entries.value, dir.cursor.value)
+		if (!entry || entry.path === cursorStatPath) return
+		cursorStatPath = entry.path
+		dir.cursorStat.set(entry)
+		void enrichEntry(fs, entry).then((enriched) => {
+			if (cursorStatPath === entry.path) dir.cursorStat.set(enriched)
+		})
+	})
+
+	// Function: refresh
+	// Re-reads the directory at `dir.path`, updating `rawEntries` and clamping
+	// the cursor. Sets `loading` while in flight; failures land in `error`.
+	dir.refresh = async () => {
+		dir.loading.set(true)
+		dir.error.set(null)
+		try {
+			dir.rawEntries.set(await fs.readDir(dir.path.value))
+			dir.cursor.set(clampCursor(dir.cursor.value, dir.entries.value.length))
+			dir.disk.set(await fs.disk(dir.path.value))
+		} catch (error) {
+			dir.error.set(`${error?.message ?? error}`)
+		} finally {
+			dir.loading.set(false)
+		}
+	}
+
+	// Function: apply
+	// The actual move to `path`: sets the path, resets filter, marks and
+	// cursor, then refreshes. History-neutral — navigate/back/forward record
+	// their own steps around it.
+	const apply = async (path) => {
+		dir.path.set(path)
+		dir.filter.set("")
+		dir.marked.set(new Set())
+		dir.cursor.set(0)
+		await dir.refresh()
+	}
+
+	// Function: navigate
+	// Moves the directory to `path` (resetting filter, marks and cursor),
+	// records the step in the history and refreshes. Re-navigating to the
+	// current path does not duplicate the entry.
+	dir.navigate = async (path) => {
+		const history = dir.history
+		if (history.stack[history.index] !== path) {
+			// A new navigation truncates the forward branch, like a browser.
+			history.stack.length = history.index + 1
+			history.stack.push(path)
+			history.index = history.stack.length - 1
+		}
+		await apply(path)
+	}
+
+	// Function: back
+	// Steps one entry back in the navigation history; no-op at its start.
+	dir.back = async () => {
+		const history = dir.history
+		if (history.index <= 0) return
+		history.index -= 1
+		await apply(history.stack[history.index])
+	}
+
+	// Function: forward
+	// Steps one entry forward in the navigation history; no-op at its end.
+	dir.forward = async () => {
+		const history = dir.history
+		if (history.index >= history.stack.length - 1) return
+		history.index += 1
+		await apply(history.stack[history.index])
+	}
+
+	// Function: up
+	// Navigates to the parent directory; no-op at the filesystem root.
+	dir.up = async () => {
+		const target = parentPath(dir.path.value)
+		if (target) await dir.navigate(target)
+	}
+
+	// Function: clearFilter
+	// Removes the directory's filter, restoring the full listing.
+	dir.clearFilter = () => dir.filter.set("")
+
+	// Function: open
+	// Opens the entry under the cursor: descends into directories.
+	dir.open = async () => {
+		const entry = currentEntry(dir.entries.value, dir.cursor.value)
+		if (entry?.isDir) await dir.navigate(entry.path)
+	}
+
+	// Function: currentEntry
+	// The entry under the cursor, or `undefined` for empty listings.
+	dir.currentEntry = () => currentEntry(dir.entries.value, dir.cursor.value)
+
+	// Function: toggleMark
+	// Marks or unmarks the entry under the cursor.
+	dir.toggleMark = () => {
+		const entry = dir.currentEntry()
+		if (entry) dir.marked.set(toggleMark(dir.marked.value, entry.path))
+	}
+
+	// Function: segments
+	// Derived breadcrumb steps for the current path: [{ name, path }], starting
+	// with the filesystem root.
+	dir.segments = derived([dir.path], ([p]) => {
+		const parts = split(p)
+		const steps = parts.map((name, i) => ({ name, path: prefix(p, i + 1) }))
+		return [{ name: SEP, path: SEP }, ...steps]
+	})
+
+	// Function: dispose
+	// Releases the directory's reactive watchers.
+	dir.dispose = () => {
+		stopFilterWatch()
+		stopCursorWatch()
+	}
+
+	return dir
+}
+
+export { createDirectory }

package/src/js/tcmd/core/entries.js

@@ -0,0 +1,88 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-09-26
+
+// Module: tcmd/core/entries
+// Pure operations over file entries: fuzzy filtering and sorting. Entries are
+// plain objects shaped by the filesystem adapter (see core/fs). Matching uses
+// the vendored fzy scorer (see vendor/fzy): a query matches when its characters
+// appear in order, and matches are ranked by score. Directories stay grouped
+// first, then by the configured sort key when scores tie.
+
+import { hasMatch, score } from "../vendor/fzy.js"
+
+// Function: normalizeQuery
+// Trims the raw filter text; an empty/whitespace query means "no filter".
+function normalizeQuery(query) {
+	return `${query ?? ""}`.trim()
+}
+
+// Function: filterEntries
+// Keeps entries whose name fuzzily matches `query` (subsequence,
+// case-insensitive), in listing order. An empty query keeps everything.
+function filterEntries(entries, query) {
+	const q = normalizeQuery(query)
+	if (!q) return entries
+	const res = []
+	for (let i = 0; i < entries.length; i++) {
+		if (hasMatch(q, entries[i].name)) res.push(entries[i])
+	}
+	return res
+}
+
+// Function: compareEntries
+// Orders two entries within the same group (dir/file) by `sort.key`
+// ("name" | "size" | "mtime") and `sort.dir` (1 ascending, -1 descending).
+function compareEntries(a, b, sort) {
+	const key = sort?.key ?? "name"
+	const dir = sort?.dir ?? 1
+	let cmp = 0
+	if (key === "name") cmp = a.name.localeCompare(b.name)
+	else if (key === "size") cmp = (a.size ?? 0) - (b.size ?? 0)
+	else if (key === "mtime") cmp = (a.mtimeMs ?? 0) - (b.mtimeMs ?? 0)
+	return cmp * dir
+}
+
+// Function: rankEntries
+// Fuzzily matches `entries` against `query` and ranks them: directories first,
+// then by descending fzy score, ties broken by `sort`. Entries that do not
+// match are dropped.
+function rankEntries(entries, query, sort) {
+	const q = normalizeQuery(query)
+	const ranked = []
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i]
+		if (!hasMatch(q, entry.name)) continue
+		ranked.push({ entry, score: score(q, entry.name) })
+	}
+	ranked.sort((a, b) => {
+		if (a.entry.isDir !== b.entry.isDir) return a.entry.isDir ? -1 : 1
+		if (a.score !== b.score) return b.score - a.score
+		return compareEntries(a.entry, b.entry, sort)
+	})
+	return ranked.map((match) => match.entry)
+}
+
+// Function: sortEntries
+// Sorts a copy of `entries`: directories first, then by `sort.key`.
+function sortEntries(entries, sort) {
+	const sorted = entries.slice()
+	sorted.sort((a, b) => {
+		if (a.isDir !== b.isDir) return a.isDir ? -1 : 1
+		return compareEntries(a, b, sort)
+	})
+	return sorted
+}
+
+// Function: viewEntries
+// The listing a directory shows: `sortEntries` when there is no filter,
+// otherwise the fzy-ranked matches of `query` (see `rankEntries`).
+function viewEntries(entries, query, sort) {
+	if (!normalizeQuery(query)) return sortEntries(entries, sort)
+	return rankEntries(entries, query, sort)
+}
+
+export { filterEntries, rankEntries, sortEntries, viewEntries }
+
+// EOF

package/src/js/tcmd/core/fs.js

@@ -0,0 +1,266 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-09-26
+
+// Module: tcmd/core/fs
+// Filesystem adapter interface plus a Node/Bun implementation. The core only
+// talks to this interface, so a web build can swap in OPFS or HTTP backends.
+//
+// An adapter provides:
+// - `readDir(path)`: Promise<FileEntry-like[]> - directory listing with stat info
+// - `stat(path)`: Promise<{ isDir, isSymlink, size, mtimeMs, ctimeMs, mode, uid,
+//   gid } | null>
+// - `isDir(path)`: Promise<boolean>
+// - `readTextHead(path, maxBytes)`: Promise<string> - leading bytes as text
+// - `du(path)`: Promise<number> - recursive size in bytes
+// - `disk(path)`: Promise<{ free, total } | null> - filesystem capacity
+// - `copy(from, to)`, `move(from, to)`: Promise<void> - files or directories
+// - `trash(paths)`, `erase(paths)`: Promise<void> - delete, with/without trash
+// - `touch(path)`: Promise<void> - create or bump mtime
+// - `home()`, `cwd()`: string - well-known directories
+
+import fs from "node:fs/promises"
+import nodeFs from "node:fs"
+import nodeOs from "node:os"
+import nodePath from "node:path"
+import { extname, join as pathJoin } from "./path.js"
+
+// Owner-name caches, filled lazily from /etc/passwd and /etc/group. Browsers
+// and non-POSIX hosts never populate them (the adapters there omit `owner`).
+let passwdNames = null
+let groupNames = null
+
+// Function: resolveOwner
+// "user:group" for a uid/gid, resolving names from /etc/passwd and /etc/group
+// (cached once). Falls back to the numeric ids, or "" when both are absent.
+async function resolveOwner(uid, gid) {
+	if (uid == null && gid == null) return ""
+	if (process.platform !== "win32") {
+		passwdNames ??= await parseColonFile("/etc/passwd", 2)
+		groupNames ??= await parseColonFile("/etc/group", 2)
+	}
+	const user = uid == null ? "" : passwdNames?.get(uid) ?? `${uid}`
+	const group = gid == null ? "" : groupNames?.get(gid) ?? `${gid}`
+	return user && group ? `${user}:${group}` : user || group
+}
+
+// Function: parseColonFile
+// Reads a passwd/group-style file into a `{ id -> name }` map; unreadable
+// files yield an empty map (names then fall back to the numeric id).
+async function parseColonFile(path, nameColumn) {
+	const map = new Map()
+	try {
+		const text = await fs.readFile(path, "utf8")
+		for (const line of text.split("\n")) {
+			const parts = line.split(":")
+			const id = Number(parts[2])
+			if (parts.length > nameColumn && Number.isFinite(id)) map.set(id, parts[0])
+		}
+	} catch (error) {
+		// No passwd/group file: numeric ids only.
+	}
+	return map
+}
+
+function toEntry(name, dirPath, isDir, stats) {
+	const stat = stats || {}
+	return {
+		name,
+		path: pathJoin(dirPath, name),
+		isDir,
+		isSymlink: Boolean(stat.isSymlink),
+		isDevice: Boolean(stat.isDevice),
+		size: isDir ? 0 : stat.size ?? 0,
+		mtimeMs: stat.mtimeMs ?? 0,
+		ctimeMs: stat.ctimeMs ?? 0,
+		mode: stat.mode ?? 0,
+		uid: stat.uid ?? null,
+		gid: stat.gid ?? null,
+		ext: isDir ? null : extname(name),
+	}
+}
+
+// Function: isDeviceNode
+// True when a stat/dirent is a special node (block/char device, FIFO, socket).
+function isDeviceNode(node) {
+	return Boolean(
+		node?.isBlockDevice?.() || node?.isCharacterDevice?.() || node?.isFIFO?.() || node?.isSocket?.(),
+	)
+}
+
+// Function: createNodeFs
+// Node/Bun-backed implementation of the filesystem adapter.
+function createNodeFs() {
+	const adapter = {
+		async readDir(path) {
+			const dirents = await fs.readdir(path, { withFileTypes: true })
+			const entries = new Array(dirents.length)
+			for (let i = 0; i < dirents.length; i++) {
+				const d = dirents[i]
+				const full = pathJoin(path, d.name)
+				const stats = await statSafe(full)
+				entries[i] = toEntry(d.name, path, d.isDirectory(), {
+					isSymlink: d.isSymbolicLink(),
+					isDevice: isDeviceNode(d),
+					size: stats?.size ?? 0,
+					mtimeMs: stats?.mtimeMs ?? 0,
+					ctimeMs: stats?.ctimeMs ?? 0,
+					mode: stats?.mode ?? 0,
+					uid: stats?.uid ?? null,
+					gid: stats?.gid ?? null,
+				})
+				entries[i].owner = await resolveOwner(stats?.uid, stats?.gid)
+			}
+			return entries
+		},
+		async stat(path) {
+			return statSafe(path)
+		},
+		async isDir(path) {
+			const stats = await statSafe(path)
+			return Boolean(stats?.isDir)
+		},
+		async readTextHead(path, maxBytes = 65536) {
+			const file = nodeFs.openSync(path, "r")
+			try {
+				const buffer = Buffer.alloc(maxBytes)
+				const bytes = nodeFs.readSync(file, buffer, 0, maxBytes, 0)
+				return buffer.toString("utf8", 0, bytes)
+			} finally {
+				nodeFs.closeSync(file)
+			}
+		},
+		async du(path) {
+			return duSafe(path)
+		},
+		async disk(path) {
+			try {
+				const stats = await fs.statfs(path)
+				return { free: Number(stats.bfree * stats.bsize), total: Number(stats.blocks * stats.bsize) }
+			} catch (error) {
+				return null
+			}
+		},
+		async copy(from, to) {
+			await fs.cp(from, to, { recursive: true })
+		},
+		async move(from, to) {
+			try {
+				await fs.rename(from, to)
+			} catch (error) {
+				if (error?.code !== "EXDEV") throw error
+				await fs.cp(from, to, { recursive: true })
+				await fs.rm(from, { recursive: true })
+			}
+		},
+		async trash(paths) {
+			const filesDir = trashDir("files")
+			const infoDir = trashDir("info")
+			await fs.mkdir(filesDir, { recursive: true })
+			await fs.mkdir(infoDir, { recursive: true })
+			for (const source of paths) {
+				const absolute = nodePath.resolve(source)
+				const name = await freeTrashName(filesDir, nodePath.basename(absolute))
+				const target = nodePath.join(filesDir, name)
+				try {
+					await fs.rename(absolute, target)
+				} catch (error) {
+					if (error?.code !== "EXDEV") throw error
+					await fs.cp(absolute, target, { recursive: true })
+					await fs.rm(absolute, { recursive: true })
+				}
+				const info = `[Trash Info]\nPath=${absolute}\nDeletionDate=${new Date().toISOString()}\n`
+				await fs.writeFile(nodePath.join(infoDir, `${name}.trashinfo`), info)
+			}
+		},
+		async erase(paths) {
+			for (const path of paths) await fs.rm(path, { recursive: true })
+		},
+		async touch(path) {
+			const now = new Date()
+			try {
+				await fs.utimes(path, now, now)
+			} catch (error) {
+				const handle = await fs.open(path, "a")
+				await handle.close()
+			}
+		},
+		home() {
+			return nodeOs.homedir()
+		},
+		cwd() {
+			return process.cwd()
+		},
+	}
+	return adapter
+}
+
+// Function: trashDir
+// Freedesktop trash directory under $XDG_DATA_HOME (default
+// ~/.local/share/Trash).
+function trashDir(kind) {
+	const dataHome = process.env.XDG_DATA_HOME || nodePath.join(nodeOs.homedir(), ".local", "share")
+	return nodePath.join(dataHome, "Trash", kind)
+}
+
+// Function: freeTrashName
+// First free `<name>`, `<name>.1`, … in the trash files directory.
+async function freeTrashName(filesDir, base) {
+	for (let i = 0; ; i++) {
+		const name = i === 0 ? base : `${base}.${i}`
+		try {
+			await fs.access(nodePath.join(filesDir, name))
+		} catch (error) {
+			return name
+		}
+	}
+}
+
+async function statSafe(path) {
+	try {
+		const stats = await fs.stat(path)
+		return {
+			isDir: stats.isDirectory(),
+			isSymlink: stats.isSymbolicLink(),
+			isDevice: isDeviceNode(stats),
+			size: stats.size,
+			mtimeMs: stats.mtimeMs,
+			ctimeMs: stats.ctimeMs,
+			mode: stats.mode,
+			uid: stats.uid,
+			gid: stats.gid,
+			owner: await resolveOwner(stats.uid, stats.gid),
+		}
+	} catch (error) {
+		return null
+	}
+}
+
+// Function: duSafe
+// Recursive disk usage; unreadable entries contribute 0 and never throw.
+async function duSafe(path) {
+	const stats = await statSafe(path)
+	if (!stats) return 0
+	if (!stats.isDir) return stats.size
+	let total = 0
+	let dirents
+	try {
+		dirents = await fs.readdir(path, { withFileTypes: true })
+	} catch (error) {
+		return 0
+	}
+	for (const d of dirents) {
+		const full = pathJoin(path, d.name)
+		if (d.isDirectory()) total += await duSafe(full)
+		else if (!d.isSymbolicLink()) {
+			const child = await statSafe(full)
+			total += child?.size ?? 0
+		}
+	}
+	return total
+}
+
+export { createNodeFs }
+
+// EOF

package/src/js/tcmd/core/index.js

@@ -0,0 +1,39 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-09-26
+
+// Module: tcmd/core
+// UI-agnostic model and controller for TinyCommand. This layer has no
+// rendering dependencies (no OpenTUI, no select.tui, no DOM) so both the TUI
+// and a future web UI can share it. State is expressed as reactive cells from
+// `select/state/cells`; the filesystem and host adapters are injectable
+// (core/fs, core/os).
+
+export { createNodeFs } from "./fs.js"
+export { createNullOs, createNodeOs } from "./os.js"
+export { filterEntries, rankEntries, sortEntries, viewEntries } from "./entries.js"
+export { clampCursor, currentEntry, moveCursor, toggleMark } from "./selection.js"
+export { PANE_BUFFERS, PANE_LABELS, createPane } from "./pane.js"
+export { createDirectory } from "./directory.js"
+export {
+	createBookmarks,
+	createFileBookmarkStore,
+	createMemoryBookmarkStore,
+	isValidName,
+	normalizeName,
+} from "./bookmarks.js"
+export { DEFAULT_KEYMAP, matchKeymap } from "./keymap.js"
+export { createDispatch, getCommand, getCommands } from "./commands.js"
+export { expandAll, expandArg, decodePathToken, getOperation, getOperations, pathToken, runOperation } from "./operations.js"
+export {
+	PANEL_FOCUS,
+	argvFor,
+	bindArgs,
+	panelOperations,
+	panelRowList,
+	paneSelectionPaths,
+} from "./panel.js"
+export { parseLine, runLine, scriptItems, tokenize } from "./script.js"
+export { createSession, load } from "./session.js"
+export { SEP, basename, extname, join, normalize, parent, prefix, split } from "./path.js"

package/src/js/tcmd/core/keymap.js

@@ -0,0 +1,60 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-09-26
+
+// Module: tcmd/core/keymap
+// Key chord to command-id mapping. A chord is `{ name, ctrl?, meta?, shift? }`
+// as delivered by OpenTUI key events. Matching is first-match-wins.
+
+const DEFAULT_KEYMAP = [
+	{ key: "up", command: "nav.up" },
+	{ key: "down", command: "nav.down" },
+	{ key: "up", ctrl: true, command: "nav.jumpUp" },
+	{ key: "down", ctrl: true, command: "nav.jumpDown" },
+	{ key: "pageup", command: "nav.pageUp" },
+	{ key: "pagedown", command: "nav.pageDown" },
+	{ key: "home", command: "nav.home" },
+	{ key: "end", command: "nav.end" },
+	{ key: "right", command: "pane.enter" },
+	{ key: "return", command: "pane.enter" },
+	{ key: "enter", command: "pane.enter" },
+	{ key: "left", command: "pane.up" },
+	{ key: "backspace", command: "pane.up" },
+	{ key: "escape", command: "pane.back" },
+	{ key: "escape", shift: true, command: "pane.forward" },
+	{ key: "tab", command: "pane.toggle" },
+	{ key: "tab", shift: true, command: "pane.toggle" },
+	{ key: "space", command: "list.mark" },
+	{ key: "b", command: "bookmark.record" },
+	{ key: "g", command: "bookmark.jump" },
+	{ key: "m", command: "panel.toggle" },
+	{ key: ":", command: "panel.open" },
+	{ key: "!", command: "palette.run" },
+	{ key: "/", command: "filter.start" },
+	{ key: "r", ctrl: true, command: "pane.reload" },
+	{ key: "v", command: "view.togglePreview" },
+	{ key: "o", shift: true, command: "file.open" },
+	{ key: "e", shift: true, command: "file.edit" },
+	{ key: "p", ctrl: true, command: "palette.toggle" },
+	{ key: "q", command: "app.quit" },
+]
+
+// Function: matchKeymap
+// Returns the command id for `chord`, or `null` when nothing matches.
+function matchKeymap(keymap, chord) {
+	if (!chord?.name) return null
+	for (let i = 0; i < keymap.length; i++) {
+		const binding = keymap[i]
+		if (binding.key !== chord.name) continue
+		if (Boolean(binding.ctrl) !== Boolean(chord.ctrl)) continue
+		if (Boolean(binding.meta) !== Boolean(chord.meta)) continue
+		if (Boolean(binding.shift) !== Boolean(chord.shift)) continue
+		return binding.command
+	}
+	return null
+}
+
+export { DEFAULT_KEYMAP, matchKeymap }
+
+// EOF