@syware/jlib 0.0.0-stage → 0.1.3

package/dist/lib/floating.js

@@ -0,0 +1,127 @@
+// src/lib/floating.ts
+var PLACEMENTS = [
+	"top",
+	"top-start",
+	"top-end",
+	"bottom",
+	"bottom-start",
+	"bottom-end",
+	"left",
+	"left-start",
+	"left-end",
+	"right",
+	"right-start",
+	"right-end"
+];
+var OPPOSITE = {
+	bottom: "top",
+	left: "right",
+	right: "left",
+	top: "bottom"
+};
+var VIEWPORT_MARGIN = 8;
+var DEFAULT_GAP = 6;
+var splitPlacement = (placement) => {
+	const [side, align] = placement.split("-");
+	return {
+		align: align ?? "center",
+		side
+	};
+};
+var joinPlacement = (side, align) => align === "center" ? side : `${side}-${align}`;
+var isVertical = (side) => side === "top" || side === "bottom";
+/** Where the floating element starts along the anchor's edge: its start, its centre, or its end. */
+function alignedOffset(start, anchorLength, floatingLength, align) {
+	return {
+		center: start + (anchorLength - floatingLength) / 2,
+		end: start + anchorLength - floatingLength,
+		start
+	}[align];
+}
+function pointFor(anchor, floating, side, align, gap) {
+	const left = alignedOffset(anchor.left, anchor.width, floating.width, align);
+	const top = alignedOffset(anchor.top, anchor.height, floating.height, align);
+	return {
+		bottom: {
+			left,
+			top: anchor.top + anchor.height + gap
+		},
+		left: {
+			left: anchor.left - floating.width - gap,
+			top
+		},
+		right: {
+			left: anchor.left + anchor.width + gap,
+			top
+		},
+		top: {
+			left,
+			top: anchor.top - floating.height - gap
+		}
+	}[side];
+}
+/** How much of the floating element would leave the window on its main side; 0 when it fits. */
+function overflowOn(point, floating, viewport, side) {
+	const overflows = {
+		bottom: point.top + floating.height - (viewport.height - VIEWPORT_MARGIN),
+		left: VIEWPORT_MARGIN - point.left,
+		right: point.left + floating.width - (viewport.width - VIEWPORT_MARGIN),
+		top: VIEWPORT_MARGIN - point.top
+	};
+	return Math.max(0, overflows[side]);
+}
+var clamp = (value, min, max) => Math.min(Math.max(value, min), Math.max(min, max));
+/**
+* Where to put a floating element next to its anchor, in window coordinates: on the asked side when it fits,
+* otherwise on the opposite side if that leaves more of it visible; then kept inside the window.
+*/
+function computePosition(anchor, floating, viewport, placement, gap = DEFAULT_GAP) {
+	const { side, align } = splitPlacement(placement);
+	const wanted = pointFor(anchor, floating, side, align, gap);
+	const flipped = pointFor(anchor, floating, OPPOSITE[side], align, gap);
+	const wantedOverflow = overflowOn(wanted, floating, viewport, side);
+	const flippedOverflow = overflowOn(flipped, floating, viewport, OPPOSITE[side]);
+	const useFlipped = wantedOverflow > 0 && flippedOverflow < wantedOverflow;
+	const finalSide = useFlipped ? OPPOSITE[side] : side;
+	const point = useFlipped ? flipped : wanted;
+	const maxLeft = viewport.width - floating.width - VIEWPORT_MARGIN;
+	const maxTop = viewport.height - floating.height - VIEWPORT_MARGIN;
+	return {
+		left: isVertical(finalSide) ? clamp(point.left, VIEWPORT_MARGIN, maxLeft) : point.left,
+		placement: joinPlacement(finalSide, align),
+		top: isVertical(finalSide) ? point.top : clamp(point.top, VIEWPORT_MARGIN, maxTop)
+	};
+}
+/** Puts a fixed-position element next to its anchor; returns the placement it got after flipping. */
+function placeFloating(anchor, floating, placement, gap) {
+	const rect = anchor.getBoundingClientRect();
+	const viewport = {
+		height: window.innerHeight,
+		width: document.documentElement.clientWidth
+	};
+	const result = computePosition(rect, {
+		height: floating.offsetHeight,
+		width: floating.offsetWidth
+	}, viewport, placement, gap);
+	floating.style.left = `${Math.round(result.left)}px`;
+	floating.style.top = `${Math.round(result.top)}px`;
+	floating.dataset.placement = result.placement;
+	return result.placement;
+}
+/** Keeps a floating element by its anchor while the page scrolls or resizes, until the signal aborts. */
+function followAnchor(anchor, floating, placement, signal, gap) {
+	const update = () => {
+		placeFloating(anchor, floating, placement, gap);
+	};
+	window.addEventListener("scroll", update, {
+		capture: true,
+		passive: true,
+		signal
+	});
+	window.addEventListener("resize", update, {
+		passive: true,
+		signal
+	});
+	update();
+}
+export { PLACEMENTS, computePosition, followAnchor, placeFloating };

