gestament 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -1,1150 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const node_child_process = require("node:child_process");
-const native = require("./native-ie_XIt1J.cjs");
-/*!
-* name: async-primitives
-* version: 1.7.0
-* description: A collection of primitive functions for asynchronous operations
-* author: Kouji Matsui (@kekyo@mi.kekyo.net)
-* license: MIT
-* repository.url: https://github.com/kekyo/async-primitives.git
-* git.commit.hash: 9472fbd5310b92690d84aaafb897429a04c013c5
-*/
-var delay = (msec, signal) => {
-  return new Promise((resolve) => {
-    setTimeout(resolve, msec);
-  });
-};
-const assertNonNegativeIndex$1 = (name, index) => {
-  if (!Number.isInteger(index) || index < 0) {
-    throw native.createGtkInvalidArgumentError(
-      `${name} must be a non-negative integer.`
-    );
-  }
-};
-const assertFiniteNumber = (name, value) => {
-  if (!Number.isFinite(value)) {
-    throw native.createGtkInvalidArgumentError(`${name} must be a finite number.`);
-  }
-};
-const normalizeRoleName = (roleName) => roleName.trim().toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ");
-const hasInterface = (info, name) => info.interfaces.some(
-  (interfaceName) => interfaceName.toLowerCase() === name.toLowerCase()
-);
-const hasState = (info, name) => info.states.some((state) => state.toLowerCase() === name.toLowerCase());
-const elementInfoOverrides = /* @__PURE__ */ new WeakMap();
-const overrideElementInfo = (handle, override) => {
-  elementInfoOverrides.set(handle, override);
-  return handle;
-};
-const nativeInfoKind = (handle) => elementInfoOverrides.get(handle)?.kind ?? widgetKindFromInfo(native.nativeElementInfo(handle));
-const widgetKindFromInfo = (info) => {
-  const roleName = normalizeRoleName(info.roleName);
-  if (hasInterface(info, "TableCell")) {
-    return "tableCell";
-  }
-  switch (roleName) {
-    case "frame":
-    case "dialog":
-    case "window":
-      return "window";
-    case "filler":
-    case "panel":
-    case "scroll pane":
-    case "layered pane":
-    case "split pane":
-    case "viewport":
-      return "container";
-    case "button":
-    case "push button":
-    case "push button menu":
-      return "button";
-    case "label":
-    case "static":
-      return "label";
-    case "entry":
-    case "password text":
-    case "search box":
-      return "entry";
-    case "text":
-      return hasInterface(info, "EditableText") || hasState(info, "editable") || hasState(info, "singleLine") ? "entry" : "text";
-    case "paragraph":
-      return "text";
-    case "check box":
-      return "checkbox";
-    case "switch":
-      return "switch";
-    case "radio button":
-      return "radio";
-    case "toggle button":
-      return hasInterface(info, "Image") || info.name.length > 0 ? "toggleButton" : "switch";
-    case "slider":
-      return "slider";
-    case "spin button":
-      return "spinButton";
-    case "progress bar":
-    case "level bar":
-      return "progressBar";
-    case "combo box":
-      return "comboBox";
-    case "list":
-    case "list box":
-      return "list";
-    case "tree":
-      return hasInterface(info, "Table") ? "table" : "list";
-    case "list item":
-    case "tree item":
-      return "listItem";
-    case "table":
-    case "tree table":
-      return "table";
-    case "table cell":
-      return "tableCell";
-    case "image":
-    case "icon":
-      return "image";
-    case "menu":
-    case "menu bar":
-    case "popup menu":
-      return "menu";
-    case "menu item":
-    case "check menu item":
-    case "radio menu item":
-    case "tearoff menu item":
-      return "menuItem";
-    default:
-      return "unknown";
-  }
-};
-const toGtkElementInfo = (info) => ({
-  ...info,
-  kind: widgetKindFromInfo(info)
-});
-const toGtkElementInfoForHandle = (handle) => {
-  const info = toGtkElementInfo(native.nativeElementInfo(handle));
-  const override = elementInfoOverrides.get(handle);
-  return override === void 0 ? info : { ...info, ...override };
-};
-const createCommonElement = (handle) => ({
-  info: async () => toGtkElementInfoForHandle(handle),
-  capture: async () => native.nativeCapture(handle)
-});
-const expectedKindLabel = (expectedKinds) => expectedKinds.join(", ");
-const assertExpectedKind = (element, expectedKinds, operation) => {
-  if (!expectedKinds.includes(element.kind)) {
-    throw native.createGtkUnsupportedInterfaceError(
-      `${operation} returned ${element.kind}, expected ${expectedKindLabel(
-        expectedKinds
-      )}.`
-    );
-  }
-  return element;
-};
-const createGetChildCountOperation = (handle) => async () => native.nativeChildCount(handle);
-const createChildAtOperation = (handle, expectedKinds) => async (index) => {
-  assertNonNegativeIndex$1("index", index);
-  const childHandle = native.nativeChildAt(handle, index);
-  if (childHandle === void 0) {
-    return void 0;
-  }
-  const child = createGtkElement(childHandle);
-  return expectedKinds === void 0 ? child : assertExpectedKind(child, expectedKinds, "childAt()");
-};
-const createChildContainerOperations = (handle, expectedKinds) => ({
-  childAt: createChildAtOperation(handle, expectedKinds),
-  getChildCount: createGetChildCountOperation(handle)
-});
-const createSelectableChildContainerOperations = (handle, expectedKinds) => ({
-  ...createChildContainerOperations(handle, expectedKinds),
-  getSelectedChildCount: async () => native.nativeSelectedChildCount(handle),
-  selectedChildAt: async (selectedIndex) => {
-    assertNonNegativeIndex$1("selectedIndex", selectedIndex);
-    const childHandle = native.nativeSelectedChildAt(handle, selectedIndex);
-    if (childHandle === void 0) {
-      return void 0;
-    }
-    const child = createGtkElement(childHandle);
-    return assertExpectedKind(child, expectedKinds, "selectedChildAt()");
-  },
-  isChildSelected: async (index) => {
-    assertNonNegativeIndex$1("index", index);
-    return native.nativeIsChildSelected(handle, index);
-  },
-  selectChildAt: async (index) => {
-    assertNonNegativeIndex$1("index", index);
-    native.nativeSelectChildAt(handle, index);
-  },
-  deselectChildAt: async (index) => {
-    assertNonNegativeIndex$1("index", index);
-    native.nativeDeselectChildAt(handle, index);
-  },
-  selectAllChildren: async () => {
-    native.nativeSelectAllChildren(handle);
-  },
-  clearSelection: async () => {
-    native.nativeClearSelection(handle);
-  }
-});
-const createOperationFailedForOutOfRangeIndex = (index) => native.createGtkOperationFailedError(`Child index is out of range: ${index}`);
-const isUnsupportedInterfaceError = (error) => error.code === "UNSUPPORTED_INTERFACE";
-const visitNativeDescendants = (handle, visitor, maxNodes) => {
-  const queue = [];
-  const childCount = native.nativeChildCount(handle);
-  for (let index = 0; index < childCount; index += 1) {
-    const childHandle = native.nativeChildAt(handle, index);
-    if (childHandle !== void 0) {
-      queue.push(childHandle);
-    }
-  }
-  let visitedNodes = 0;
-  while (queue.length > 0 && visitedNodes < maxNodes) {
-    const currentHandle = queue.shift();
-    visitedNodes += 1;
-    if (visitor(currentHandle)) {
-      return;
-    }
-    const currentChildCount = native.nativeChildCount(currentHandle);
-    for (let index = 0; index < currentChildCount; index += 1) {
-      const childHandle = native.nativeChildAt(currentHandle, index);
-      if (childHandle !== void 0) {
-        queue.push(childHandle);
-      }
-    }
-  }
-};
-const findFirstDescendantName = (handle) => {
-  let foundName;
-  visitNativeDescendants(
-    handle,
-    (descendantHandle) => {
-      const name = native.nativeElementInfo(descendantHandle).name;
-      if (name.length === 0) {
-        return false;
-      }
-      foundName = name;
-      return true;
-    },
-    64
-  );
-  return foundName;
-};
-const directChildKindAt = (handle, index) => {
-  const childHandle = native.nativeChildAt(handle, index);
-  return childHandle === void 0 ? void 0 : nativeInfoKind(childHandle);
-};
-const handleContainsComboItems = (handle) => {
-  const childCount = native.nativeChildCount(handle);
-  if (childCount === 0) {
-    return false;
-  }
-  const firstChildKind = directChildKindAt(handle, 0);
-  return firstChildKind === "listItem" || firstChildKind === "menuItem";
-};
-const findComboBoxItemContainerHandle = (handle) => {
-  if (handleContainsComboItems(handle)) {
-    return handle;
-  }
-  let foundHandle;
-  visitNativeDescendants(
-    handle,
-    (descendantHandle) => {
-      const kind = nativeInfoKind(descendantHandle);
-      if ((kind === "list" || kind === "menu") && handleContainsComboItems(descendantHandle)) {
-        foundHandle = descendantHandle;
-        return true;
-      }
-      return false;
-    },
-    128
-  );
-  return foundHandle;
-};
-const resolveComboBoxItemContainerHandle = (handle) => {
-  const descendantItemContainer = findComboBoxItemContainerHandle(handle);
-  if (descendantItemContainer !== void 0) {
-    return descendantItemContainer;
-  }
-  const childCount = native.nativeChildCount(handle);
-  if (childCount !== 1) {
-    return handle;
-  }
-  const childHandle = native.nativeChildAt(handle, 0);
-  if (childHandle === void 0) {
-    return handle;
-  }
-  const childKind = nativeInfoKind(childHandle);
-  return childKind === "menu" || childKind === "list" ? childHandle : handle;
-};
-const comboBoxClickTargetHandle = (handle) => {
-  const childHandle = native.nativeChildAt(handle, 0);
-  if (childHandle === void 0) {
-    return handle;
-  }
-  const childKind = nativeInfoKind(childHandle);
-  return childKind === "button" || childKind === "toggleButton" ? childHandle : handle;
-};
-const overrideComboBoxItemInfo = (handle) => {
-  const info = native.nativeElementInfo(handle);
-  if (info.name.length > 0) {
-    return handle;
-  }
-  const descendantName = findFirstDescendantName(handle);
-  return descendantName === void 0 ? handle : overrideElementInfo(handle, { name: descendantName });
-};
-const itemIdentityMatches = (candidate, selected) => {
-  if (candidate.accessibleId.length > 0 && selected.accessibleId.length > 0) {
-    return candidate.accessibleId === selected.accessibleId;
-  }
-  return candidate.kind === selected.kind && candidate.roleName === selected.roleName && candidate.name === selected.name && candidate.description === selected.description;
-};
-const comboBoxItemLookupAt = (handle, index) => {
-  const itemContainerHandle = resolveComboBoxItemContainerHandle(handle);
-  const itemHandle = native.nativeChildAt(itemContainerHandle, index);
-  if (itemHandle === void 0) {
-    throw createOperationFailedForOutOfRangeIndex(index);
-  }
-  const itemKind = nativeInfoKind(itemHandle);
-  if (itemKind !== "listItem" && itemKind !== "menuItem") {
-    throw native.createGtkUnsupportedInterfaceError(
-      `ComboBox childAt() returned ${itemKind}, expected listItem, menuItem.`
-    );
-  }
-  return {
-    itemContainerHandle,
-    itemHandle: overrideComboBoxItemInfo(itemHandle)
-  };
-};
-const comboBoxItemHandleAt = (handle, index) => comboBoxItemLookupAt(handle, index).itemHandle;
-const createComboBoxOperations = (handle) => ({
-  childAt: async (index) => {
-    assertNonNegativeIndex$1("index", index);
-    const itemContainerHandle = resolveComboBoxItemContainerHandle(handle);
-    const itemHandle = native.nativeChildAt(itemContainerHandle, index);
-    if (itemHandle === void 0) {
-      return void 0;
-    }
-    overrideComboBoxItemInfo(itemHandle);
-    return assertExpectedKind(
-      createGtkElement(itemHandle),
-      ["listItem", "menuItem"],
-      "childAt()"
-    );
-  },
-  getChildCount: async () => native.nativeChildCount(resolveComboBoxItemContainerHandle(handle)),
-  getSelectedChildCount: async () => native.nativeSelectedChildCount(handle),
-  selectedChildAt: async (selectedIndex) => {
-    assertNonNegativeIndex$1("selectedIndex", selectedIndex);
-    const childHandle = native.nativeSelectedChildAt(handle, selectedIndex);
-    if (childHandle === void 0) {
-      return void 0;
-    }
-    return assertExpectedKind(
-      createGtkElement(childHandle),
-      ["listItem", "menuItem"],
-      "selectedChildAt()"
-    );
-  },
-  isChildSelected: async (index) => {
-    assertNonNegativeIndex$1("index", index);
-    const itemHandle = comboBoxItemHandleAt(handle, index);
-    const itemInfo = toGtkElementInfoForHandle(itemHandle);
-    const selectedCount = native.nativeSelectedChildCount(handle);
-    for (let selectedIndex = 0; selectedIndex < selectedCount; selectedIndex += 1) {
-      const selectedHandle = native.nativeSelectedChildAt(handle, selectedIndex);
-      if (selectedHandle === void 0) {
-        continue;
-      }
-      const selectedInfo = toGtkElementInfo(native.nativeElementInfo(selectedHandle));
-      if (itemIdentityMatches(itemInfo, selectedInfo)) {
-        return true;
-      }
-    }
-    return false;
-  },
-  selectChildAt: async (index) => {
-    assertNonNegativeIndex$1("index", index);
-    const { itemContainerHandle, itemHandle } = comboBoxItemLookupAt(
-      handle,
-      index
-    );
-    const expectedName = toGtkElementInfoForHandle(itemHandle).name;
-    native.nativeClick(itemHandle);
-    if (itemContainerHandle !== handle && expectedName.length > 0 && native.nativeElementInfo(handle).name !== expectedName) {
-      throw native.createGtkOperationFailedError(
-        "ComboBox child selection did not change the selected item."
-      );
-    }
-  },
-  deselectChildAt: async (index) => {
-    assertNonNegativeIndex$1("index", index);
-    comboBoxItemHandleAt(handle, index);
-    native.nativeDeselectChildAt(handle, 0);
-  },
-  selectAllChildren: async () => {
-    native.nativeSelectAllChildren(handle);
-  },
-  clearSelection: async () => {
-    const selectedBefore = native.nativeSelectedChildCount(handle);
-    native.nativeClearSelection(handle);
-    if (selectedBefore > 0 && native.nativeSelectedChildCount(handle) > 0) {
-      throw native.createGtkOperationFailedError(
-        "ComboBox selection could not be cleared."
-      );
-    }
-  }
-});
-const createSetTextOperation = (handle) => async (text) => {
-  native.nativeSetText(handle, text);
-};
-const createClickOperation = (handle) => async () => {
-  native.nativeClick(handle);
-};
-const createComboBoxClickOperation = (handle) => async () => {
-  native.nativeClick(comboBoxClickTargetHandle(handle));
-};
-const createTextOperation = (handle) => async () => native.nativeText(handle);
-const createIsCheckedOperation = (handle) => async () => {
-  const info = native.nativeElementInfo(handle);
-  return hasState(info, "checked") || hasState(info, "pressed");
-};
-const createToggleOperation = (handle) => async () => {
-  native.nativeClick(handle);
-};
-const createValueInfoOperation = (handle) => async () => native.nativeValueInfo(handle);
-const createImageInfoOperation = (handle) => async () => {
-  const info = native.nativeImageInfo(handle);
-  return {
-    ...info,
-    capture: async () => native.nativeCaptureBounds(info.bounds)
-  };
-};
-const createValueOperation = (handle) => async () => native.nativeValueInfo(handle).value;
-const createSetValueOperation = (handle) => async (value) => {
-  assertFiniteNumber("value", value);
-  native.nativeSetValue(handle, value);
-};
-const assertUsableValueMetadata = (info) => {
-  if (!Number.isFinite(info.value) || !Number.isFinite(info.minimum) || !Number.isFinite(info.maximum) || !Number.isFinite(info.minimumIncrement)) {
-    throw native.createGtkOperationFailedError(
-      "Accessible value metadata does not contain usable numeric values."
-    );
-  }
-};
-const valueStep = (info) => {
-  assertUsableValueMetadata(info);
-  if (info.minimumIncrement > 0) {
-    return info.minimumIncrement;
-  }
-  const range = info.maximum - info.minimum;
-  if (!Number.isFinite(range) || range <= 0) {
-    throw native.createGtkOperationFailedError(
-      "Accessible value metadata does not contain a usable increment."
-    );
-  }
-  return Math.min(1, range);
-};
-const clampedValue = (value, minimum, maximum) => Math.min(Math.max(value, minimum), maximum);
-const createIncrementOperation = (handle) => async () => {
-  const info = native.nativeValueInfo(handle);
-  const step = valueStep(info);
-  native.nativeSetValue(
-    handle,
-    clampedValue(info.value + step, info.minimum, info.maximum)
-  );
-};
-const createDecrementOperation = (handle) => async () => {
-  const info = native.nativeValueInfo(handle);
-  const step = valueStep(info);
-  native.nativeSetValue(
-    handle,
-    clampedValue(info.value - step, info.minimum, info.maximum)
-  );
-};
-const collectDirectTableCellChildren = (rowHandle) => {
-  const cells = [];
-  const childCount = native.nativeChildCount(rowHandle);
-  for (let index = 0; index < childCount; index += 1) {
-    const childHandle = native.nativeChildAt(rowHandle, index);
-    if (childHandle !== void 0 && nativeInfoKind(childHandle) === "tableCell") {
-      cells.push(childHandle);
-    }
-  }
-  return cells;
-};
-const collectFallbackTableRows = (handle) => {
-  const rows = [];
-  visitNativeDescendants(
-    handle,
-    (descendantHandle) => {
-      const roleName = normalizeRoleName(
-        native.nativeElementInfo(descendantHandle).roleName
-      );
-      if (roleName !== "table row") {
-        return false;
-      }
-      const cells = collectDirectTableCellChildren(descendantHandle);
-      if (cells.length > 0) {
-        rows.push(
-          cells.map(
-            (cellHandle) => overrideElementInfo(cellHandle, { kind: "tableCell" })
-          )
-        );
-      }
-      return false;
-    },
-    512
-  );
-  return rows;
-};
-const fallbackTableRowCount = (handle) => collectFallbackTableRows(handle).length;
-const fallbackTableColumnCount = (handle) => {
-  const rows = collectFallbackTableRows(handle);
-  return rows.reduce((max, row) => Math.max(max, row.length), 0);
-};
-const fallbackTableCellAt = (handle, row, column) => {
-  const rows = collectFallbackTableRows(handle);
-  return rows[row]?.[column];
-};
-const createTableCellAtOperation = (handle) => async (row, column) => {
-  assertNonNegativeIndex$1("row", row);
-  assertNonNegativeIndex$1("column", column);
-  let cellHandle;
-  try {
-    cellHandle = native.nativeTableCellAt(handle, row, column);
-  } catch (error) {
-    if (!isUnsupportedInterfaceError(error)) {
-      throw error;
-    }
-    cellHandle = fallbackTableCellAt(handle, row, column);
-  }
-  if (cellHandle === void 0) {
-    return void 0;
-  }
-  overrideElementInfo(cellHandle, { kind: "tableCell" });
-  return assertExpectedKind(
-    createGtkElement(cellHandle),
-    ["tableCell"],
-    "cellAt()"
-  );
-};
-const createTableOperations = (handle) => ({
-  getRowCount: async () => {
-    try {
-      return native.nativeTableRowCount(handle);
-    } catch (error) {
-      if (!isUnsupportedInterfaceError(error)) {
-        throw error;
-      }
-      return fallbackTableRowCount(handle);
-    }
-  },
-  getColumnCount: async () => {
-    try {
-      return native.nativeTableColumnCount(handle);
-    } catch (error) {
-      if (!isUnsupportedInterfaceError(error)) {
-        throw error;
-      }
-      return fallbackTableColumnCount(handle);
-    }
-  },
-  cellAt: createTableCellAtOperation(handle),
-  selectedRows: async () => native.nativeTableSelectedRows(handle),
-  selectedColumns: async () => native.nativeTableSelectedColumns(handle),
-  isRowSelected: async (row) => {
-    assertNonNegativeIndex$1("row", row);
-    return native.nativeTableIsRowSelected(handle, row);
-  },
-  isColumnSelected: async (column) => {
-    assertNonNegativeIndex$1("column", column);
-    return native.nativeTableIsColumnSelected(handle, column);
-  },
-  isCellSelected: async (row, column) => {
-    assertNonNegativeIndex$1("row", row);
-    assertNonNegativeIndex$1("column", column);
-    return native.nativeTableIsCellSelected(handle, row, column);
-  },
-  selectRow: async (row) => {
-    assertNonNegativeIndex$1("row", row);
-    native.nativeTableSelectRow(handle, row);
-  },
-  deselectRow: async (row) => {
-    assertNonNegativeIndex$1("row", row);
-    native.nativeTableDeselectRow(handle, row);
-  },
-  selectColumn: async (column) => {
-    assertNonNegativeIndex$1("column", column);
-    native.nativeTableSelectColumn(handle, column);
-  },
-  deselectColumn: async (column) => {
-    assertNonNegativeIndex$1("column", column);
-    native.nativeTableDeselectColumn(handle, column);
-  }
-});
-const createGtkElement = (handle) => {
-  const initialInfo = toGtkElementInfoForHandle(handle);
-  const common = createCommonElement(handle);
-  switch (initialInfo.kind) {
-    case "window":
-      return {
-        ...common,
-        kind: "window",
-        ...createChildContainerOperations(handle, void 0)
-      };
-    case "button":
-      return { ...common, kind: "button", click: createClickOperation(handle) };
-    case "container":
-      return {
-        ...common,
-        kind: "container",
-        ...createChildContainerOperations(handle, void 0)
-      };
-    case "label":
-      return { ...common, kind: "label", text: createTextOperation(handle) };
-    case "entry":
-      return {
-        ...common,
-        kind: "entry",
-        setText: createSetTextOperation(handle),
-        text: createTextOperation(handle)
-      };
-    case "text":
-      return { ...common, kind: "text", text: createTextOperation(handle) };
-    case "checkbox":
-      return {
-        ...common,
-        kind: "checkbox",
-        click: createClickOperation(handle),
-        isChecked: createIsCheckedOperation(handle),
-        toggle: createToggleOperation(handle)
-      };
-    case "switch":
-      return {
-        ...common,
-        kind: "switch",
-        click: createClickOperation(handle),
-        isChecked: createIsCheckedOperation(handle),
-        toggle: createToggleOperation(handle)
-      };
-    case "radio":
-      return {
-        ...common,
-        kind: "radio",
-        click: createClickOperation(handle),
-        isChecked: createIsCheckedOperation(handle),
-        toggle: createToggleOperation(handle)
-      };
-    case "toggleButton":
-      return {
-        ...common,
-        kind: "toggleButton",
-        click: createClickOperation(handle),
-        isChecked: createIsCheckedOperation(handle),
-        toggle: createToggleOperation(handle)
-      };
-    case "slider":
-      return {
-        ...common,
-        kind: "slider",
-        value: createValueOperation(handle),
-        valueInfo: createValueInfoOperation(handle),
-        setValue: createSetValueOperation(handle)
-      };
-    case "spinButton":
-      return {
-        ...common,
-        kind: "spinButton",
-        value: createValueOperation(handle),
-        valueInfo: createValueInfoOperation(handle),
-        setValue: createSetValueOperation(handle),
-        increment: createIncrementOperation(handle),
-        decrement: createDecrementOperation(handle)
-      };
-    case "progressBar":
-      return {
-        ...common,
-        kind: "progressBar",
-        value: createValueOperation(handle),
-        valueInfo: createValueInfoOperation(handle)
-      };
-    case "comboBox":
-      return {
-        ...common,
-        kind: "comboBox",
-        click: createComboBoxClickOperation(handle),
-        ...createComboBoxOperations(handle)
-      };
-    case "list":
-      return {
-        ...common,
-        kind: "list",
-        ...createSelectableChildContainerOperations(
-          handle,
-          ["listItem"]
-        )
-      };
-    case "listItem":
-      return {
-        ...common,
-        kind: "listItem",
-        click: createClickOperation(handle)
-      };
-    case "table":
-      return { ...common, kind: "table", ...createTableOperations(handle) };
-    case "tableCell":
-      return { ...common, kind: "tableCell" };
-    case "image":
-      return {
-        ...common,
-        kind: "image",
-        imageInfo: createImageInfoOperation(handle)
-      };
-    case "menu":
-      return {
-        ...common,
-        kind: "menu",
-        ...createChildContainerOperations(handle, [
-          "menuItem"
-        ])
-      };
-    case "menuItem":
-      return {
-        ...common,
-        kind: "menuItem",
-        click: createClickOperation(handle)
-      };
-    case "unknown":
-      return { ...common, kind: "unknown" };
-  }
-};
-const optionalString = (value) => value.length === 0 ? void 0 : value;
-const toMetadata = (item) => {
-  const iconName = optionalString(item.iconName);
-  const id = optionalString(item.id);
-  const status = optionalString(item.status);
-  const title = optionalString(item.title);
-  return {
-    backend: "status-notifier",
-    ...iconName === void 0 ? {} : { iconName },
-    ...id === void 0 ? {} : { id },
-    ...status === void 0 ? {} : { status },
-    ...title === void 0 ? {} : { title }
-  };
-};
-const sameTrayItem = (first, second) => first.busName === second.busName && first.objectPath === second.objectPath;
-const staleTrayItemError = () => native.createGtkStaleElementError("Tray item is no longer registered.");
-const resolveCurrentInfo = (handle) => {
-  const item = native.nativeTrayItems(handle.processId).find(
-    (candidate) => sameTrayItem(handle, candidate)
-  );
-  if (item === void 0) {
-    throw staleTrayItemError();
-  }
-  return item;
-};
-const isClickableElement = (element) => {
-  switch (element.kind) {
-    case "button":
-    case "checkbox":
-    case "switch":
-    case "radio":
-    case "toggleButton":
-    case "comboBox":
-    case "listItem":
-    case "menuItem":
-      return true;
-    default:
-      return false;
-  }
-};
-const nativeTrayItemMatchesSelector = (item, selector) => {
-  if ("id" in selector) {
-    return item.id === selector.id;
-  }
-  if ("title" in selector) {
-    return item.title === selector.title;
-  }
-  if ("busName" in selector) {
-    return item.busName === selector.busName && (selector.objectPath === void 0 || item.objectPath === selector.objectPath);
-  }
-  return false;
-};
-const createGtkTrayItem = (processId, item) => {
-  const handle = {
-    busName: item.busName,
-    objectPath: item.objectPath,
-    processId
-  };
-  const trayItem = {
-    metadata: async () => toMetadata(resolveCurrentInfo(handle)),
-    element: async () => {
-      const current = resolveCurrentInfo(handle);
-      const elementHandle = native.nativeFindAnyById(current.accessibleId);
-      return elementHandle === void 0 ? void 0 : createGtkElement(elementHandle);
-    },
-    capture: async () => {
-      const element = await trayItem.element();
-      if (element === void 0) {
-        throw native.createGtkElementNotFoundError(
-          "Tray item is registered but not visible."
-        );
-      }
-      return element.capture();
-    },
-    click: async () => {
-      const element = await trayItem.element();
-      if (element === void 0) {
-        throw native.createGtkElementNotFoundError(
-          "Tray item is registered but not visible."
-        );
-      }
-      if (!isClickableElement(element)) {
-        throw native.createGtkUnsupportedInterfaceError(
-          `Tray item element does not support click: ${element.kind}.`
-        );
-      }
-      await element.click();
-    },
-    openMenu: async () => {
-      resolveCurrentInfo(handle);
-      return void 0;
-    }
-  };
-  return trayItem;
-};
-const appendOutput = (lines, chunk) => {
-  lines.push(chunk.toString("utf8"));
-  if (lines.length > 40) {
-    lines.splice(0, lines.length - 40);
-  }
-};
-const formatProcessOutput = (state) => {
-  const stdout = state.stdout.join("").trim();
-  const stderr = state.stderr.join("").trim();
-  if (stdout.length === 0 && stderr.length === 0) {
-    return "";
-  }
-  return `
-stdout:
-${stdout}
-stderr:
-${stderr}`;
-};
-const assertProcessRunning = (state, command) => {
-  if (state.exitCode !== null || state.exitSignal !== null) {
-    throw native.createGtkAppExitedError(
-      `GTK application exited before the operation completed: ${command} (code=${String(state.exitCode)}, signal=${String(state.exitSignal)})` + formatProcessOutput(state)
-    );
-  }
-  const processId = state.process.pid;
-  if (processId === void 0) {
-    throw native.createGtkAppExitedError(
-      `GTK application did not expose a process id: ${command}`
-    );
-  }
-  return processId;
-};
-const assertNonNegativeIndex = (name, index) => {
-  if (!Number.isInteger(index) || index < 0) {
-    throw native.createGtkInvalidArgumentError(
-      `${name} must be a non-negative integer.`
-    );
-  }
-};
-const parseElementPath = (path) => {
-  const segments = path.split(/[.:;,]/u);
-  const id = segments[0];
-  if (id === void 0 || id.length === 0) {
-    throw native.createGtkInvalidArgumentError(
-      "path must start with an accessible id."
-    );
-  }
-  const childIndexes = [];
-  for (let index = 1; index < segments.length; index += 1) {
-    const segment = segments[index];
-    if (segment === void 0 || !/^\d+$/u.test(segment)) {
-      throw native.createGtkInvalidArgumentError(
-        "path child indexes must be non-negative decimal integers."
-      );
-    }
-    const childIndex = Number(segment);
-    if (!Number.isSafeInteger(childIndex)) {
-      throw native.createGtkInvalidArgumentError(
-        "path child indexes must be safe non-negative integers."
-      );
-    }
-    childIndexes.push(childIndex);
-  }
-  return { id, childIndexes };
-};
-const isPathChildContainer = (element) => "childAt" in element;
-const waitForAtspiReady = async (state, command, timeoutMs, startedAt) => {
-  if (state.atspiReady) {
-    return assertProcessRunning(state, command);
-  }
-  while (Date.now() - startedAt <= timeoutMs) {
-    const processId = assertProcessRunning(state, command);
-    state.atspiReadiness = native.nativeProcessAtspiReadiness(processId);
-    if (state.atspiReadiness === "ready") {
-      state.atspiReady = true;
-      return processId;
-    }
-    await delay(50);
-  }
-  assertProcessRunning(state, command);
-  throw native.createGtkOperationFailedError(
-    `AT-SPI did not become ready for GTK application: ${command} (last readiness: ${state.atspiReadiness})` + formatProcessOutput(state)
-  );
-};
-const createGtkAppEnvironment = (baseEnv, overrides) => {
-  const env = {
-    ...baseEnv,
-    GDK_BACKEND: baseEnv.GDK_BACKEND ?? "x11",
-    GSETTINGS_BACKEND: baseEnv.GSETTINGS_BACKEND ?? "memory",
-    GTK_THEME: baseEnv.GTK_THEME ?? "Adwaita",
-    ...overrides
-  };
-  delete env.NO_AT_BRIDGE;
-  return env;
-};
-const launchGtkApp = (appPath, args, options) => {
-  const _args = args ?? [];
-  const _timeoutMs = options?.timeoutMs ?? 1e4;
-  const child = node_child_process.spawn(appPath, [..._args], {
-    env: createGtkAppEnvironment(process.env, options?.env),
-    stdio: "pipe"
-  });
-  const state = {
-    atspiReadiness: "missing-bus-name",
-    atspiReady: false,
-    exitCode: null,
-    exitSignal: null,
-    process: child,
-    stderr: [],
-    stdout: []
-  };
-  child.stdout.on("data", (chunk) => {
-    appendOutput(state.stdout, chunk);
-  });
-  child.stderr.on("data", (chunk) => {
-    appendOutput(state.stderr, chunk);
-  });
-  child.on("exit", (code, signal) => {
-    state.exitCode = code;
-    state.exitSignal = signal;
-  });
-  const release = async () => {
-    if (state.exitCode !== null || state.exitSignal !== null) {
-      return;
-    }
-    child.kill("SIGTERM");
-    const startedAt = Date.now();
-    while (state.exitCode === null && state.exitSignal === null) {
-      if (Date.now() - startedAt > 2e3) {
-        child.kill("SIGKILL");
-        break;
-      }
-      await delay(25);
-    }
-  };
-  const findById = async (id) => {
-    const startedAt = Date.now();
-    await waitForAtspiReady(state, appPath, _timeoutMs, startedAt);
-    while (Date.now() - startedAt <= _timeoutMs) {
-      const processId = assertProcessRunning(state, appPath);
-      try {
-        const handle = native.nativeFindById(processId, id);
-        if (handle !== void 0) {
-          return createGtkElement(handle);
-        }
-      } catch (error) {
-        throw native.normalizeNativeError(error);
-      }
-      await delay(50);
-    }
-    assertProcessRunning(state, appPath);
-    return void 0;
-  };
-  const getById = async (id) => {
-    const element = await findById(id);
-    if (element === void 0) {
-      throw native.createGtkElementNotFoundError(`Accessible id was not found: ${id}`);
-    }
-    return element;
-  };
-  const findByPath = async (path) => {
-    const parsedPath = parseElementPath(path);
-    const startedAt = Date.now();
-    await waitForAtspiReady(state, appPath, _timeoutMs, startedAt);
-    while (Date.now() - startedAt <= _timeoutMs) {
-      const processId = assertProcessRunning(state, appPath);
-      try {
-        const handle = native.nativeFindById(processId, parsedPath.id);
-        if (handle !== void 0) {
-          let element = createGtkElement(handle);
-          let resolved = true;
-          for (const childIndex of parsedPath.childIndexes) {
-            if (!isPathChildContainer(element)) {
-              resolved = false;
-              break;
-            }
-            const child2 = await element.childAt(childIndex);
-            if (child2 === void 0) {
-              resolved = false;
-              break;
-            }
-            element = child2;
-          }
-          if (resolved) {
-            return element;
-          }
-        }
-      } catch (error) {
-        throw native.normalizeNativeError(error);
-      }
-      await delay(50);
-    }
-    assertProcessRunning(state, appPath);
-    return void 0;
-  };
-  const getByPath = async (path) => {
-    const element = await findByPath(path);
-    if (element === void 0) {
-      throw native.createGtkElementNotFoundError(
-        `Element path was not found: ${path}`
-      );
-    }
-    return element;
-  };
-  const findTrayItem = async (selector) => {
-    const startedAt = Date.now();
-    while (Date.now() - startedAt <= _timeoutMs) {
-      const processId = assertProcessRunning(state, appPath);
-      try {
-        const item = native.nativeTrayItems(processId).find(
-          (candidate) => nativeTrayItemMatchesSelector(candidate, selector)
-        );
-        if (item !== void 0) {
-          return createGtkTrayItem(processId, item);
-        }
-      } catch (error) {
-        const normalizedError = native.normalizeNativeError(error);
-        if (normalizedError.code === "OPERATION_FAILED" && normalizedError.message.includes("Timeout was reached")) {
-          await delay(50);
-          continue;
-        }
-        throw normalizedError;
-      }
-      await delay(50);
-    }
-    assertProcessRunning(state, appPath);
-    return void 0;
-  };
-  const getTrayItem = async (selector) => {
-    const trayItem = await findTrayItem(selector);
-    if (trayItem === void 0) {
-      throw native.createGtkElementNotFoundError(
-        `StatusNotifier tray item was not found: ${JSON.stringify(selector)}`
-      );
-    }
-    return trayItem;
-  };
-  const app = {
-    capture: async () => {
-      assertProcessRunning(state, appPath);
-      try {
-        return native.nativeCaptureScreen();
-      } catch (error) {
-        throw native.normalizeNativeError(error);
-      }
-    },
-    findById,
-    findByPath,
-    getById,
-    getByPath,
-    windowAt: async (index) => {
-      assertNonNegativeIndex("index", index);
-      const processId = await waitForAtspiReady(
-        state,
-        appPath,
-        _timeoutMs,
-        Date.now()
-      );
-      try {
-        const handle = native.nativeWindowAt(processId, index);
-        return handle === void 0 ? void 0 : createGtkElement(handle);
-      } catch (error) {
-        throw native.normalizeNativeError(error);
-      }
-    },
-    getWindowCount: async () => {
-      const processId = await waitForAtspiReady(
-        state,
-        appPath,
-        _timeoutMs,
-        Date.now()
-      );
-      try {
-        return native.nativeWindowCount(processId);
-      } catch (error) {
-        throw native.normalizeNativeError(error);
-      }
-    },
-    findTrayItem,
-    getTrayItem,
-    trayItemAt: async (index) => {
-      assertNonNegativeIndex("index", index);
-      const processId = assertProcessRunning(state, appPath);
-      try {
-        const item = native.nativeTrayItems(processId)[index];
-        return item === void 0 ? void 0 : createGtkTrayItem(processId, item);
-      } catch (error) {
-        throw native.normalizeNativeError(error);
-      }
-    },
-    getTrayItemCount: async () => {
-      const processId = assertProcessRunning(state, appPath);
-      try {
-        return native.nativeTrayItems(processId).length;
-      } catch (error) {
-        throw native.normalizeNativeError(error);
-      }
-    },
-    release,
-    [Symbol.asyncDispose]: release
-  };
-  child.on("error", (error) => {
-    appendOutput(state.stderr, Buffer.from(error.message));
-  });
-  return Promise.resolve(app);
-};
-const createGtkAppLauncher = (options) => {
-  const launchedApps = [];
-  const launch = async (args) => {
-    const launchOptions = {
-      env: options.env,
-      timeoutMs: options.timeoutMs
-    };
-    const app = await launchGtkApp(
-      options.appPath,
-      [...options.args ?? [], ...args ?? []],
-      launchOptions
-    );
-    launchedApps.push(app);
-    return app;
-  };
-  const release = async () => {
-    const apps = launchedApps.splice(0);
-    await Promise.all(apps.map((app) => app.release()));
-  };
-  return {
-    launch,
-    release,
-    [Symbol.asyncDispose]: release
-  };
-};
-exports.createGtkAppEnvironment = createGtkAppEnvironment;
-exports.createGtkAppLauncher = createGtkAppLauncher;
-exports.launchGtkApp = launchGtkApp;
+const launchGtkApp = require("./launchGtkApp-BIO_5Xjn.cjs");
+exports.createGtkAppEnvironment = launchGtkApp.createGtkAppEnvironment;
+exports.createGtkAppLauncher = launchGtkApp.createGtkAppLauncher;
+exports.launchGtkApp = launchGtkApp.launchGtkApp;
 //# sourceMappingURL=index.cjs.map