@witchcraft/spellcraft 0.0.1

package/src/internal/checkUntrigger.ts

@@ -0,0 +1,26 @@
+import { setManagerProp } from "../core/setManagerProp.js"
+import type { AnyInputEvent, Manager, TriggerableShortcut } from "../types/index.js"
+
+
+export function checkUntrigger(
+	manager: Manager,
+	e?: AnyInputEvent
+): void {
+	if (manager.state.untrigger) {
+		const untrigger: TriggerableShortcut = manager.state.untrigger
+		// MUST be set to false first or we can get into an infinite loop if the user uses `set(chain)` from inside the command execute function
+		setManagerProp(manager, "state.untrigger", false)
+		setManagerProp(manager, "state.nextIsChord", false)
+		if (!manager.options.enableShortcuts) return
+		const command = manager.commands.entries[untrigger.command]
+		command.execute?.({
+			isKeydown: false,
+			command,
+			shortcut: untrigger,
+			event: e,
+			manager,
+			context: manager.context
+		})
+	}
+}
+

package/src/internal/cloneLastChord.ts

@@ -0,0 +1,10 @@
+import { last } from "@alanscodelog/utils/last"
+
+/**
+ * A copy of the last chord in the chain if it exists.
+ */
+export function cloneLastChord(chain: string[][]): string[] | undefined {
+	const lastC = last(chain)
+	return lastC ? [...lastC] : undefined
+}
+

package/src/internal/containsPossibleToggleChords.ts

@@ -0,0 +1,91 @@
+import { crop } from "@alanscodelog/utils/crop"
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { getKeyFromIdOrVariant } from "../helpers/getKeyFromIdOrVariant.js"
+import { KnownError } from "../helpers/KnownError.js"
+import { type Manager, type PickManager, SHORTCUT_ERROR } from "../types/index.js"
+
+/**
+ * If you have toggle keys in chords, their are "chains" of the same toggle key that would be physically impossible. For example: `toggle(on) toggle(on)`.
+ *
+ * This guards against that.
+ *
+ * This does NOT guard against duplicates and errors in the same chord, for that see {@link isValidChord}.
+ *
+ * @internal
+ */
+export function containsPossibleToggleChords(
+	chain: string[][],
+	manager: Pick<Manager, "keys"> & PickManager<"options", "stringifier">
+): Result<true, KnownError<typeof SHORTCUT_ERROR.IMPOSSIBLE_TOGGLE_SEQUENCE>> {
+	const keys = manager.keys
+	const s = manager.options.stringifier
+
+
+	const prevToggles: [string, number][] = []
+	let num = 0
+	let impossible: {
+		keyId: string
+		pos: number
+	} | undefined
+	for (const chord of chain) {
+		const toggleIds = chord.filter(keyId => (getKeyFromIdOrVariant(keyId, keys).unwrap()[0]).isToggle)
+		let found = false
+		for (let k = 0; k < toggleIds.length; k++) {
+			const currId = toggleIds[k]
+			// We've already been guaranteed there's maximum 1 of the same toggle per chord in isValidChord
+			// So we can use this to count if the amount of previous toggle states for each unique toggle key cancel out
+			const prevWithSameRootsIds = prevToggles.map(([prevId, j]) => {
+				const prev = getKeyFromIdOrVariant(prevId, keys).unwrap()[0]
+				const curr = getKeyFromIdOrVariant(currId, keys).unwrap()[0]
+				return (prev.id === curr.id || prev.variants?.includes(curr.id) || curr.variants?.includes(prev.id))
+					? [prevId, j]
+					: undefined
+			}).filter(key => key !== undefined) as [string, number][]
+			prevWithSameRootsIds.push([currId, num + k])
+			let canBeOn = true
+			let canBeOff = true
+			for (const [keyId, j] of prevWithSameRootsIds) {
+				// no need to check variants
+				const key = (keys.entries[keyId] ?? keys.toggles[keyId])
+				if (key.id === keyId) {
+					// Flip them since a root toggle functions as the opposite of the last toggle key state
+					// Note they can be both true, which is why we must literally flip them
+					const couldOn: boolean = canBeOn
+					const couldOff: boolean = canBeOff
+					canBeOn = couldOff
+					canBeOff = couldOn
+					continue
+				}
+				const isOff = key.toggleOffId === keyId
+				const isOn = key.toggleOnId === keyId
+				if ((isOn && !canBeOn)
+					|| (isOff && !canBeOff)) {
+					impossible = { keyId, pos: j }
+					break
+				}
+				canBeOn = isOff
+				canBeOff = isOn
+			}
+			if (impossible) {
+				found = true; break
+			}
+			const currKey = getKeyFromIdOrVariant(currId, keys).unwrap()[0]
+			if (currKey.isToggle) {
+				prevToggles.push([currId, num + k])
+			}
+			num += chord.length
+		}
+		if (found) break
+	}
+	if (impossible) {
+		const prettyShortcut = s.stringify(chain, manager)
+		const { pos, keyId: key } = impossible
+		const e = Err(new KnownError(SHORTCUT_ERROR.IMPOSSIBLE_TOGGLE_SEQUENCE, crop`
+			Chain "${prettyShortcut}" is impossible.
+			This chain has a toggle key state "${s.stringify(key, manager)}" at key #${pos + 1} that would be impossible to trigger.
+		`, { chain, key: keys.entries[key] ?? keys.toggles[key], i: pos }))
+		return e
+	}
+	return Ok(true)
+}

