@joystyk/cards-ui 0.0.0-stage → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# @joystyk/cards-ui
+
+## 0.2.0
+
+### Patch Changes
+
+- Updated dependencies [bb095c7]
+- Updated dependencies [bb095c7]
+  - @joystyk/contracts@0.2.0
+  - @joystyk/kit@0.2.0
+
+## 0.1.0
+
+### Minor Changes
+
+- Prepare the first compiled library release: ESM and API declarations for every public entry point, runtime assets, and checks against installed npm tarballs. Games and applications remain private.
+
+### Patch Changes
+
+- Updated dependencies
+  - @joystyk/contracts@0.1.0
+  - @joystyk/kit@0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joystyk contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,36 @@
+Third-party material in the Joystyk library release
+
+This notice preserves third-party attribution. Original Joystyk code in the 17
+platform libraries under packages/ uses the MIT license in packages/LICENSE.
+That choice does not license the private applications, games or other repository
+material, and does not replace the third-party terms below.
+
+@joystyk/contracts
+------------------
+Standard Schema v1 type definitions from @standard-schema/spec 1.1.0:
+https://github.com/standard-schema/standard-schema
+https://standardschema.dev
+Copyright (c) 2024 Colin McDonnell. MIT License.
+The complete license and source/change notes accompany the distributed
+dist/standard-schema.d.ts definitions. Changes: individually exported declarations
+and formatting; the declarations themselves are unchanged.
+
+@joystyk/identity and @joystyk/content
+-----------------------------------
+Word blocklists derived from List of Dirty, Naughty, Obscene, and Otherwise Bad
+Words, copyright Shutterstock, Inc. and contributors:
+https://github.com/LDNOOBW/List-of-Dirty-Naughty-Obscene-and-Otherwise-Bad-Words
+Licensed under Creative Commons Attribution 4.0 International:
+https://creativecommons.org/licenses/by/4.0/
+Identity uses the English list at commit
+5faf2ba42d7b1c0977169ec3611df25a3c08eb13. Changes include reducing or dropping
+phrases, dropping words with everyday meanings, substituting stems for inflections
+and adding entries. Identity's README and content's lists/blocklist.txt retain
+their source-specific provenance and changes.
+
+@joystyk/content
+---------------
+SCOWL-derived common, vocabulary and ranked word lists use SCOWL 2020.12.07.
+Their complete source licenses and attribution accompany the package in
+lists/SCOWL-COPYRIGHT. Word-list transformations and build provenance are described
+in the package README. Preserve that copyright file when redistributing the lists.

package/README.md

@@ -1,3 +1,33 @@
-# Temporary Holding Version
+# @joystyk/cards-ui
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Shared card tables, hands and solitaire controls for Gyral games. A game supplies a public table layout and intentions; these components handle pointer, keyboard and screen-reader interaction. Keep game authority in the engine.
+
+## npm package
+
+The first `0.1.0` release is being prepared; it has not been published. Once available:
+
+```sh
+npm install @joystyk/cards-ui
+```
+
+Node consumers require Node 24.15 or later. Browser entry points require a modern
+browser and should be loaded in the browser. Tested with Gyral 0.3.1.
+
+| Import | Format |
+| --- | --- |
+| `@joystyk/cards-ui` | ES module and TypeScript declarations |
+| `@joystyk/cards-ui/controller` | ES module and TypeScript declarations |
+| `@joystyk/cards-ui/layout` | ES module and TypeScript declarations |
+| `@joystyk/cards-ui/solitaire` | ES module and TypeScript declarations |
+
+Only the entries listed above are public API. Installed packages contain compiled ESM,
+type declarations and runtime assets. Repository-relative links describe the Joystyk
+workspace and are not needed to use the npm package.
+
+```ts
+import { CardTable, CardHand } from '@joystyk/cards-ui';
+import { EMPTY_LAYOUT, DEFAULT_OPTIONS } from '@joystyk/cards-ui/layout';
+
+// CardTable and CardHand register <jy-card-table> and <jy-card-hand>.
+// Bind the layout/options properties from your Gyral parent.
+```