package/dist/lib/fuzzy.d.ts

@@ -0,0 +1,26 @@
+import type { FuzzyMatch, TextSegment } from '../types/fuzzy.types';
+/**
+ * What a matched letter is worth. Letters next to each other and letters that start a word count most, so "ofi"
+ * finds "Open file" before "Profile", and "set" puts "Settings" before "Reset".
+ */
+export declare const FUZZY_SCORE: {
+    /** A letter right after the previous matched one. */
+    readonly contiguous: 6;
+    /** Taken off for each letter skipped between two matched ones. */
+    readonly gap: 1;
+    /** Each matched letter. */
+    readonly match: 1;
+    /** The text's very first letter, on top of the word start. */
+    readonly textStart: 4;
+    /** A letter that starts a word: after a space, a dash, a slash…, or a capital in camelCase. */
+    readonly wordStart: 8;
+};
+/** Whether the letter at `index` starts a word of the text. */
+export declare function isWordStart(text: string, index: number): boolean;
+/**
+ * Whether the letters of the query appear in the text in order (spaces ignored, any case), and how well: the
+ * best placement by contiguity and word starts. `null` when they do not; an empty query matches with 0.
+ */
+export declare function fuzzyMatch(query: string, text: string): FuzzyMatch | null;
+/** The text cut into runs of matched and unmatched letters, for drawing the matches in `<mark>`. */
+export declare function highlightSegments(text: string, positions: readonly number[]): TextSegment[];

package/dist/lib/fuzzy.js