package/src/internal/errorTextAdd.ts

@@ -0,0 +1,18 @@
+import { crop } from "@alanscodelog/utils/crop"
+import { indent } from "@alanscodelog/utils/indent"
+
+
+export function errorTextAdd(
+	type: "Key" | "Shortcut" | "Command",
+	existingIdentifier: string,
+	existingEntry: string,
+	newEntry: string
+): string {
+	return crop`
+		${type} ${existingIdentifier} is already registered.
+			Existing ${type}:
+			${indent(existingEntry.toString(), 3)}
+			New ${type}:
+			${indent(newEntry.toString(), 3)}
+		`
+}

package/src/internal/errorTextInUse.ts

@@ -0,0 +1,10 @@
+import { crop } from "@alanscodelog/utils/crop"
+import { indent } from "@alanscodelog/utils/indent"
+
+
+export function errorTextInUse(type: "command" | "key", identifier: string, list: string): string {
+	return crop`
+		Cannot remove ${type} ${identifier}, it is in use by the following shortcuts:
+		${indent(list, 2)}
+	`
+}

package/src/internal/errorTextRemove.ts

@@ -0,0 +1,10 @@
+import { crop } from "@alanscodelog/utils/crop"
+import { indent } from "@alanscodelog/utils/indent"
+
+
+export function errorTextRemove(type: string, identifier: string, entries: string): string {
+	return crop`
+		${type} ${identifier} does not exist in entries:
+			${indent(entries, 3)}
+		`
+}

package/src/internal/getModifierState.ts

@@ -0,0 +1,15 @@
+import type { AnyInputEvent, Key, PickManager } from "../types/index.js"
+
+
+export function getModifierState(
+	key: Key,
+	e: AnyInputEvent,
+	manager: PickManager<"options", "updateStateOnAllEvents">
+): boolean | null {
+	if (!manager.options.updateStateOnAllEvents || !key.updateStateOnAllEvents) return null
+	for (const code of [key.id, ...key.variants ?? []]) {
+		if ("getModifierState" in e && e.getModifierState(code)) return true
+	}
+	return false
+}
+

package/src/internal/getPressedKeys.ts

@@ -0,0 +1,26 @@
+import type { Manager } from "../types/index.js"
+
+/**
+ * A list of currently pressed keys for convenience.
+ *
+ * It's just a wrapper around querying the key set for pressed keys.
+ */
+export function getPressedKeys(manager: Pick<Manager, "keys">): string[] {
+	const res: string[] = []
+	for (const keyId of Object.keys(manager.keys.entries)) {
+		const key = manager.keys.entries[keyId]
+		if (key.pressed) {
+			res.push(key.id)
+		}
+		if (key.isToggle) {
+			if (key.toggleOnPressed) {
+				res.push(key.toggleOnId)
+			}
+			if (key.toggleOffPressed) {
+				res.push(key.toggleOffId)
+			}
+		}
+	}
+	return res
+}
+

package/src/internal/getPressedModifierKeys.ts