package/dist/controller.d.ts

@@ -0,0 +1,110 @@
+import { type FaceCard, type PileSpec, type TableLayout, type TableOptions } from './layout.js';
+/** Pointer travel, in CSS pixels, that turns a press into a drag (spec: Pointer). */
+export declare const DRAG_THRESHOLD = 6;
+export type Via = 'drag' | 'click' | 'keyboard';
+/** Cards the player has picked up: the top `count` of pile `from`. */
+export type Held = {
+    readonly from: string;
+    readonly count: number;
+    readonly via: Via;
+};
+/** A pointer pressed on a pile; `depth` counts cards from the top (0: the pile, not a card). */
+export type Press = {
+    readonly pile: string | null;
+    readonly depth: number;
+    readonly x: number;
+    readonly y: number;
+    readonly dragging: boolean;
+    readonly dx: number;
+    readonly dy: number;
+    readonly over: string | null;
+};
+export type Ctl = {
+    /** The focused region. */
+    readonly region: number;
+    /** The remembered pile of each region: the one Tab reaches (roving tabindex). */
+    readonly piles: readonly number[];
+    /** Cards counted from the top of the focused pile: what Enter picks up. */
+    readonly depth: number;
+    readonly held: Held | null;
+    readonly press: Press | null;
+    /** The layout version last seen. */
+    readonly version: number;
+    /** A drag just dropped: the next layout lands without card flights. */
+    readonly settle: boolean;
+    /** The layout version that renders without card flights. */
+    readonly quiet: number | null;
+};
+/** What the table tells the game. */
+export type TableOut = {
+    readonly _tag: 'Move';
+    readonly from: string;
+    readonly to: string;
+    readonly count: number;
+    readonly via: Via;
+} | {
+    readonly _tag: 'Smart';
+    readonly from: string;
+    readonly count: number;
+    readonly via: Via;
+} | {
+    readonly _tag: 'Activate';
+    readonly pile: string;
+} | {
+    readonly _tag: 'Key';
+    readonly key: string;
+    readonly pile: string;
+    readonly count: number;
+} | {
+    readonly _tag: 'Announce';
+    readonly message: string;
+};
+export type CtlMsg = {
+    readonly _tag: 'Key';
+    readonly key: string;
+    readonly ctrl: boolean;
+    readonly alt: boolean;
+    readonly meta: boolean;
+    readonly shift: boolean;
+} | {
+    readonly _tag: 'Focus';
+    readonly pile: string;
+} | {
+    readonly _tag: 'Down';
+    readonly pile: string | null;
+    readonly depth: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly _tag: 'Move';
+    readonly x: number;
+    readonly y: number;
+    readonly over: string | null;
+} | {
+    readonly _tag: 'Up';
+    readonly over: string | null;
+} | {
+    readonly _tag: 'Cancel';
+};
+/** One step: the new controller state, outputs, and a pile to focus after rendering. */
+export type Step = {
+    readonly ctl: Ctl;
+    readonly outs: readonly TableOut[];
+    readonly focus: string | null;
+};
+export declare const initialCtl: (layout: TableLayout) => Ctl;
+/**
+ * Brings the controller in line with a new layout: indexes stay in range, and a new version
+ * (the cards changed) drops any pick-up or press.
+ */
+export declare const sync: (ctl: Ctl, layout: TableLayout) => Ctl;
+/** The focused pile, if the table has any. */
+export declare const focusedPile: (ctl: Ctl, layout: TableLayout) => PileSpec | null;
+/** A card's name for the middle of a sentence: "queen of hearts", "7 of clubs". */
+export declare const spoken: (card: FaceCard) => string;
+/** "9 of spades", or "9 of spades and 2 more cards": the cards a pick-up of `count` takes. */
+export declare const describe: (pile: PileSpec, count: number) => string;
+/** The controller's reducer. */
+export declare const step: (before: Ctl, layout: TableLayout, options: TableOptions, m: CtlMsg) => Step;
+/** True when the table should render this layout without card flights. */
+export declare const isQuiet: (ctl: Ctl, layout: TableLayout, options: TableOptions) => boolean;