@@ -0,0 +1,149 @@
+// src/lib/fuzzy.ts
+/**
+* What a matched letter is worth. Letters next to each other and letters that start a word count most, so "ofi"
+* finds "Open file" before "Profile", and "set" puts "Settings" before "Reset".
+*/
+var FUZZY_SCORE = {
+	/** A letter right after the previous matched one. */
+	contiguous: 6,
+	/** Taken off for each letter skipped between two matched ones. */
+	gap: 1,
+	/** Each matched letter. */
+	match: 1,
+	/** The text's very first letter, on top of the word start. */
+	textStart: 4,
+	/** A letter that starts a word: after a space, a dash, a slash…, or a capital in camelCase. */
+	wordStart: 8
+};
+var NO_MATCH = Number.NEGATIVE_INFINITY;
+var NO_INDEX = -1;
+var WHITESPACE = /\s+/g;
+var SEPARATORS = /* @__PURE__ */ new Set([
+	" ",
+	"-",
+	"_",
+	"/",
+	".",
+	":",
+	"(",
+	"[",
+	"\\"
+]);
+var isLower = (char) => char !== char.toUpperCase() && char === char.toLowerCase();
+var isUpper = (char) => char !== char.toLowerCase() && char === char.toUpperCase();
+/** Whether the letter at `index` starts a word of the text. */
+function isWordStart(text, index) {
+	if (index === 0) return true;
+	const previous = text[index - 1] ?? "";
+	const current = text[index] ?? "";
+	return SEPARATORS.has(previous) || isLower(previous) && isUpper(current);
+}
+function positionBonus(text, index) {
+	const wordStart = isWordStart(text, index) ? FUZZY_SCORE.wordStart : 0;
+	const textStart = index === 0 ? FUZZY_SCORE.textStart : 0;
+	return FUZZY_SCORE.match + wordStart + textStart;
+}
+function firstRow(letter, haystack, text) {
+	const scores = new Float64Array(haystack.length).fill(NO_MATCH);
+	for (const [index, char] of haystack.entries()) if (char === letter) scores[index] = positionBonus(text, index);
+	return {
+		from: new Int32Array(haystack.length).fill(NO_INDEX),
+		scores
+	};
+}
+/**
+* The best score of each place for the next letter, knowing the previous row. A gapped step costs `gap` per
+* skipped letter: the best gapped predecessor is kept as a running maximum, so a row costs one pass.
+*/
+function nextRow(previous, letter, haystack, text) {
+	const scores = new Float64Array(haystack.length).fill(NO_MATCH);
+	const from = new Int32Array(haystack.length).fill(NO_INDEX);
+	const gapped = {
+		index: NO_INDEX,
+		value: NO_MATCH
+	};
+	for (const [index, char] of haystack.entries()) {
+		const candidate = index - 2;
+		const candidateValue = candidate >= 0 ? (previous.scores[candidate] ?? NO_MATCH) + FUZZY_SCORE.gap * candidate : NO_MATCH;
+		if (candidateValue > gapped.value) {
+			gapped.value = candidateValue;
+			gapped.index = candidate;
+		}
+		if (char !== letter) continue;
+		const contiguous = index >= 1 ? (previous.scores[index - 1] ?? NO_MATCH) + FUZZY_SCORE.contiguous : NO_MATCH;
+		const afterGap = gapped.value - FUZZY_SCORE.gap * (index - 1);
+		const best = Math.max(contiguous, afterGap);
+		if (best === NO_MATCH) continue;
+		scores[index] = best + positionBonus(text, index);
+		from[index] = contiguous >= afterGap ? index - 1 : gapped.index;
+	}
+	return {
+		from,
+		scores
+	};
+}
+function bestEnd(row) {
+	const best = {
+		index: NO_INDEX,
+		value: NO_MATCH
+	};
+	for (const [index, value] of row.scores.entries()) if (value > best.value) {
+		best.value = value;
+		best.index = index;
+	}
+	return best.index;
+}
+function backtrack(rows, end) {
+	const positions = [];
+	const cursor = { index: end };
+	for (const row of [...rows].reverse()) {
+		positions.unshift(cursor.index);
+		cursor.index = row.from[cursor.index] ?? NO_INDEX;
+	}
+	return positions;
+}
+/**
+* Whether the letters of the query appear in the text in order (spaces ignored, any case), and how well: the
+* best placement by contiguity and word starts. `null` when they do not; an empty query matches with 0.
+*/
+function fuzzyMatch(query, text) {
+	const needle = query.replace(WHITESPACE, "").toLowerCase().split("");
+	const haystack = text.split("").map((char) => char.toLowerCase());
+	const [first, ...rest] = needle;
+	if (first === void 0) return {
+		positions: [],
+		score: 0
+	};
+	if (needle.length > haystack.length) return null;
+	const rows = [firstRow(first, haystack, text)];
+	for (const letter of rest) {
+		const previous = rows[rows.length - 1];
+		rows.push(nextRow(previous, letter, haystack, text));
+	}
+	const last = rows[rows.length - 1];
+	const end = bestEnd(last);
+	if (end === NO_INDEX) return null;
+	return {
+		positions: backtrack(rows, end),
+		score: last.scores[end] ?? 0
+	};
+}
+/** The text cut into runs of matched and unmatched letters, for drawing the matches in `<mark>`. */
+function highlightSegments(text, positions) {
+	const matched = new Set(positions);
+	const segments = [];
+	for (const [index, char] of text.split("").entries()) {
+		const marked = matched.has(index);
+		const last = segments[segments.length - 1];
+		if (last !== void 0 && last.marked === marked) {
+			last.text += char;
+			continue;
+		}
+		segments.push({
+			marked,
+			text: char
+		});
+	}
+	return segments;
+}
+export { FUZZY_SCORE, fuzzyMatch, highlightSegments, isWordStart };

package/dist/lib/highlight.d.ts

@@ -0,0 +1,5 @@
+import type { CodeLanguage, Token } from '../types/highlight.types';
+/** Splits source code into coloured tokens. Small and forgiving: it draws code, it does not parse it. */
+export declare function tokenize(code: string, language: CodeLanguage): Token[];
+/** The tokens as spans with a `tok-<kind>` class each; plain text stays a text node. */
+export declare function highlightedNodes(code: string, language: CodeLanguage): Node[];

package/dist/lib/highlight.js