@@ -0,0 +1,14 @@
+import type { Manager } from "../types/index.js"
+
+
+export function getPressedModifierKeys(manager: Pick<Manager, "keys">): string[] {
+	const res: string[] = []
+	for (const keyId of Object.keys(manager.keys.entries)) {
+		const key = manager.keys.entries[keyId]
+		if (key.pressed && key.isModifier) {
+			res.push(key.id)
+		}
+	}
+	return res
+}
+

package/src/internal/getPressedNonModifierKeys.ts

@@ -0,0 +1,19 @@
+import type { Manager } from "../types/index.js"
+import { isTriggerKey } from "../utils/isTriggerKey.js"
+
+/**
+ * A list of currently pressed non-modifier keys. They can't be toggle state keys (i.e. `on`/`off`) either.
+ *
+ * This determines whether when we await keyup and when a new chord should be added.
+ */
+export function getPressedNonModifierKeys(manager: Pick<Manager, "keys">): string[] {
+	const res: string[] = []
+	for (const keyId of Object.keys(manager.keys.entries)) {
+		const key = manager.keys.entries[keyId]
+		if (key.pressed && isTriggerKey(manager.keys.entries[keyId])) {
+			res.push(key.id)
+		}
+	}
+	return res
+}
+

package/src/internal/inChain.ts

@@ -0,0 +1,25 @@
+import { shortcutCanExecuteIn } from "../helpers/shortcutCanExecuteIn.js"
+import type { Manager } from "../types/index.js"
+import { equalsKeys } from "../utils/equalsKeys.js"
+
+
+/**
+	* Returns true if there are shortcuts that could be executed given the state of the manager's chain. That is, except if {@link Manager.isAwaitingKeyup} is true, in which case it returns false.
+ */
+export function inChain(manager: Manager): boolean {
+	if (manager.state.isAwaitingKeyup) return false
+	const shortcuts = manager.shortcuts.entries.filter(shortcut => (
+		shortcutCanExecuteIn(shortcut, manager, { allowEmptyCommand: true })
+		&& manager.state.chain.length < shortcut.chain.length
+		&& equalsKeys(
+			shortcut.chain,
+			manager.state.chain,
+			manager.keys,
+			manager.state.chain.length,
+			{ allowVariants: true }
+		)
+	))
+	if (!shortcuts) return false
+	return shortcuts.length > 0
+}
+

package/src/internal/isValidChain.ts