package/dist/controller.js

@@ -0,0 +1,449 @@
+import { findPile, isFaceCard, topCards } from "./layout.js";
+import { cardName } from "@joystyk/kit/cards";
+//#region src/controller.ts
+/** Pointer travel, in CSS pixels, that turns a press into a drag (spec: Pointer). */
+var DRAG_THRESHOLD = 6;
+var initialCtl = (layout) => {
+	const first = layout.regions.findIndex((r) => r.piles.length > 0);
+	return {
+		region: Math.max(0, first),
+		piles: layout.regions.map(() => 0),
+		depth: 1,
+		held: null,
+		press: null,
+		version: layout.version,
+		settle: false,
+		quiet: null
+	};
+};
+var clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+/**
+* Brings the controller in line with a new layout: indexes stay in range, and a new version
+* (the cards changed) drops any pick-up or press.
+*/
+var sync = (ctl, layout) => {
+	const piles = layout.regions.map((r, i) => clamp(ctl.piles[i] ?? 0, 0, Math.max(0, r.piles.length - 1)));
+	let region = clamp(ctl.region, 0, Math.max(0, layout.regions.length - 1));
+	if ((layout.regions[region]?.piles.length ?? 0) === 0) region = Math.max(0, layout.regions.findIndex((r) => r.piles.length > 0));
+	const moved = layout.version !== ctl.version;
+	const same = piles.length === ctl.piles.length && piles.every((p, i) => p === ctl.piles[i]) && region === ctl.region;
+	if (!moved && same) return ctl;
+	if (!moved) return {
+		...ctl,
+		piles,
+		region
+	};
+	return {
+		...ctl,
+		piles,
+		region,
+		depth: 1,
+		held: null,
+		press: null,
+		version: layout.version,
+		settle: false,
+		quiet: ctl.settle ? layout.version : null
+	};
+};
+/** The focused pile, if the table has any. */
+var focusedPile = (ctl, layout) => layout.regions[ctl.region]?.piles[ctl.piles[ctl.region] ?? 0] ?? null;
+/** A card's name for the middle of a sentence: "queen of hearts", "7 of clubs". */
+var spoken = (card) => cardName(card).toLowerCase();
+var capital = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+/** "9 of spades", or "9 of spades and 2 more cards": the cards a pick-up of `count` takes. */
+var describe = (pile, count) => {
+	const [first] = topCards(pile, count);
+	if (first === void 0) return "nothing";
+	const more = count - 1;
+	return more === 0 ? spoken(first) : `${spoken(first)} and ${more} more ${more === 1 ? "card" : "cards"}`;
+};
+var none = (ctl) => ({
+	ctl,
+	outs: [],
+	focus: null
+});
+var say = (message) => ({
+	_tag: "Announce",
+	message
+});
+/** Picks up `count` cards from `pile` and says so. */
+var pickUp = (ctl, pile, count, via) => {
+	const note = pile.note === void 0 ? "" : ` ${pile.note}`;
+	const help = via === "keyboard" ? " Choose a pile, then press Enter." : "";
+	return {
+		ctl: {
+			...ctl,
+			held: {
+				from: pile.id,
+				count,
+				via
+			}
+		},
+		outs: [say(`Picked up ${describe(pile, count)}.${note}${help}`)],
+		focus: null
+	};
+};
+/** Drops the held cards on `to`: a move, or a smart move on their own pile. */
+var drop = (ctl, held, to, via) => {
+	return {
+		ctl: {
+			...ctl,
+			held: null
+		},
+		outs: [to === held.from ? {
+			_tag: "Smart",
+			from: held.from,
+			count: held.count,
+			via
+		} : {
+			_tag: "Move",
+			from: held.from,
+			to,
+			count: held.count,
+			via
+		}],
+		focus: null
+	};
+};
+var putBack = (ctl, layout) => {
+	const held = ctl.held;
+	if (held === null) return none(ctl);
+	const pile = findPile(layout, held.from)?.pile;
+	return {
+		ctl: {
+			...ctl,
+			held: null
+		},
+		outs: [say(pile === void 0 ? "Put back." : `Put back ${describe(pile, held.count)}.`)],
+		focus: null
+	};
+};
+/** Moves the focus to pile `index` of the focused region. */
+var focusAt = (ctl, layout, region, index) => {
+	const pile = layout.regions[region]?.piles[index];
+	if (pile === void 0) return none(ctl);
+	const piles = ctl.piles.slice();
+	piles[region] = index;
+	const changed = region !== ctl.region || index !== ctl.piles[region];
+	return {
+		ctl: {
+			...ctl,
+			region,
+			piles,
+			depth: changed ? 1 : ctl.depth
+		},
+		outs: [],
+		focus: pile.id
+	};
+};
+/** Enter or Space on the focused pile. */
+var activate = (ctl, pile) => {
+	if (ctl.held !== null) return drop(ctl, ctl.held, pile.id, "keyboard");
+	if (pile.action === true) return {
+		ctl,
+		outs: [{
+			_tag: "Activate",
+			pile: pile.id
+		}],
+		focus: null
+	};
+	if (pile.pickable >= 1) return pickUp(ctl, pile, clamp(ctl.depth, 1, pile.pickable), "keyboard");
+	return {
+		ctl,
+		outs: [say(pile.cards.length === 0 ? "Nothing to pick up: the pile is empty." : "Nothing here can be picked up.")],
+		focus: null
+	};
+};
+/** Up and Down: how many cards Enter picks up. */
+var deepen = (ctl, pile, by) => {
+	if (pile.inspect === true && ctl.held === null) {
+		const depth = clamp(ctl.depth + by, 1, Math.max(1, pile.cards.length));
+		const card = pile.cards[pile.cards.length - depth];
+		return {
+			ctl: {
+				...ctl,
+				depth
+			},
+			outs: isFaceCard(card) ? [say(capital(spoken(card)))] : [],
+			focus: null
+		};
+	}
+	if (ctl.held !== null || pile.pickable < 1) return none(ctl);
+	const depth = clamp(ctl.depth, 1, pile.pickable);
+	const next = depth + by;
+	if (next < 1) return {
+		ctl: {
+			...ctl,
+			depth
+		},
+		outs: [],
+		focus: null
+	};
+	if (next > pile.pickable) return {
+		ctl: {
+			...ctl,
+			depth
+		},
+		outs: pile.limit === void 0 ? [] : [say(pile.limit)],
+		focus: null
+	};
+	return {
+		ctl: {
+			...ctl,
+			depth: next
+		},
+		outs: [say(capital(describe(pile, next)))],
+		focus: null
+	};
+};
+var isDigit = (key) => key.length === 1 && key >= "0" && key <= "9";
+/** Navigate a geometric layout without consulting the DOM or skipping covered cards. */
+var geometricFocus = (ctl, layout, key) => {
+	const region = layout.regions[ctl.region];
+	const here = focusedPile(ctl, layout)?.position;
+	if (region?.placement !== "free" || here === void 0) return null;
+	const candidates = region.piles.map((pile, index) => ({
+		index,
+		position: pile.position
+	})).filter((p) => p.position !== void 0);
+	const row = key === "ArrowUp" ? Math.max(-1, ...candidates.filter((p) => p.position.row < here.row).map((p) => p.position.row)) : key === "ArrowDown" ? Math.min(Infinity, ...candidates.filter((p) => p.position.row > here.row).map((p) => p.position.row)) : here.row;
+	let choices = candidates.filter((p) => p.position.row === row);
+	if (key === "ArrowLeft") choices = choices.filter((p) => p.position.column < here.column);
+	if (key === "ArrowRight") choices = choices.filter((p) => p.position.column > here.column);
+	choices.sort((a, b) => key === "Home" ? a.position.column - b.position.column : key === "End" ? b.position.column - a.position.column : Math.abs(a.position.column - here.column) - Math.abs(b.position.column - here.column) || a.position.column - b.position.column);
+	return choices[0] === void 0 ? none(ctl) : focusAt(ctl, layout, ctl.region, choices[0].index);
+};
+var onKey = (ctl, layout, options, m) => {
+	const pile = focusedPile(ctl, layout);
+	if (pile === null || m.alt || m.meta || m.ctrl) return none(ctl);
+	const count = layout.regions[ctl.region]?.piles.length ?? 0;
+	const index = ctl.piles[ctl.region] ?? 0;
+	if ([
+		"ArrowLeft",
+		"ArrowRight",
+		"ArrowUp",
+		"ArrowDown",
+		"Home",
+		"End"
+	].includes(m.key)) {
+		const spatial = geometricFocus(ctl, layout, m.key);
+		if (spatial !== null) return spatial;
+	}
+	switch (m.key) {
+		case "ArrowLeft": return focusAt(ctl, layout, ctl.region, Math.max(0, index - 1));
+		case "ArrowRight": return focusAt(ctl, layout, ctl.region, Math.min(count - 1, index + 1));
+		case "Home": return focusAt(ctl, layout, ctl.region, 0);
+		case "End": return focusAt(ctl, layout, ctl.region, count - 1);
+		case "ArrowUp": return deepen(ctl, pile, 1);
+		case "ArrowDown": return deepen(ctl, pile, -1);
+		case "Enter":
+		case " ": return activate(ctl, pile);
+		case "Escape": return putBack(ctl, layout);
+	}
+	if (!options.singleKeys || m.shift) return none(ctl);
+	const key = m.key.toLowerCase();
+	if (isDigit(key)) {
+		const target = layout.regions.flatMap((r, ri) => r.piles.map((p, pi) => ({
+			p,
+			ri,
+			pi
+		}))).find(({ p }) => p.key === key);
+		if (target === void 0) return none(ctl);
+		const moved = focusAt(ctl, layout, target.ri, target.pi);
+		if (ctl.held === null) return layout.activateNumbers === true ? {
+			...activate(moved.ctl, target.p),
+			focus: moved.focus
+		} : moved;
+		return {
+			...drop(moved.ctl, ctl.held, target.p.id, "keyboard"),
+			focus: moved.focus
+		};
+	}
+	if (layout.keys.includes(key)) {
+		if (key === "n" || key === "t" || key === "w") {
+			const piles = layout.regions.flatMap((r, ri) => r.piles.map((p, pi) => ({
+				p,
+				ri,
+				pi
+			})));
+			const available = piles.filter(({ p }) => p.pickable > 0).sort((a, b) => (b.p.position?.row ?? -1) - (a.p.position?.row ?? -1) || (a.p.position?.column ?? a.pi) - (b.p.position?.column ?? b.pi));
+			const current = available.findIndex(({ p }) => p.id === pile.id);
+			const next = key === "n" ? available[(current + 1) % Math.max(1, available.length)] : piles.find(({ p }) => p.id === (key === "t" ? "turned" : "waste"));
+			if (next !== void 0) return focusAt(ctl, layout, next.ri, next.pi);
+			return none(ctl);
+		}
+		const held = ctl.held;
+		const out = held === null ? {
+			_tag: "Key",
+			key,
+			pile: pile.id,
+			count: clamp(ctl.depth, 1, Math.max(1, pile.pickable))
+		} : {
+			_tag: "Key",
+			key,
+			pile: held.from,
+			count: held.count
+		};
+		return {
+			ctl: {
+				...ctl,
+				held: null
+			},
+			outs: [out],
+			focus: null
+		};
+	}
+	return none(ctl);
+};
+/** A click (a press released without dragging) on `pileId` at `depth`. */
+var click = (ctl, layout, pileId, depth) => {
+	const found = pileId === null ? null : findPile(layout, pileId);
+	if (found === null) return putBack(ctl, layout);
+	const { pile } = found;
+	const focused = {
+		...ctl,
+		region: found.region,
+		piles: ctl.piles.map((p, i) => i === found.region ? found.index : p)
+	};
+	const held = ctl.held;
+	if (held !== null) {
+		if (pile.id !== held.from) return drop(focused, held, pile.id, "click");
+		if (depth === held.count) return drop(focused, held, pile.id, "click");
+		if (depth >= 1 && depth <= pile.pickable) return pickUp({
+			...focused,
+			depth
+		}, pile, depth, "click");
+		return putBack(focused, layout);
+	}
+	if (pile.action === true) return {
+		ctl: focused,
+		outs: [{
+			_tag: "Activate",
+			pile: pile.id
+		}],
+		focus: null
+	};
+	if (depth >= 1 && depth <= pile.pickable) return pickUp({
+		...focused,
+		depth
+	}, pile, depth, "click");
+	return none(focused);
+};
+/** The controller's reducer. */
+var step = (before, layout, options, m) => {
+	const ctl = sync(before, layout);
+	switch (m._tag) {
+		case "Key": return onKey(ctl, layout, options, m);
+		case "Focus": {
+			const found = findPile(layout, m.pile);
+			if (found === null) return none(ctl);
+			if (found.region === ctl.region && found.index === ctl.piles[found.region]) return none(ctl);
+			const piles = ctl.piles.slice();
+			piles[found.region] = found.index;
+			return none({
+				...ctl,
+				region: found.region,
+				piles,
+				depth: 1
+			});
+		}
+		case "Down": {
+			const stale = ctl.press?.dragging === true;
+			return none({
+				...ctl,
+				held: stale ? null : ctl.held,
+				press: {
+					pile: m.pile,
+					depth: m.depth,
+					x: m.x,
+					y: m.y,
+					dragging: false,
+					dx: 0,
+					dy: 0,
+					over: null
+				}
+			});
+		}
+		case "Move": {
+			const press = ctl.press;
+			if (press === null || press.pile === null) return none(ctl);
+			const dx = m.x - press.x;
+			const dy = m.y - press.y;
+			if (press.dragging) return none({
+				...ctl,
+				press: {
+					...press,
+					dx,
+					dy,
+					over: m.over
+				}
+			});
+			if (Math.sqrt(dx * dx + dy * dy) < 6) return none(ctl);
+			const pile = findPile(layout, press.pile)?.pile;
+			const top = pile?.cards[pile.cards.length - press.depth];
+			if (pile === void 0 || press.depth < 1 || press.depth > pile.pickable || !isFaceCard(top)) return none({
+				...ctl,
+				press: null
+			});
+			return none({
+				...ctl,
+				held: {
+					from: pile.id,
+					count: press.depth,
+					via: "drag"
+				},
+				press: {
+					...press,
+					dragging: true,
+					dx,
+					dy,
+					over: m.over
+				}
+			});
+		}
+		case "Up": {
+			const press = ctl.press;
+			if (press === null) return none(ctl);
+			const released = {
+				...ctl,
+				press: null
+			};
+			if (!press.dragging) return click(released, layout, press.pile, press.depth);
+			const held = ctl.held;
+			const to = m.over;
+			if (held === null || to === null || to === held.from) return none({
+				...released,
+				held: null
+			});
+			return {
+				ctl: {
+					...released,
+					held: null,
+					settle: true
+				},
+				outs: [{
+					_tag: "Move",
+					from: held.from,
+					to,
+					count: held.count,
+					via: "drag"
+				}],
+				focus: null
+			};
+		}
+		case "Cancel": {
+			const dragging = ctl.press?.dragging === true;
+			return none({
+				...ctl,
+				press: null,
+				held: dragging ? null : ctl.held
+			});
+		}
+	}
+};
+/** True when the table should render this layout without card flights. */
+var isQuiet = (ctl, layout, options) => options.calm || ctl.quiet === layout.version;
+//#endregion
+export { DRAG_THRESHOLD, describe, focusedPile, initialCtl, isQuiet, spoken, step, sync };
+
+//# sourceMappingURL=controller.js.map