@@ -0,0 +1,267 @@
+// src/lib/highlight.ts
+var TS_KEYWORDS = [
+	"as",
+	"async",
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"from",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"new",
+	"null",
+	"of",
+	"private",
+	"protected",
+	"public",
+	"readonly",
+	"return",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"type",
+	"typeof",
+	"undefined",
+	"var",
+	"void",
+	"while"
+];
+var sticky = (source) => new RegExp(source, "y");
+var QUOTED_STRING = String.raw`'(?:\\.|[^'\\\n])*'|"(?:\\.|[^"\\\n])*"`;
+var TEMPLATE_STRING = String.raw`\`(?:\\.|[^\`\\])*\``;
+var TS_RULES = [
+	{
+		kind: "comment",
+		pattern: sticky(String.raw`\/\/[^\n]*|\/\*[\s\S]*?\*\/`)
+	},
+	{
+		kind: "string",
+		pattern: sticky(`${QUOTED_STRING}|${TEMPLATE_STRING}`)
+	},
+	{
+		kind: "tag",
+		pattern: sticky(String.raw`<\/?[A-Za-z][\w.-]*|\/?>`)
+	},
+	{
+		kind: "keyword",
+		pattern: sticky(String.raw`\b(?:${TS_KEYWORDS.join("|")})\b`)
+	},
+	{
+		kind: "number",
+		pattern: sticky(String.raw`\b\d[\d_]*(?:\.\d+)?\b`)
+	},
+	{
+		kind: "function",
+		pattern: sticky(String.raw`[A-Za-z_$][\w$]*(?=\s*\()`)
+	},
+	{
+		kind: "attribute",
+		pattern: sticky(String.raw`[A-Za-z_$][\w$-]*(?==[{"'])`)
+	},
+	{
+		kind: "plain",
+		pattern: sticky(String.raw`[A-Za-z_$][\w$]*`)
+	},
+	{
+		kind: "punctuation",
+		pattern: sticky(String.raw`[{}()[\];,.:=<>+\-*/!?&|]`)
+	}
+];
+var CSS_RULES = [
+	{
+		kind: "comment",
+		pattern: sticky(String.raw`\/\*[\s\S]*?\*\/`)
+	},
+	{
+		kind: "string",
+		pattern: sticky(String.raw`'[^'\n]*'|"[^"\n]*"`)
+	},
+	{
+		kind: "keyword",
+		pattern: sticky(String.raw`@[\w-]+|!important`)
+	},
+	{
+		kind: "property",
+		pattern: sticky(String.raw`--[\w-]+|[a-z-]+(?=\s*:[^:])`)
+	},
+	{
+		kind: "number",
+		pattern: sticky(String.raw`#[\da-fA-F]{3,8}\b|-?\d*\.?\d+(?:px|rem|em|%|ms|s|vh|vw|dvh|fr|deg|turn)?\b`)
+	},
+	{
+		kind: "function",
+		pattern: sticky(String.raw`[\w-]+(?=\()`)
+	},
+	{
+		kind: "tag",
+		pattern: sticky(String.raw`:{1,2}[\w-]+|[.#][\w-]+|\b[a-z][\w-]*(?=[^{};]*\{)`)
+	},
+	{
+		kind: "punctuation",
+		pattern: sticky(String.raw`[{}();:,>+~*[\]=]`)
+	}
+];
+var BASH_RULES = [
+	{
+		kind: "comment",
+		pattern: sticky(String.raw`#[^\n]*`)
+	},
+	{
+		kind: "string",
+		pattern: sticky(String.raw`'[^']*'|"(?:\\.|[^"\\])*"`)
+	},
+	{
+		kind: "attribute",
+		pattern: sticky(String.raw`(?<=\s)--?[\w-]+`)
+	},
+	{
+		kind: "function",
+		pattern: sticky(String.raw`(?<=^|\n|&&\s|\|\s)[\w.-]+`)
+	},
+	{
+		kind: "plain",
+		pattern: sticky(String.raw`[^\s'"#]+`)
+	}
+];
+var HTML_RULES = [{
+	kind: "comment",
+	pattern: sticky(String.raw`<!--[\s\S]*?-->`)
+}, {
+	kind: "tag",
+	pattern: sticky(String.raw`<\/?[A-Za-z][\w-]*`)
+}];
+var HTML_TAG_RULES = [
+	{
+		kind: "string",
+		pattern: sticky(`"[^"]*"|'[^']*'`)
+	},
+	{
+		kind: "attribute",
+		pattern: sticky(String.raw`[^\s=>/"']+`)
+	},
+	{
+		kind: "punctuation",
+		pattern: sticky("=")
+	}
+];
+var SPACE = {
+	kind: "plain",
+	pattern: sticky(String.raw`\s+`)
+};
+var TAG_END = {
+	kind: "tag",
+	pattern: sticky(String.raw`\/?>`)
+};
+function matchAt(rules, code, position) {
+	for (const rule of rules) {
+		rule.pattern.lastIndex = position;
+		const match = rule.pattern.exec(code);
+		if (match !== null && match[0] !== "") return {
+			kind: rule.kind,
+			text: match[0]
+		};
+	}
+	return null;
+}
+/** What no rule matches is plain text, one character at a time. */
+var nextToken = (rules, code, position) => matchAt(rules, code, position) ?? {
+	kind: "plain",
+	text: code.charAt(position)
+};
+/** Joins neighbouring tokens of the same kind, so the result has as few spans as it can. */
+function merge(tokens) {
+	return tokens.reduce((merged, token) => {
+		const last = merged.at(-1);
+		if (last !== void 0 && last.kind === token.kind) {
+			last.text += token.text;
+			return merged;
+		}
+		merged.push({ ...token });
+		return merged;
+	}, []);
+}
+/** Splits code with a flat list of rules. */
+function scan(code, rules) {
+	const withSpace = [SPACE, ...rules];
+	const tokens = [];
+	let position = 0;
+	while (position < code.length) {
+		const token = nextToken(withSpace, code, position);
+		tokens.push(token);
+		position += token.text.length;
+	}
+	return merge(tokens);
+}
+var OUTSIDE_TAG = [SPACE, ...HTML_RULES];
+var INSIDE_TAG = [
+	TAG_END,
+	SPACE,
+	...HTML_TAG_RULES
+];
+/** HTML needs two states: outside a tag (text, comments, tag names) and inside one (attributes). */
+function scanHtml(code) {
+	const tokens = [];
+	let position = 0;
+	let insideTag = false;
+	while (position < code.length) {
+		const token = nextToken(insideTag ? INSIDE_TAG : OUTSIDE_TAG, code, position);
+		insideTag = isInsideTagAfter(token, insideTag);
+		tokens.push(token);
+		position += token.text.length;
+	}
+	return merge(tokens);
+}
+/** A tag name opens a tag, `>` or `/>` closes it; any other token leaves the state as it was. */
+function isInsideTagAfter(token, insideTag) {
+	if (token.kind !== "tag") return insideTag;
+	return token.text.startsWith("<");
+}
+var SCANNERS = {
+	bash: (code) => scan(code, BASH_RULES),
+	css: (code) => scan(code, CSS_RULES),
+	html: scanHtml,
+	text: (code) => [{
+		kind: "plain",
+		text: code
+	}],
+	ts: (code) => scan(code, TS_RULES)
+};
+/** Splits source code into coloured tokens. Small and forgiving: it draws code, it does not parse it. */
+function tokenize(code, language) {
+	if (code === "") return [];
+	return SCANNERS[language](code);
+}
+/** The tokens as spans with a `tok-<kind>` class each; plain text stays a text node. */
+function highlightedNodes(code, language) {
+	return tokenize(code, language).map((token) => {
+		if (token.kind === "plain") return document.createTextNode(token.text);
+		const span = document.createElement("span");
+		span.className = `tok-${token.kind}`;
+		span.textContent = token.text;
+		return span;
+	});
+}
+export { highlightedNodes, tokenize };