@@ -0,0 +1,42 @@
+import { Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { areValidKeys } from "./areValidKeys.js"
+import { containsPossibleToggleChords } from "./containsPossibleToggleChords.js"
+import { isValidChord } from "./isValidChord.js"
+
+import type { ChainError, Manager, MultipleErrors, PickManager } from "../types/index.js"
+
+
+/**
+ * Guards against invalid chains (for various reasons). See the {@link ChainError}.
+ *
+ * Checks {@link areValidKeys}, {@link isValidChord} and {@link containsPossibleToggleChords}
+ *
+ * @internal
+ */
+export function isValidChain(
+	chain: string[][],
+	manager: Pick<Manager, "keys"> & PickManager<"options", "stringifier" | "sorter">
+): Result<true,
+	MultipleErrors<ChainError>
+> {
+	const sorter = manager.options.sorter
+
+	if ((chain.length === 0) || (chain.length === 1 && chain[0].length === 0)) {
+		return Ok(true)
+	}
+
+	const resIsValid = areValidKeys(chain, manager)
+	if (resIsValid.isError) return resIsValid
+
+	const val = []
+	for (let i = 0; i < chain.length; i++) {
+		const chord = chain[i]
+		const res = isValidChord(chain, chord, i, manager)
+		if (res.isError) return res
+		val.push(sorter.sort([...chord], manager.keys))
+	}
+	const res = containsPossibleToggleChords(chain, manager)
+	if (res.isError) return res
+	return Ok(true)
+}

package/src/internal/isValidChord.ts

@@ -0,0 +1,87 @@
+import { crop } from "@alanscodelog/utils/crop"
+import { findDuplicates } from "@alanscodelog/utils/findDuplicates"
+import { indent } from "@alanscodelog/utils/indent"
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { getKeyFromIdOrVariant } from "../helpers/getKeyFromIdOrVariant.js"
+import { KnownError } from "../helpers/KnownError.js"
+import { type Manager, type PickManager, SHORTCUT_ERROR } from "../types/index.js"
+import { isTriggerKey } from "../utils/isTriggerKey.js"
+import { isWheelKey } from "../utils/isWheelKey.js"
+
+
+/**
+ * Guards against invalid chords (for various reasons). See the {@link ERROR}.CHORD_W_... errors.
+ *
+ * Does not check if the keys are valid.
+ *
+ * @internal
+ */
+export function isValidChord(
+	chain: string[][],
+	chord: string[],
+	i: number,
+	manager: Pick<Manager, "keys"> & PickManager<"options", "stringifier" | "sorter">
+): Result<true, KnownError<typeof SHORTCUT_ERROR.CHORD_W_DUPLICATE_KEY | typeof SHORTCUT_ERROR.CHORD_W_ONLY_MODIFIERS | typeof SHORTCUT_ERROR.CHORD_W_MULTIPLE_TRIGGER_KEYS | typeof SHORTCUT_ERROR.CHORD_W_MULTIPLE_WHEEL_KEYS>> {
+	const keys = manager.keys
+	const s = manager.options.stringifier
+
+	const prettyChord = s.stringify(chord, manager)
+	const prettyChain = s.stringify(chain, manager)
+
+	const repeated = findDuplicates(chord, { equals: (id, otherId) => {
+		const key = getKeyFromIdOrVariant(id, keys).unwrap()[0]
+		const other = getKeyFromIdOrVariant(otherId, keys).unwrap()[0]
+		if (key.id === other.id) return true
+		if (key.variants?.includes(other.id) || other.variants?.includes(key.id)) return true
+		// this is caught by multiple wheel key error
+		if (isWheelKey(key) && isWheelKey(other)) return false
+		return false
+	} })
+	if (repeated.length > 0) {
+		const prettyRepeated = s.stringifyList("keys", repeated, manager)
+
+		return Err(new KnownError(SHORTCUT_ERROR.CHORD_W_DUPLICATE_KEY, crop`
+			Chord "${prettyChord}" in chain "${prettyChain}" contains duplicate or incompatible keys:
+				${indent(prettyRepeated, 4)}
+			Chords cannot contain duplicate keys. This includes more than one of the same toggle, regardless of the state.
+		`, { chord, i, keys: repeated }))
+	}
+
+	const onlyModifiers = chord.filter(id => (getKeyFromIdOrVariant(id, keys).unwrap()[0]).isModifier)
+	const containsOnlyModifiers = onlyModifiers.length === chord.length
+	if (i < chain.length - 1 && containsOnlyModifiers) {
+		return Err(new KnownError(SHORTCUT_ERROR.CHORD_W_ONLY_MODIFIERS, crop`
+			Chain "${prettyChain}" is impossible.
+			Chord #${i + 1} "${prettyChord}" cannot contain only modifiers if it is followed by another chord.
+			A chord can only consist of only modifiers if it's the last chord in a chain.
+		`, { chord, i, keys: onlyModifiers }))
+	}
+
+	/* It might actually be possible to allow this, similar to how emulated toggle keys are handled but it would be a pain for such an odd use case (even I don't have such weird shortcuts). */
+	const wheelKeys = chord.filter(id => isWheelKey(getKeyFromIdOrVariant(id, keys).unwrap()[0]))
+	const prettyWheelKeys = s.stringifyList("keys", wheelKeys, manager)
+
+	if (wheelKeys.length > 1) {
+		return Err(new KnownError(SHORTCUT_ERROR.CHORD_W_MULTIPLE_WHEEL_KEYS, crop`
+			Chain "${prettyChain}" is impossible.
+			Chord #${i + 1} "${prettyChord}" contains multiple wheel keys: ${prettyWheelKeys}
+			Chords can only contain one.
+		`, { chord, i, keys: wheelKeys }))
+	}
+	// todo remove this limitation
+	// we should be able to have shortcuts like holding down both mouse buttons
+	// note it's fine to not check key.toggles in isTriggerKey because a trigger key cannot be a toggle *state* anyways
+	const triggerKeys = chord.filter(id => isTriggerKey(getKeyFromIdOrVariant(id, keys).unwrap()[0]))
+	const prettyTriggerKeys = s.stringifyList("keys", triggerKeys, manager)
+	if (triggerKeys.length > 1) {
+		return Err(new KnownError(SHORTCUT_ERROR.CHORD_W_MULTIPLE_TRIGGER_KEYS, crop`
+			Chain "${prettyChain}" is impossible.
+			Chord #${i + 1} "${prettyChord}" contains multiple trigger (non-modifier/non-root toggle) keys: ${prettyTriggerKeys}
+			Chords can only contain one.
+		`, { chord, i, keys: triggerKeys }))
+	}
+
+
+	return Ok(true)
+}

package/src/internal/isValidCommand.ts

@@ -0,0 +1,35 @@
+import { crop } from "@alanscodelog/utils/crop"
+import { indent } from "@alanscodelog/utils/indent"
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { KnownError } from "../helpers/KnownError.js"
+import type { Manager, MultipleErrors, PickManager, Shortcut } from "../types/index.js"
+import { SHORTCUT_ERROR } from "../types/index.js"
+
+/**
+ * @internal
+ */
+
+export function isValidCommand(
+	commandName: string | undefined,
+	manager: Pick<Manager, "commands"> & Partial<Pick<Manager, "keys">> & PickManager<"options", "stringifier">,
+	/**
+	 * Shortcut will only be added to error if the manager contains keys.
+	 * Otherwise it will be ignored.
+	 */
+	shortcut?: Shortcut
+): Result<true, MultipleErrors<typeof SHORTCUT_ERROR.UNKNOWN_COMMAND>> {
+	const commands = manager.commands
+	const s = manager.options.stringifier
+	if (commandName === undefined) return Ok(true)
+	const command = commands.entries[commandName]
+	if (command === undefined) {
+		const shortcutString = shortcut && "keys" in manager ? ` in shortcut ${s.stringify(shortcut, manager as Pick<Manager, "commands" | "keys">)}` : ""
+		return Err(new KnownError(SHORTCUT_ERROR.UNKNOWN_COMMAND, crop`
+			Unknown command: ${commandName}${shortcutString}. Cannot find in:
+
+			${indent(s.stringifyList("commands", Object.values(commands.entries)), 3)}
+			`, { command: commandName, commands, shortcut }))
+	}
+	return Ok(true)
+}

package/src/internal/keyOrder.ts

@@ -0,0 +1,24 @@
+import type { Key, KEY_SORT_POS, KeySortPos } from "../types/index.js"
+import { isMouseKey } from "../utils/isMouseKey.js"
+import { isWheelKey } from "../utils/isWheelKey.js"
+
+
+/**
+	*
+ * Determines the key order position based on a key's type and the given {@link KeySortPos}
+ */
+export function keyOrder(
+	key: Key,
+	dictOrEnum: KeySortPos
+): number {
+	let type = [
+		key.isModifier ? "mod" : "",
+		key.isToggle ? "toggle" : "",
+		isMouseKey(key) ? "mouse" : "",
+		isWheelKey(key) ? "wheel" : ""
+	].join("")
+	if (type === "") {
+		type = "normal"
+	}
+	return dictOrEnum[type as keyof typeof KEY_SORT_POS]
+}

package/src/internal/removeFromChain.ts

@@ -0,0 +1,46 @@
+import { Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { checkTrigger } from "./checkTrigger.js"
+import { checkUntrigger } from "./checkUntrigger.js"
+import { cloneLastChord } from "./cloneLastChord.js"
+import { getPressedNonModifierKeys } from "./getPressedNonModifierKeys.js"
+
+import { setManagerProp } from "../core/setManagerProp.js"
+import type { AnyInputEvent, Manager, ManagerSetEntries, MultipleErrors } from "../types/index.js"
+import { cloneChain } from "../utils/cloneChain.js"
+
+
+export function removeFromChain(
+	manager: Manager,
+	keys: string[],
+	e?: AnyInputEvent
+): Result<true, MultipleErrors<ManagerSetEntries["state.chain"]["error"]>> {
+	if (keys.length === 0) return Ok(true)
+	if (manager.state.isAwaitingKeyup) {
+		checkUntrigger(manager, e)
+		if (getPressedNonModifierKeys(manager).length === 0) {
+			setManagerProp(manager, "state.isAwaitingKeyup", false)
+		}
+	}
+
+	if (manager.state.nextIsChord) return Ok(true)
+	const lastChord = cloneLastChord(manager.state.chain) ?? []
+	for (const id of keys) {
+		const key = manager.keys.entries[id]
+		const i = lastChord.indexOf(key.id)
+
+		if (i > -1) {
+			lastChord.splice(i, 1)
+			const chain = manager.state.chain
+			const precedingChords = chain.slice(0, chain.length - 1)
+			const spreadableLastChord = precedingChords.length === 0 && lastChord.length === 0
+				? []
+				: [lastChord]
+			const res = setManagerProp(manager, "state.chain", cloneChain([...precedingChords, ...spreadableLastChord]))
+			if (res.isError) return res as any
+		}
+	}
+	checkTrigger(manager, e)
+	return Ok(true)
+}
+

package/src/internal/safeSetEmulatedToggleState.ts

@@ -0,0 +1,23 @@
+import { setKeyProp } from "../core/setKeyProp.js"
+import type { Key, KeySetEntries, Manager } from "../types/index.js"
+
+
+export function safeSetEmulatedToggleState<
+	THooks extends Manager["hooks"]
+>(
+	key: Key,
+	value: boolean,
+	manager: KeySetEntries["toggleOnPressed" | "toggleOffPressed"]["manager"] & { hooks?: THooks }
+) {
+	const res = setKeyProp(key, "toggleOnPressed", value, manager, { check: "only" })
+	if (res.isOk) {
+		const res2 = setKeyProp(key, "toggleOffPressed", !value, manager, { check: "only" })
+		if (res2.isOk) {
+			setKeyProp(key, "toggleOnPressed", value, manager, { check: false })
+			setKeyProp(key, "toggleOffPressed", !value, manager, { check: false })
+		}
+		return res2
+	}
+	return res
+}
+

package/src/internal/setKeysState.ts

@@ -0,0 +1,71 @@
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { safeSetEmulatedToggleState } from "./safeSetEmulatedToggleState.js"
+
+import { setKeyProp } from "../core/setKeyProp.js"
+import { KnownError } from "../helpers/KnownError.js"
+import type { CanHookErrors, KeySetEntries, Manager, MultipleErrors } from "../types/index.js"
+import { SHORTCUT_ERROR } from "../types/index.js"
+
+
+export function setKeysState<
+	THooks extends Manager["hooks"]
+>(
+	keysList: string[],
+	manager: KeySetEntries["pressed" | "toggleOnPressed" | "toggleOffPressed"]["manager"] & { hooks?: THooks },
+	state: boolean,
+	{
+		ignoreToggleType = false
+	}: {
+		ignoreToggleType?: boolean
+	} = {}
+): Result<
+	true,
+	| MultipleErrors<
+		| typeof SHORTCUT_ERROR.CANNOT_SET_WHILE_DISABLED
+		| typeof SHORTCUT_ERROR.INCORRECT_TOGGLE_STATE
+	>
+	| CanHookErrors<THooks extends never ? never : THooks, "canSetKeyProp">
+> {
+	const s = manager.options.stringifier
+	for (const id of keysList) {
+		const key = manager.keys.entries[id]
+		const isRoot = id === key.id
+		// this is only for the emulator
+		const isOn = id === key.toggleOnId
+		const isOff = id === key.toggleOffId
+		if ((isRoot && key.pressed === state)
+			|| (isOn && key.toggleOnPressed === state)
+			|| (isOff && key.toggleOffPressed === state)
+		) {
+			continue
+		}
+		const res = setKeyProp(key, "pressed", state, manager)
+		if (res.isError) return res
+		if (isRoot && state) {
+			// toggles are considered active on keydown
+			if ((ignoreToggleType && key.isToggle) || key.isToggle === "emulated") {
+				// state was never set
+				if (key.toggleOnPressed && key.toggleOffPressed) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.INCORRECT_TOGGLE_STATE,
+						`Key ${s.stringify(key, manager)} is a toggle key whose on and off versions are both pressed, which is not a valid state. This should not happen if letting the manager manage the state.`,
+						{ key }
+					))
+				}
+
+				let res
+				if (!key.toggleOnPressed && !key.toggleOffPressed) {
+					res = safeSetEmulatedToggleState(key, true, manager)
+				} else if (key.toggleOnPressed) {
+					res = safeSetEmulatedToggleState(key, false, manager)
+				} else if (key.toggleOffPressed) {
+					res = safeSetEmulatedToggleState(key, true, manager)
+				}
+				if (res?.isError) return res
+			}
+		}
+	}
+	return Ok(true)
+}
+