@enigmax/primitives 0.25.0 → 0.26.0

package/dist/chunk-QIIV2QSV.js

@@ -0,0 +1,108 @@
+// src/core/image-viewer.ts
+var IDENTITY = { scale: 1, x: 0, y: 0 };
+var ZOOM_LIMITS = { min: 1, max: 8 };
+var ZOOM_STEP = 1.35;
+var ZOOM_DOUBLE = 2.5;
+function clampScale(scale, limits = ZOOM_LIMITS) {
+  return Math.min(Math.max(scale, limits.min), limits.max);
+}
+function wheelFactor(deltaY, deltaMode = 0) {
+  const pixels = deltaMode === 1 ? deltaY * 16 : deltaMode === 2 ? deltaY * 400 : deltaY;
+  return Math.exp(-Math.min(Math.max(pixels, -240), 240) / 320);
+}
+function zoomAt(current, factor, point, box, limits = ZOOM_LIMITS) {
+  const scale = clampScale(current.scale * factor, limits);
+  if (scale === current.scale) return current;
+  const dx = point.x - (box.left + box.width / 2);
+  const dy = point.y - (box.top + box.height / 2);
+  const ratio = scale / current.scale;
+  return { scale, x: dx - (dx - current.x) * ratio, y: dy - (dy - current.y) * ratio };
+}
+function clampPan(transform, box, natural) {
+  const width = natural.width * transform.scale;
+  const height = natural.height * transform.scale;
+  const x = Math.max(0, (width - box.width) / 2);
+  const y = Math.max(0, (height - box.height) / 2);
+  return {
+    scale: transform.scale,
+    x: Math.min(Math.max(transform.x, -x), x),
+    y: Math.min(Math.max(transform.y, -y), y)
+  };
+}
+function fittedSize(natural, box) {
+  if (!natural.width || !natural.height) return { width: box.width, height: box.height };
+  const ratio = Math.min(box.width / natural.width, box.height / natural.height, 1);
+  return { width: natural.width * ratio, height: natural.height * ratio };
+}
+function pinchDistance(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function nextIndex(index, length, step, options = {}) {
+  const { loop = true, skip } = options;
+  if (length <= 0) return -1;
+  let next = index;
+  for (let moved = 0; moved < length; moved += 1) {
+    next += step;
+    if (next < 0 || next >= length) {
+      if (!loop) return -1;
+      next = (next % length + length) % length;
+    }
+    if (!skip?.has(next)) return next;
+  }
+  return -1;
+}
+function filenameFrom(url, fallback = "image") {
+  try {
+    const { pathname } = new URL(url, typeof location === "undefined" ? "https://localhost" : location.href);
+    const name = pathname.split("/").filter(Boolean).pop();
+    return name && name.includes(".") ? decodeURIComponent(name) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function downloadFile(url, filename) {
+  const name = filename ?? filenameFrom(url);
+  try {
+    const response = await fetch(url, { mode: "cors", credentials: "omit" });
+    if (!response.ok) throw new Error(`the file answered ${response.status}`);
+    const blob = await response.blob();
+    const href = URL.createObjectURL(blob);
+    saveAs(href, name);
+    setTimeout(() => URL.revokeObjectURL(href), 1e4);
+  } catch {
+    saveAs(url, name, true);
+  }
+}
+function saveAs(href, name, external = false) {
+  if (typeof document === "undefined") return;
+  const anchor = document.createElement("a");
+  anchor.href = href;
+  anchor.download = name;
+  anchor.rel = "noopener";
+  if (external) anchor.target = "_blank";
+  document.body.append(anchor);
+  anchor.click();
+  anchor.remove();
+}
+var FLIGHT_MS = 300;
+function flightMs(element) {
+  if (!element || typeof getComputedStyle === "undefined") return FLIGHT_MS;
+  const seconds = Number.parseFloat(getComputedStyle(element).transitionDuration);
+  return Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : FLIGHT_MS;
+}
+function flightFrom(from, to) {
+  if (!from.width || !from.height || !to.width || !to.height) return null;
+  return {
+    scale: from.width / to.width,
+    // Centre to centre: `translate(x, y) scale(s)` scales about the element's own centre
+    // first, so the offset that lands it on the thumbnail is the distance between them.
+    x: from.left + from.width / 2 - (to.left + to.width / 2),
+    y: from.top + from.height / 2 - (to.top + to.height / 2)
+  };
+}
+function prefersReducedMotion() {
+  if (typeof window === "undefined" || !window.matchMedia) return false;
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+
+export { FLIGHT_MS, IDENTITY, ZOOM_DOUBLE, ZOOM_LIMITS, ZOOM_STEP, clampPan, clampScale, downloadFile, filenameFrom, fittedSize, flightFrom, flightMs, nextIndex, pinchDistance, prefersReducedMotion, wheelFactor, zoomAt };

package/dist/chunk-RUEQ3TGP.js

@@ -0,0 +1,155 @@
+// src/core/player.ts
+var SPEEDS = [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2];
+var SEEK_STEP = 5;
+var SEEK_JUMP = 10;
+var VOLUME_STEP = 0.05;
+function formatTime(seconds, duration = seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) seconds = 0;
+  const total = Math.floor(seconds);
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor(total % 3600 / 60);
+  const rest = total % 60;
+  const withHours = Number.isFinite(duration) && duration >= 3600;
+  const pad = (value) => String(value).padStart(2, "0");
+  if (withHours || hours > 0) return `${hours}:${pad(minutes)}:${pad(rest)}`;
+  return `${minutes}:${pad(rest)}`;
+}
+function progress(time, duration) {
+  if (!Number.isFinite(duration) || duration <= 0) return 0;
+  return Math.min(Math.max(time / duration, 0), 1);
+}
+function fractionAt(box, clientX) {
+  if (!box.width) return 0;
+  return Math.min(Math.max((clientX - box.left) / box.width, 0), 1);
+}
+function bufferedAhead(ranges, time, duration) {
+  if (!ranges || !Number.isFinite(duration) || duration <= 0) return 0;
+  for (let at = 0; at < ranges.length; at += 1) {
+    if (ranges.start(at) <= time && ranges.end(at) >= time) return Math.min(ranges.end(at) / duration, 1);
+  }
+  return 0;
+}
+function nextSpeed(current, step = 1) {
+  const at = SPEEDS.indexOf(current);
+  const from = at === -1 ? SPEEDS.indexOf(1) : at;
+  return SPEEDS[(from + step + SPEEDS.length) % SPEEDS.length];
+}
+function commandFor(key) {
+  if (key === " " || key === "k" || key === "K") return { type: "toggle" };
+  if (key === "ArrowRight") return { type: "seek", by: SEEK_STEP };
+  if (key === "ArrowLeft") return { type: "seek", by: -SEEK_STEP };
+  if (key === "l" || key === "L") return { type: "seek", by: SEEK_JUMP };
+  if (key === "j" || key === "J") return { type: "seek", by: -SEEK_JUMP };
+  if (key === "ArrowUp") return { type: "volume", by: VOLUME_STEP };
+  if (key === "ArrowDown") return { type: "volume", by: -VOLUME_STEP };
+  if (key === "m" || key === "M") return { type: "mute" };
+  if (key === "f" || key === "F") return { type: "fullscreen" };
+  if (key === "c" || key === "C") return { type: "captions" };
+  if (key === "p" || key === "P") return { type: "pip" };
+  if (key >= "0" && key <= "9") return { type: "seekTo", fraction: Number(key) / 10 };
+  return null;
+}
+function isTypingTarget(target) {
+  const element = target;
+  if (!element || typeof element.tagName !== "string") return false;
+  if (element.isContentEditable) return true;
+  return ["INPUT", "TEXTAREA", "SELECT"].includes(element.tagName);
+}
+function fullscreenElement() {
+  if (typeof document === "undefined") return null;
+  const legacy = document;
+  return document.fullscreenElement ?? legacy.webkitFullscreenElement ?? null;
+}
+async function toggleFullscreen(container, video) {
+  const legacyDocument = document;
+  if (fullscreenElement()) {
+    await (document.exitFullscreen?.() ?? legacyDocument.webkitExitFullscreen?.());
+    return;
+  }
+  const legacyElement = container;
+  if (container.requestFullscreen) return void await container.requestFullscreen();
+  if (legacyElement.webkitRequestFullscreen) return void await legacyElement.webkitRequestFullscreen();
+  const iosVideo = video;
+  iosVideo?.webkitEnterFullscreen?.();
+}
+function supportsPip() {
+  return typeof document !== "undefined" && Boolean(document.pictureInPictureEnabled);
+}
+async function togglePip(video) {
+  if (document.pictureInPictureElement) return void await document.exitPictureInPicture();
+  await video.requestPictureInPicture();
+}
+function captionTracks(list) {
+  if (!list) return [];
+  const found = [];
+  for (let at = 0; at < list.length; at += 1) {
+    const track = list[at];
+    if (!track || track.kind !== "subtitles" && track.kind !== "captions") continue;
+    found.push({ index: at, label: track.label || track.language || `Track ${found.length + 1}`, language: track.language });
+  }
+  return found;
+}
+function activeCaption(list) {
+  if (!list) return -1;
+  for (let at = 0; at < list.length; at += 1) if (list[at]?.mode === "showing") return at;
+  return -1;
+}
+function showCaption(list, index) {
+  if (!list) return;
+  for (let at = 0; at < list.length; at += 1) {
+    const track = list[at];
+    if (track) track.mode = at === index ? "showing" : "disabled";
+  }
+}
+function supportsRemote(video) {
+  const element = video;
+  if (!element || element.disableRemotePlayback) return false;
+  return Boolean(element.remote?.prompt ?? element.webkitShowPlaybackTargetPicker);
+}
+function watchRemote(video, onChange) {
+  const element = video;
+  const state = { available: false, connected: false };
+  const publish = (next) => {
+    Object.assign(state, next);
+    onChange({ ...state });
+  };
+  if (element.remote) {
+    const remote = element.remote;
+    const onState = () => publish({ connected: remote.state === "connected" });
+    let watch = null;
+    let cancelled = false;
+    remote.watchAvailability((available) => {
+      if (!cancelled) publish({ available });
+    }).then((id) => {
+      if (cancelled) void remote.cancelWatchAvailability(id).catch(() => {
+      });
+      else watch = id;
+    }).catch(() => {
+      if (!cancelled) publish({ available: true });
+    });
+    for (const name of ["connect", "connecting", "disconnect"]) remote.addEventListener(name, onState);
+    onState();
+    return () => {
+      cancelled = true;
+      for (const name of ["connect", "connecting", "disconnect"]) remote.removeEventListener(name, onState);
+      if (watch !== null) void remote.cancelWatchAvailability(watch).catch(() => {
+      });
+    };
+  }
+  const onAvailability = (event) => publish({ available: event.availability === "available" });
+  const onWireless = () => publish({ connected: Boolean(element.webkitCurrentPlaybackTargetIsWireless) });
+  element.addEventListener("webkitplaybacktargetavailabilitychanged", onAvailability);
+  element.addEventListener("webkitcurrentplaybacktargetiswirelesschanged", onWireless);
+  onWireless();
+  return () => {
+    element.removeEventListener("webkitplaybacktargetavailabilitychanged", onAvailability);
+    element.removeEventListener("webkitcurrentplaybacktargetiswirelesschanged", onWireless);
+  };
+}
+async function promptRemote(video) {
+  const element = video;
+  if (element.remote?.prompt) return void await element.remote.prompt();
+  element.webkitShowPlaybackTargetPicker?.();
+}
+
+export { SEEK_JUMP, SEEK_STEP, SPEEDS, VOLUME_STEP, activeCaption, bufferedAhead, captionTracks, commandFor, formatTime, fractionAt, fullscreenElement, isTypingTarget, nextSpeed, progress, promptRemote, showCaption, supportsPip, supportsRemote, toggleFullscreen, togglePip, watchRemote };

package/dist/clipboard-menu-BvXJCSFN.d.ts

@@ -0,0 +1,93 @@
+import { b as ContextMenuEntry } from './context-menu-D3FtTn7v.js';
+
+/**
+ * The rows every context menu on a desktop already has: Copy, Cut and Paste.
+ *
+ * A menu opened over a selection or over a field is expected to offer them - the browser's own
+ * does, and replacing that menu with a custom one takes them away without saying so. Which is
+ * why they are ON by default here and turned off with a prop, rather than the other way round:
+ * the defect is silent, so the default has to be the safe one.
+ *
+ * WHAT DECIDES THEY APPEAR is what was right-clicked, and it is read at the moment the menu
+ * opens, not from React state - by then the selection is settled (a `contextmenu` event fires
+ * after the press has adjusted it) and the caret is still where the visitor left it.
+ *
+ * - **Copy**, when there is selected text under the pointer.
+ * - **Cut**, when that selection is also in something writable.
+ * - **Paste**, in anything writable - and disabled when the clipboard is known to be empty.
+ *
+ * Not a React module: what a selection is, whether a field takes writes, and how text is put
+ * back into one are DOM questions, so a menu drawn by anything else gets the same rows.
+ */
+
+/** The ids these rows carry. Namespaced, so they can never collide with a caller's own. */
+declare const CLIPBOARD_PREFIX = "enigma:clipboard:";
+type ClipboardAction = "copy" | "cut" | "paste";
+/** What the menu was opened over, as far as the clipboard is concerned. */
+interface ClipboardTarget {
+    /** The field or contenteditable under the pointer, or null when it is neither. */
+    editable: HTMLElement | null;
+    /** Whether that element takes writes: not disabled, not read-only. */
+    writable: boolean;
+    /** The selected text, from the field's own selection or the document's. */
+    selection: string;
+    /**
+     * Whether that text may be put on the clipboard.
+     *
+     * False for a password field. The clipboard is shared with every other application on the
+     * machine and is not cleared, so a menu that copies a password out of a masked field
+     * leaks it somewhere the visitor cannot see - and the browser's own menu refuses too.
+     */
+    copyable: boolean;
+    /** Where the selection was, so it can be put back after the menu has taken focus. */
+    range: {
+        start: number;
+        end: number;
+    } | null;
+}
+interface ClipboardMenuLabels {
+    copy?: string;
+    cut?: string;
+    paste?: string;
+}
+interface ClipboardMenuOptions {
+    copy?: boolean;
+    cut?: boolean;
+    paste?: boolean;
+    labels?: ClipboardMenuLabels;
+    /** Whatever the renderer draws icons with. `unknown`, because a core cannot know. */
+    icons?: {
+        copy?: unknown;
+        cut?: unknown;
+        paste?: unknown;
+    };
+    /** The clipboard is known to be empty, so Paste is listed and greyed rather than missing. */
+    clipboardEmpty?: boolean;
+}
+/** What was right-clicked, read the moment the menu opens. */
+declare function inspectClipboardTarget(node: EventTarget | null): ClipboardTarget;
+/**
+ * Whether the clipboard has text in it, or null when that cannot be known.
+ *
+ * Null is the common answer and not a failure: reading the clipboard needs permission, and
+ * asking for it puts a browser prompt on screen just to decide whether to grey out a row -
+ * which is a worse trade than showing an enabled Paste that turns out to do nothing. So the
+ * permission is only READ, never requested, and the clipboard is only opened where it has
+ * already been granted.
+ */
+declare function clipboardHasText(): Promise<boolean | null>;
+/** The rows for this target, in the order every desktop menu puts them. */
+declare function clipboardEntries(target: ClipboardTarget, options?: ClipboardMenuOptions): ContextMenuEntry[];
+/** Which clipboard row an id belongs to, or null for anything that is not one of ours. */
+declare function clipboardAction(id: string): ClipboardAction | null;
+/**
+ * Do what the row says.
+ *
+ * Called straight from the press that chose it, so the browser still counts it as a user
+ * gesture - which is what the clipboard API requires and what makes a paste possible at all.
+ * Returns whether the action happened: a refused permission and an empty clipboard are both
+ * "no", and neither is worth an exception the caller has to catch.
+ */
+declare function performClipboardAction(action: ClipboardAction, target: ClipboardTarget): Promise<boolean>;
+
+export { CLIPBOARD_PREFIX as C, type ClipboardAction as a, type ClipboardMenuLabels as b, type ClipboardMenuOptions as c, type ClipboardTarget as d, clipboardAction as e, clipboardEntries as f, clipboardHasText as g, inspectClipboardTarget as i, performClipboardAction as p };

package/dist/context-BfjYGPnH.d.ts

@@ -0,0 +1,54 @@
+import { ReactNode, RefObject } from 'react';
+import { a as ContextMenuAction, b as ContextMenuEntry, c as ContextMenuInstance, j as ContextMenuState, h as ContextMenuPoint } from './context-menu-D3FtTn7v.js';
+
+/**
+ * One row, as React draws it. The core carries `icon` as `unknown` because it cannot know
+ * what a node is; here it is one.
+ */
+interface ContextMenuItem extends Omit<ContextMenuAction, "icon" | "items"> {
+    icon?: ReactNode;
+    items?: readonly ContextMenuNode[];
+}
+/** Anything that can appear in a menu, with React's icon type. */
+type ContextMenuNode = ContextMenuItem | Exclude<ContextMenuEntry, ContextMenuAction>;
+interface ContextMenuContextValue {
+    instance: ContextMenuInstance;
+    state: ContextMenuState;
+    /**
+     * Open at a point, over what the press landed on. False when there was nothing to show,
+     * so the press is left alone.
+     *
+     * `target` is what the clipboard rows are built from - the field or the selection under
+     * the pointer - and a caller that leaves it out gets a menu with none of them, which is
+     * the right answer for a menu opened from somewhere that is not a press.
+     */
+    open: (point: ContextMenuPoint, target?: EventTarget | null) => boolean;
+    close: () => void;
+    /** ids the parts need to point at each other. */
+    ids: {
+        trigger: string;
+    };
+    panelId: (level: number) => string;
+    itemId: (level: number, index: number) => string;
+    triggerRef: RefObject<HTMLElement | null>;
+    /** Which panel the keyboard is in. Always the deepest open one. */
+    onMenuKeyDown: (event: React.KeyboardEvent) => void;
+    /** How long the pointer must rest on a row before its submenu opens, and before one closes. */
+    delays: {
+        open: number;
+        close: number;
+    };
+    /** Drop the pending close, wherever it was scheduled. Called wherever the pointer lands. */
+    cancelClose: () => void;
+    /** Close everything below `level`, after the beat - replacing any close already waiting. */
+    scheduleClose: (level: number) => void;
+    /** Draw a row instead of the default icon / label / shortcut. */
+    renderItem?: (item: ContextMenuItem, level: number, index: number) => ReactNode;
+    /** Shown while a fetched submenu has not answered. */
+    loadingLabel: ReactNode;
+    /** Shown when a filter matched nothing, or a fetched submenu came back with nothing. */
+    emptyLabel: ReactNode;
+}
+declare function useContextMenuContext(part: string): ContextMenuContextValue;
+
+export { type ContextMenuContextValue as C, type ContextMenuItem as a, type ContextMenuNode as b, useContextMenuContext as u };

package/dist/{clipboard-menu-B_ouitfS.d.ts → context-menu-D3FtTn7v.d.ts}

@@ -171,94 +171,4 @@ interface ContextMenuInstance {
 type ContextMenuMoveKey = "ArrowDown" | "ArrowUp" | "Home" | "End" | "PageDown" | "PageUp";
 declare function createContextMenu(options?: ContextMenuOptions): ContextMenuInstance;
 
-/**
- * The rows every context menu on a desktop already has: Copy, Cut and Paste.
- *
- * A menu opened over a selection or over a field is expected to offer them - the browser's own
- * does, and replacing that menu with a custom one takes them away without saying so. Which is
- * why they are ON by default here and turned off with a prop, rather than the other way round:
- * the defect is silent, so the default has to be the safe one.
- *
- * WHAT DECIDES THEY APPEAR is what was right-clicked, and it is read at the moment the menu
- * opens, not from React state - by then the selection is settled (a `contextmenu` event fires
- * after the press has adjusted it) and the caret is still where the visitor left it.
- *
- * - **Copy**, when there is selected text under the pointer.
- * - **Cut**, when that selection is also in something writable.
- * - **Paste**, in anything writable - and disabled when the clipboard is known to be empty.
- *
- * Not a React module: what a selection is, whether a field takes writes, and how text is put
- * back into one are DOM questions, so a menu drawn by anything else gets the same rows.
- */
-
-/** The ids these rows carry. Namespaced, so they can never collide with a caller's own. */
-declare const CLIPBOARD_PREFIX = "enigma:clipboard:";
-type ClipboardAction = "copy" | "cut" | "paste";
-/** What the menu was opened over, as far as the clipboard is concerned. */
-interface ClipboardTarget {
-    /** The field or contenteditable under the pointer, or null when it is neither. */
-    editable: HTMLElement | null;
-    /** Whether that element takes writes: not disabled, not read-only. */
-    writable: boolean;
-    /** The selected text, from the field's own selection or the document's. */
-    selection: string;
-    /**
-     * Whether that text may be put on the clipboard.
-     *
-     * False for a password field. The clipboard is shared with every other application on the
-     * machine and is not cleared, so a menu that copies a password out of a masked field
-     * leaks it somewhere the visitor cannot see - and the browser's own menu refuses too.
-     */
-    copyable: boolean;
-    /** Where the selection was, so it can be put back after the menu has taken focus. */
-    range: {
-        start: number;
-        end: number;
-    } | null;
-}
-interface ClipboardMenuLabels {
-    copy?: string;
-    cut?: string;
-    paste?: string;
-}
-interface ClipboardMenuOptions {
-    copy?: boolean;
-    cut?: boolean;
-    paste?: boolean;
-    labels?: ClipboardMenuLabels;
-    /** Whatever the renderer draws icons with. `unknown`, because a core cannot know. */
-    icons?: {
-        copy?: unknown;
-        cut?: unknown;
-        paste?: unknown;
-    };
-    /** The clipboard is known to be empty, so Paste is listed and greyed rather than missing. */
-    clipboardEmpty?: boolean;
-}
-/** What was right-clicked, read the moment the menu opens. */
-declare function inspectClipboardTarget(node: EventTarget | null): ClipboardTarget;
-/**
- * Whether the clipboard has text in it, or null when that cannot be known.
- *
- * Null is the common answer and not a failure: reading the clipboard needs permission, and
- * asking for it puts a browser prompt on screen just to decide whether to grey out a row -
- * which is a worse trade than showing an enabled Paste that turns out to do nothing. So the
- * permission is only READ, never requested, and the clipboard is only opened where it has
- * already been granted.
- */
-declare function clipboardHasText(): Promise<boolean | null>;
-/** The rows for this target, in the order every desktop menu puts them. */
-declare function clipboardEntries(target: ClipboardTarget, options?: ClipboardMenuOptions): ContextMenuEntry[];
-/** Which clipboard row an id belongs to, or null for anything that is not one of ours. */
-declare function clipboardAction(id: string): ClipboardAction | null;
-/**
- * Do what the row says.
- *
- * Called straight from the press that chose it, so the browser still counts it as a user
- * gesture - which is what the clipboard API requires and what makes a paste possible at all.
- * Returns whether the action happened: a refused permission and an empty clipboard are both
- * "no", and neither is worth an exception the caller has to catch.
- */
-declare function performClipboardAction(action: ClipboardAction, target: ClipboardTarget): Promise<boolean>;
-
-export { CLIPBOARD_PREFIX as C, CONTEXT_MENU_SEARCH_KEYS as a, type ClipboardAction as b, type ClipboardMenuLabels as c, type ClipboardMenuOptions as d, type ClipboardTarget as e, type ContextMenuAction as f, type ContextMenuEntry as g, type ContextMenuInstance as h, type ContextMenuLabel as i, type ContextMenuLevel as j, type ContextMenuMoveKey as k, type ContextMenuOptions as l, type ContextMenuPoint as m, type ContextMenuSeparator as n, type ContextMenuState as o, clipboardAction as p, clipboardEntries as q, clipboardHasText as r, createContextMenu as s, inspectClipboardTarget as t, isAction as u, performClipboardAction as v };
+export { CONTEXT_MENU_SEARCH_KEYS as C, type ContextMenuAction as a, type ContextMenuEntry as b, type ContextMenuInstance as c, type ContextMenuLabel as d, type ContextMenuLevel as e, type ContextMenuMoveKey as f, type ContextMenuOptions as g, type ContextMenuPoint as h, type ContextMenuSeparator as i, type ContextMenuState as j, createContextMenu as k, isAction as l };