package/dist/lib/hotkey.d.ts

@@ -0,0 +1,9 @@
+import type { Hotkey, KeyPress } from '../types/hotkey.types';
+/** Reads a combination such as `mod+k` or `ctrl+shift+p`: `mod` is ⌘ on Apple and Ctrl elsewhere. */
+export declare function parseHotkey(text: string): Hotkey;
+/** Whether a key press is the combination; extra modifiers make it another one. */
+export declare function matchesHotkey(press: KeyPress, hotkey: Hotkey, apple: boolean): boolean;
+/** The keycaps of a combination, modifiers first: `['⌘', 'K']` on a Mac, `['Ctrl', 'K']` elsewhere. */
+export declare function hotkeyLabels(text: string, apple: boolean): string[];
+/** Whether the keyboard has ⌘: Macs, iPhones and iPads. */
+export declare function isApplePlatform(platform: string): boolean;

package/dist/lib/hotkey.js

@@ -0,0 +1,101 @@
+// src/lib/hotkey.ts
+var SEPARATOR = "+";
+var MODIFIER_NAMES = {
+	alt: "alt",
+	cmd: "meta",
+	command: "meta",
+	control: "ctrl",
+	ctrl: "ctrl",
+	meta: "meta",
+	mod: "mod",
+	option: "alt",
+	shift: "shift"
+};
+/** How each modifier reads on a keycap, on Apple keyboards and elsewhere. */
+var MODIFIER_LABELS = {
+	alt: {
+		apple: "⌥",
+		other: "Alt"
+	},
+	ctrl: {
+		apple: "⌃",
+		other: "Ctrl"
+	},
+	meta: {
+		apple: "⌘",
+		other: "Win"
+	},
+	mod: {
+		apple: "⌘",
+		other: "Ctrl"
+	},
+	shift: {
+		apple: "⇧",
+		other: "Shift"
+	}
+};
+/** The order keycaps are written in: ⌃⌥⇧⌘ on Apple, Ctrl+Alt+Shift elsewhere. */
+var MODIFIER_ORDER = {
+	apple: [
+		"ctrl",
+		"alt",
+		"shift",
+		"mod",
+		"meta"
+	],
+	other: [
+		"mod",
+		"ctrl",
+		"alt",
+		"shift",
+		"meta"
+	]
+};
+var KEY_LABELS = {
+	arrowdown: "↓",
+	arrowleft: "←",
+	arrowright: "→",
+	arrowup: "↑",
+	backspace: "⌫",
+	enter: "↵",
+	esc: "Esc",
+	escape: "Esc",
+	space: "Space",
+	tab: "Tab"
+};
+/** Reads a combination such as `mod+k` or `ctrl+shift+p`: `mod` is ⌘ on Apple and Ctrl elsewhere. */
+function parseHotkey(text) {
+	const parts = text.toLowerCase().split(SEPARATOR).map((part) => part.trim()).filter((part) => part !== "");
+	const modifiers = new Set(parts.map((part) => MODIFIER_NAMES[part]).filter((name) => name !== void 0));
+	const key = parts.filter((part) => MODIFIER_NAMES[part] === void 0).at(-1) ?? "";
+	return {
+		alt: modifiers.has("alt"),
+		ctrl: modifiers.has("ctrl"),
+		key,
+		meta: modifiers.has("meta"),
+		mod: modifiers.has("mod"),
+		shift: modifiers.has("shift")
+	};
+}
+/** Whether a key press is the combination; extra modifiers make it another one. */
+function matchesHotkey(press, hotkey, apple) {
+	if (hotkey.key === "" || press.key.toLowerCase() !== hotkey.key) return false;
+	const wantsCtrl = hotkey.ctrl || hotkey.mod && !apple;
+	const wantsMeta = hotkey.meta || hotkey.mod && apple;
+	return press.ctrlKey === wantsCtrl && press.metaKey === wantsMeta && press.shiftKey === hotkey.shift && press.altKey === hotkey.alt;
+}
+function keyLabel(key) {
+	return KEY_LABELS[key] ?? (key.length === 1 ? key.toUpperCase() : key.charAt(0).toUpperCase() + key.slice(1));
+}
+/** The keycaps of a combination, modifiers first: `['⌘', 'K']` on a Mac, `['Ctrl', 'K']` elsewhere. */
+function hotkeyLabels(text, apple) {
+	const hotkey = parseHotkey(text);
+	const platform = apple ? "apple" : "other";
+	const modifiers = MODIFIER_ORDER[platform].filter((modifier) => hotkey[modifier]).map((modifier) => MODIFIER_LABELS[modifier][platform]);
+	return hotkey.key === "" ? modifiers : [...modifiers, keyLabel(hotkey.key)];
+}
+/** Whether the keyboard has ⌘: Macs, iPhones and iPads. */
+function isApplePlatform(platform) {
+	return /mac|iphone|ipad|ipod/i.test(platform);
+}
+export { hotkeyLabels, isApplePlatform, matchesHotkey, parseHotkey };