winui-svelte 0.0.6 → 0.0.7

package/API.md

@@ -38,6 +38,7 @@ monorepo needs no build step (the repository is a pnpm workspace, see
 | `winui-svelte/bootstrap` | `src/window/bootstrap.ts` | `initWindowsAppSdk()`; imports nothing of WinRT, safe on the host's main thread |
 | `winui-svelte/thread` | `src/window/thread.ts` | `runOnUiThread()`; imports only dynwinrt, so the apartment comes first |
 | `winui-svelte/window` | `src/window/index.ts` | `runWindow()`, `exitApplication()`, `createWindow()`, `startTimer()`, `systemSettings()`, the picker options (see App services) |
+| `winui-svelte/window/foreground` | `src/window/foreground.ts` | `trackForeground()`, `bringWindowToFront()`, `shouldRestore()` (opt-in; see Following the foreground app) |
 | `winui-svelte/app` | `src/app/index.ts` | `ensureSingleInstance()`, `notify()`, `activateInstance()`, `activateOrLaunch()`, `launchApp()`, `startTray()`, `relaunch()`, `restartAfterCrash()` (opt-in; see App lifecycle) |
 | `winui-svelte/app/shell` | `src/app/shell/index.ts` | `trash()`, `openWith()`, `createShortcut()`, `readShortcut()`, `registerAppPath()`, `ShellFailure` (opt-in; see Shell verbs) |
 | `winui-svelte/app/activation` | `src/app/activation/index.ts` | `installProtocolHandlers()`, `registerFileTypes()`, `launchAtLogin()`, `startActivation()`, `ActivationKind` (opt-in; see Activation) |
@@ -58,11 +59,13 @@ monorepo needs no build step (the repository is a pnpm workspace, see
 | `winui-svelte/enums` | `src/enums.ts` | every closed set a prop or option takes: WinUI's enums, `ThemeBrush`, `ColorKeyword`, `Backdrop`, `WindowTheme`, `TrayBalloonIcon` and the rest (see Closed sets) |
 | `winui-svelte/win2d/context-2d` | `src/win2d/context-2d/index.ts` | `Canvas2D`, `createCanvas2D`, `CanvasElement`, `Context2D`, `Path2D` and the rest of the HTML Canvas 2D API over Win2D (opt-in; see Canvas 2D) |
 | `winui-svelte/tray` | `src/tray/index.ts` | `TrayIcon` (with its `menu`), `createTrayIcon()`, `placeMenuWindow()`, `hideToTray()`, `restoreFromTray()`, `toggleInTray()`, `removeAllTrayIcons()`, `TrayGesture` (opt-in; see System tray) |
+| `winui-svelte/progress/core` | `src/progress/core.ts` | `ProgressRegistry`, `defaultProgressRegistry()`, `ProgressOperation`, `trackOperation()`, `progressText()` and the types, with no Svelte component and no taskbar code, for a process with no window (opt-in; see Progress) |
 | `winui-svelte/tray/standalone` | `src/tray/standalone/index.ts` | `createStandaloneTray()`, `defineTray()`, its opt-in parts `balloons`, `bounds` and `themedIcon`, `MenuItemKind`, `MenuLevel`, and the `winui-svelte/app` calls that start or signal the app: a tray with no window, no WinUI and no components (opt-in; see Tray with no window) |
 | `winui-svelte/notice` | `src/notice/index.ts` | `showNotice()`, `NoticeIcon`, `NoticeButtons`, `NoticeButton`: a message box with no window or app (opt-in; see Notice with no app) |
 | `winui-svelte/forms` | `src/forms/index.ts` | `Form`, `FormField`, `textField`, `numberField`, `selectField` and the other field attachments, `formButton`, `FormValues`, `validityOf` (opt-in; see Forms) |
 | `winui-svelte/store` | `src/store/index.ts` | `getAppLicense`, `watchLicense`, `checkForUpdates`, `watchPackages`, `getStartupTask`, `getPackageInfo`: the Store and package APIs, answering `hasPackage: false` outside a package (opt-in) |
 | `winui-svelte/accessibility`, `/accessibility/audit` | `src/accessibility/index.ts`, `src/accessibility/audit/index.ts` | `announce`, `liveRegion`, `LivePriority`; `auditAccessibility`, `accessibilityRules` (opt-in; see Accessibility) |
+| `winui-svelte/automation` | `src/automation/index.ts` | `withUiaClient`, `createUiaWorker`, `readWindowText`, `UiaControlType`: a UI Automation client that reads the text of another window (opt-in; see UI Automation client) |
 | `winui-svelte/devices` | `src/devices/index.ts` | device enumeration, input devices, Bluetooth, printers, power, network, display, audio, gamepads and sensors, each also at `winui-svelte/devices/<area>` (opt-in; see Windows devices) |
 
 The table is the source layout: `exports` point at `.ts` files so the monorepo
@@ -752,6 +755,7 @@ type WindowOptions<Props> = {
   size?: { width: number; height: number };   // device pixels
   backdrop?: Backdrop;                        // "acrylic" | "acrylicBase" | "acrylicThin" | "mica" | "micaAlt" | "none" | "transparent"
   extendsIntoTitleBar?: boolean;
+  onclosing?: () => boolean | void;           // AppWindow.Closing: return true to keep the window open
   isBackground?: boolean;                     // shown without activating (tests, captures)
 } & ({ component: Component<Props>; props: Props } | { control: FrameworkElement });
 
@@ -2571,9 +2575,13 @@ An opt-in subpath: an app that does not import it does not bundle it
   redirects to it
   An app whose windows run in a worker thread passes `entryScript`, the script
   that starts the process, because `process.argv[1]` there is the worker's
+  A single executable application (a Node `node:sea` build, where
+  `process.execPath` is the app's own exe) is relaunched as the exe and
+  `arguments`, with no script and no Node flags
 - `restartAfterCrash({ arguments, conditions })` is
   `RegisterApplicationRestart`: Windows starts the same Node and entry
-  script with `arguments` after a crash, a hang, an update that closes the
+  script (a single executable: its own exe) with `arguments` after a crash,
+  a hang, an update that closes the
   app or a reboot for one; `conditions` is a subset of `RestartCondition`
   (`crash`, `hang`, `update`, `reboot`; all by default)
   Limits: no callback (a crashed Node cannot run code, so
@@ -2926,6 +2934,65 @@ const hotkey = registerHotkey({
   posts `WM_HOTKEY` to the thread itself with `PostThreadMessageW`; no key is
   pressed
 
+### Following the foreground app (`winui-svelte/window/foreground`)
+
+Opt-in; nothing runs at import
+
+```ts
+import {
+  bringWindowToFront,
+  shouldRestore,
+  trackForeground
+} from "winui-svelte/window/foreground";
+
+const tracker = trackForeground({
+  ownWindows: () => [pillHwnd],
+  onChanged: ({ hwnd, isRealApp }) => {}
+});
+tracker.lastRealApp; // bigint | null, the last real app that was in front
+tracker.current; // bigint | null
+tracker.stop(); // idempotent
+
+const isBack = shouldRestore({
+  lastRealApp: tracker.lastRealApp,
+  foreground: tracker.foreground
+});
+if (isBack && tracker.lastRealApp !== null) {
+  bringWindowToFront(tracker.lastRealApp); // true when Windows took it
+}
+```
+
+- `trackForeground({ onChanged, ownWindows, ignoredClasses, tracking,
+  intervalMilliseconds })` runs on the UI thread of a `runWindow` app
+- `tracking: "events"` (default, `ForegroundTracking.events`): the shell posts
+  a message to a hidden window of the app on each change
+  (`RegisterShellHookWindow` and `SHELLHOOK`), the message pump reads it, and
+  `GetForegroundWindow` is read once; an idle foreground costs nothing
+  dynwinrt delivers no native callbacks, so `SetWinEventHook` cannot be used
+  If Windows refuses the registration, use `tracking: "polling"`
+- `tracking: "polling"`: one `GetForegroundWindow` per `intervalMilliseconds`
+  (100 by default, 16 at least); latency is one tick
+  The class and the process of a window are read once, when it is first seen
+- The filter: a real app is not the desktop, not a shell class
+  (`ForegroundShellClass`: `Progman`, `WorkerW`, `Shell_TrayWnd`,
+  `Shell_SecondaryTrayWnd`, `CopilotKeyPressFocusFrame`), not a window of
+  this process, and not in `ownWindows()` or `ignoredClasses`
+  `lastRealApp` changes only on a real app
+- `bringWindowToFront(hwnd)` joins this thread to the foreground thread's
+  input for `BringWindowToTop` and `SetForegroundWindow`, then detaches,
+  because a hotkey's key releases went to the app in front and Windows'
+  foreground lock refuses a plain call; it restores a minimized window first,
+  sends no input and returns whether the window ended in front
+  It is best effort: a foreground window of a higher integrity level or a hung
+  one still refuses; the tray menu window takes the foreground through it
+- Not measured yet: the idle cost of each mode (the tray's 30 Hz timer costs
+  about 2 percent of a core in an idle window)
+
+Manual checklist: press the app's hotkey from Notepad, then from the desktop,
+then from a browser on a second monitor; each time the key goes back to where
+it was; then Alt+Tab to another app while the overlay is up and confirm it is
+not pulled back
+
 ### System tray (`winui-svelte/tray`)
 
 WinUI and the Windows App SDK have no notification-area API (apps call
@@ -3324,6 +3391,12 @@ createStandaloneTray({
   `bounds` when their extras are passed
   The icon keeps the process alive; `remove()` or the process ending takes it
   out of the tray
+- `colorScheme` is the menu's `color-scheme` as the web says it: `"light dark"`
+  (the default) makes the popup dark when Windows' app theme is, `"light"` and
+  `"dark"` force one; `MenuColorScheme` names the three values
+  It uses uxtheme's `SetPreferredAppMode` and `FlushMenuThemes` (ordinals 135
+  and 136), applied before each menu opens, so it affects the process's other
+  native menus too
 - The default is the smallest tray: an icon from one `.ico` path, clicks,
   `update`, `remove` and the menu
   Three parts are opt-in, each one import from the same entry, passed in
@@ -3373,8 +3446,8 @@ tray.notify({ title: "Ready" });
   here: Windows opens a submenu row without reporting a pick, and no pixel
   or file icon is drawn
   The menu is modal: the thread runs its own message loop until it closes
-  It does not follow a dark system theme, which a native popup menu does not
-  without an undocumented call; a menu that must match the theme belongs in
+  `colorScheme` makes it follow the system theme through an undocumented
+  uxtheme call; a menu that must be drawn in WinUI belongs in
   `winui-svelte/tray` with `TrayIcon`'s `menu` snippet
 - The same entry re-exports `activateInstance`, `activateOrLaunch` and
   `launchApp` from `winui-svelte/app` (App lifecycle), so a tray imports from
@@ -3385,6 +3458,76 @@ tray.notify({ title: "Ready" });
   component, window or renderer module, or a component's name, is in the
   output, or if it grows past its budget
 
+### Trays and windows are independent
+
+Neither needs the other
+A process can have zero windows and several tray icons, or windows and
+taskbar buttons and no tray; nothing is created for the part you leave out
+
+```ts
+// Zero windows, two icons, one Node process
+import { createStandaloneTray, MenuColorScheme, MenuItemKind } from "winui-svelte/tray/standalone";
+import { defaultProgressRegistry, progressText } from "winui-svelte/progress/core";
+
+createStandaloneTray({
+  icon: "recorder.ico",
+  tooltip: "Recorder",
+  colorScheme: MenuColorScheme.DARK,
+  menu: () => [{
+    kind: MenuItemKind.COMMAND,
+    id: "status",
+    label: progressText(defaultProgressRegistry().snapshot),
+    onselect() {}
+  }]
+});
+
+createStandaloneTray({
+  icon: "uploads.ico",
+  tooltip: "Uploads",
+  colorScheme: MenuColorScheme.LIGHT,
+  menu: [{ kind: MenuItemKind.COMMAND, id: "quit", label: "Quit", onselect: () => process.exit(0) }]
+});
+```
+
+```svelte
+<!-- Windows and a taskbar button, no tray -->
+<script lang="ts">
+  import { Window } from "winui-svelte/components";
+  import { TaskbarProgress } from "winui-svelte/progress";
+</script>
+
+<Window>
+  <TaskbarProgress />
+</Window>
+```
+
+- Each `createStandaloneTray` has an identity of its own (its own hidden owner
+  window and a unique id, and its own `guid` when you pass one), its own
+  timer, its own menu and its own state; `remove()` takes out that icon only
+  and the exit hook takes out all of them
+- Clicks are polled, and Windows keeps one "pressed since the last read"
+  flag for the whole process, which the first read clears; the trays of a
+  process share that read, so each icon hears a click shorter than its
+  polling interval (the flag can still be cleared by another process or by
+  other code of yours that calls `GetAsyncKeyState`)
+- The menu theme is one setting per process (uxtheme's preferred app mode);
+  a tray sets its own `colorScheme` right before each of its menus opens, so
+  two trays with different schemes each get theirs, because only one menu is
+  open at a time
+  The setting then stays until the next menu opens, so another popup menu in
+  the same process (a window's) shows in the scheme of the tray that spoke
+  last
+- `winui-svelte/progress/core` is the progress registry, operations and
+  `progressText` with no Svelte component and no taskbar code, so a
+  tray-only process can show progress; `winui-svelte/progress` adds
+  `TaskbarProgress` and `bindTaskbarProgress`, which are the only part that
+  needs a window
+- `scripts/pack/independence.test.ts` walks the imports and fails if the
+  standalone tray reaches a component, the renderer, the window runtime or
+  taskbar code, if the taskbar progress reaches a tray, or if a window
+  reaches a tray; `scripts/pack/tray-only.test.ts` bundles two trays with the
+  registry and fails on the same, or on a growing size
+
 ### Tray as an entrypoint (`entrypoints/tray.ts`)
 
 The app does not have to know it has a tray; the tray is its own file, found
@@ -3425,6 +3568,14 @@ export default defineTray({
 - `guid` is required: it keeps the icon's place in the tray and names the one
   tray process, so a second `tray.js` exits at once
 - `onactivate` runs on a left click when `onclick` is not given
+- `export default [defineTray({ ... }), defineTray({ ... })]` defines several
+  trays in one entrypoint: one `tray.js`, one process, each tray with its own
+  `guid`, icon, tooltip, menu and `colorScheme` (every `guid` must differ)
+  The first tray's `guid` names the process, so keep the order; `tray.json` is
+  the single manifest for one tray and `{ "trays": [ ... ] }` for several, and
+  `startTray()` reads the first `guid` from either
+  The markup form (`tray.svelte`) is one tray; use `tray.ts` for several
+  `examples/tray-multiple` is a two-icon entrypoint with no window
 - The build reads `icon`, `tooltip` and `guid` from the syntax tree, never by
   running the file, so a top-level import of WinRT in `tray.ts` does not
   execute at build; `icon` and `guid` must be string literals, and the icon a
@@ -4556,6 +4707,170 @@ takes drops, through the handlers a real drop reaches, and resolves with the
 operation the control accepted (`0` when it refused); it sends no input, so an
 app can test its drop handling in a real window
 
+## Progress (`winui-svelte/progress`)
+
+One progress object for any long work: a download, a file read, a copy, an OCR
+pass; it is a promise, an `EventTarget` with the platform events, and
+reactive state, in one value
+Operations list themselves in an app-wide registry, so the taskbar button and
+the tray show them with no setup
+Opt-in: nothing is bundled until an app imports it, and importing does no work
+
+### Five call sites
+
+```svelte
+<script lang="ts">
+  import { Button, ProgressBar, TextBlock, Window } from "winui-svelte/components";
+  import { fetchToFile } from "winui-svelte/downloads";
+  import { TaskbarProgress } from "winui-svelte/progress";
+
+  // 1. A download with a bar: fetchToFile returns the operation at once
+  const download = fetchToFile({ url, handle });
+  download.then(size => console.log("saved", size));   // or: await download
+</script>
+
+<Window>
+  <TaskbarProgress />                           <!-- 4. the taskbar shows every running operation -->
+  <ProgressBar {...download.barProps} />        <!-- value, isIndeterminate, showPaused, showError -->
+  <TextBlock>{download.loaded} of {download.total ?? "?"}</TextBlock>
+  <Button onclick={() => download.cancel()}>Cancel</Button>
+</Window>
+```
+
+```ts
+// 2. Reading a file from disk, with progress and cancel
+const read = handle.read({ onprogress: event => console.log(event.loaded, event.total) });
+const file = await read;                 // a File, like getFile()
+read.cancel();                           // or abort the signal given in the options
+
+// 3. Any other long work: one call, no lifecycle code
+const copy = trackOperation({
+  label: "Copying photos",
+  group: "sync",
+  async run(operation) {
+    for await (const chunk of source) {
+      await write(chunk);
+      operation.update({ loaded: (written += chunk.byteLength), total });
+      operation.signal.throwIfAborted();
+    }
+  }
+});
+
+// 5. Retry: a failed fetchToFile continues where it stopped
+await fetchToFile({ url, handle, resume: true });
+```
+
+```svelte
+<!-- Tray menu, in tray.svelte markup -->
+<TrayMenu>
+  <TrayMenuProgress id="progress" />                  <!-- "setup.exe - 45%", hidden when idle -->
+  <TrayMenuOperations id="operations" label="Running" emptyLabel="Nothing running" />
+</TrayMenu>
+```
+
+`{...download.barProps}` spreads onto a `ProgressBar`; Svelte then cannot tell
+at build time whether a scoped class selector matches that bar, so write the
+five props out when the same component has a `<style>` rule for its siblings
+
+### Several windows and tray icons
+
+The registry is app-wide; what a taskbar button or a tray line shows is scoped
+by `group` (a name an operation is given) or by an operation or registry given
+as `of`
+A `<TaskbarProgress />` drives the taskbar button of the window it sits in;
+`window={handle}` picks another
+
+```svelte
+<script lang="ts">
+  const upload = trackOperation({ group: "uploads", run });
+  const download = fetchToFile({ url, handle, group: "downloads" });
+</script>
+
+<!-- Window A: its taskbar button shows the downloads only -->
+<Window bind:handle={windowA}>
+  <TaskbarProgress group="downloads" />
+</Window>
+
+<!-- Window B: its own button shows one upload; window A is not touched -->
+<Window>
+  <TaskbarProgress of={upload} />
+</Window>
+
+<!-- The main window drives window A from outside -->
+<TaskbarProgress window={windowA} group="downloads" />
+
+<!-- Two tray icons, each with its own menu and its own scope -->
+<TrayIcon>
+  <TrayMenu>
+    <TrayMenuProgress id="downloads" group="downloads" />
+  </TrayMenu>
+</TrayIcon>
+<TrayIcon>
+  <TrayMenu>
+    <TrayMenuOperations id="uploads" label="Uploads" group="uploads" />
+  </TrayMenu>
+</TrayIcon>
+```
+
+### `ProgressOperation`
+
+- It is `PromiseLike`: `await operation` gives the value passed to `complete`
+  and throws the reason of `fail` or `cancel` (an `AbortError` by default); an
+  operation nobody awaits raises no unhandled rejection
+- It is an `EventTarget` that fires `loadstart`, `progress`, `load`, `error`,
+  `abort` and `loadend` as `OperationProgressEvent` (`lengthComputable`,
+  `loaded`, `total`), in the order `XMLHttpRequest` and `FileReader` use, plus
+  `pause`, `resume` and `change`; `onprogress` and its kin work as properties
+  and as options
+- `value` (0 to 1), `loaded`, `total`, `state`, `isIndeterminate`,
+  `showPaused`, `showError`, `label` and `barProps` are reactive in markup and
+  in `$effect`, with the meaning `ProgressBar` gives them: a total that is
+  unknown is indeterminate
+- `$operation` works too: it has `subscribe` and so is a Svelte store
+- `signal` is an `AbortSignal` that aborts on `cancel()`; a `signal` given to
+  the constructor cancels the operation when it aborts
+- `start`, `update({ loaded, total })`, `pause`, `resume`, `complete(value)`
+  and `fail(reason)` are for the code doing the work; `resume` also retries an
+  errored operation (the other final states are final)
+- `ProgressState` is the closed set of states: `idle`, `running`, `paused`,
+  `complete`, `error`, `canceled`
+
+### Registry and scopes
+
+- `defaultProgressRegistry()` is the app-wide registry; an operation lists
+  itself there unless it gets `registry: otherRegistry` or `registry: false`
+- A finished or canceled operation leaves; a failed one stays so a red bar
+  is not lost, until `clearFailed()` or `remove(operation)`
+- `registry.where("sync")` or `registry.where(operation => ...)` is a scoped
+  registry that follows the first (call `dispose()` when done);
+  `<TaskbarProgress group>` and the tray components do this for you
+- `snapshot`, `value`, `count`, `state`, `isIndeterminate`, `showPaused` and
+  `showError` are the aggregate: the bar covers the operations that know their
+  total, and is indeterminate only when none does; `paused` when all that are
+  left are paused; `error` when only failed ones are left; `count` is the
+  number unfinished
+- `aggregateSnapshots` is that rule as a pure function
+
+### Taskbar and tray
+
+- `<TaskbarProgress of group window taskbar />` draws nothing and keeps the
+  taskbar button in step: a bar, a marquee when the total is unknown, paused
+  yellow, error red, gone when nothing is left; the shell is told only when the
+  bar moves by a thousandth
+- `bindTaskbarProgress({ source, taskbar })` is the same without markup (the
+  `taskbar` option of `Downloads.download` uses it); `taskbarOptionsOf` is the
+  mapping
+- `<TrayMenuProgress id of group />` is a command line with the text of
+  `progressText(snapshot)`, hidden while nothing runs; `onselect` is yours
+- `<TrayMenuOperations id label of group />` is a submenu with a line per
+  running operation; picking a line cancels it
+- `Downloads` gives each download an operation (`progress: registry` in its
+  options picks the registry, `group` in `download({ ... })` the group), and
+  `fetchToFile` returns one; `FileSystemFileHandle.read` is the extra (WinUI
+  only) that reads a file in 1 MiB chunks
+- `trackStream({ stream, operation })` passes a `ReadableStream` through and
+  reports the bytes; `trackOperation` is the whole lifecycle for any async work
+
 ## Incremental loading (`winui-svelte/incremental`)
 
 A list that loads its next batch as the user scrolls near the end, for
@@ -6331,6 +6646,78 @@ The working example is `examples/win2d` (`test/win2d.test.ts` runs it in a real
 window and checks the redraw; `src/win2d/win2d.test.ts` draws on a render
 target and checks the pixels)
 
+## UI Automation client (`winui-svelte/automation`)
+
+Read the exact text and headings of another window, instead of OCR; the
+counterpart of the Accessibility section, which provides automation to
+others, while this one consumes it; no web API reads another application's
+window, so this mirrors none; it is opt-in and bundles COM only when imported
+
+```ts
+import { createUiaWorker } from "winui-svelte/automation";
+
+const worker = createUiaWorker();
+const text = await worker.readText({
+  target: "foreground",
+  excludeProcessId: process.pid,
+  hardMilliseconds: 1500
+});
+// { title, blocks: [{ kind: "heading", level: 1, text }, ...], version, end }
+```
+
+`readText` runs in a worker thread in the multithreaded COM apartment; a target
+that hangs makes the call reject with `UiaTimeout` after `hardMilliseconds`,
+the worker is ended and the next call starts a new one (a blocked COM call
+cannot be cancelled); it resolves null when there is no window to read, the
+window is the excluded process's or an elevated one
+
+For the lower level, `withUiaClient` gives a client on the calling thread
+(call it from a thread that joined a COM apartment) and releases every COM
+pointer it made when the callback ends:
+
+```ts
+import { UiaControlType, withUiaClient } from "winui-svelte/automation";
+
+const lines = await withUiaClient(client => {
+  const root = client.elementFromHandle(hwnd);
+  if (root === null) {
+    return [];
+  }
+
+  const found: string[] = [];
+  const walk = client.walk({
+    root,
+    maxElements: 400,
+    maxMilliseconds: 400,
+    shouldVisit: ({ controlType, isOffscreen }) => !isOffscreen && controlType !== UiaControlType.button
+  });
+  for (const node of walk) {
+    const ranges = node.pattern("text")?.visibleRanges() ?? [];
+    found.push(...ranges.map(range => range.getText(1000)));
+  }
+
+  return found;
+});
+```
+
+| Call | What |
+|---|---|
+| `withUiaClient(use)` | creates `CUIAutomation`, runs `use(client)`, releases everything; an element used after that throws `UiaScopeEndedError` |
+| `client.elementFromHandle(hwnd)`, `client.focusedElement()` | an element, or null when it is gone or cannot be read |
+| `element.properties()` | `name`, `className`, `automationId`, `controlType`, `processId`, `isOffscreen`, `boundingRectangle`, `headingLevel` (0 for none, 1 to 9), `hasTextPattern`, `hasValuePattern` |
+| `client.walk({ root, maxElements, maxMilliseconds, shouldVisit })` | breadth first over the control view, one cached call per parent (`FindAllBuildCache`); `walk.end` is `complete`, `maxElements` or `deadline`; an element that went away is skipped; `node.skipSubtree()` prunes |
+| `element.pattern("text")` | `visibleRanges()`, `documentRange()`, and `range.getText(maxLength)` |
+| `element.pattern("value")` | `value` |
+| `readWindowText({ client, root })` | the headings and text of a window, skipping chrome and off screen elements (`UIA_CHROME_CONTROL_TYPES`); `version` changes when the text does |
+| `createUiaWorker()` | `readText({ target, excludeProcessId, hardMilliseconds, ... })` with the hard deadline; `close()` |
+| `UiaControlType`, `UiaPropertyId`, `UiaPatternName`, `HEADING_LEVEL_NONE`, `HEADING_LEVEL_FIRST` | the header's ids as `as const` sets and constants (the sets also under `winui-svelte/enums`) |
+| `UiaWalkEnd`, `TextBlockKind`, `UiaTarget` | the closed sets of a walk's end, a block's kind and a worker target (`foreground`, `focused`, or `{ hwnd }`) |
+| `UiaElementUnavailableError`, `UiaScopeEndedError`, `UiaTimeout` | the errors: an element went away, a client was used after its scope, a target did not answer in time |
+
+Elements an app cannot read (elevated windows) come back as null, never an
+exception; browsers and Electron build their tree when the first client asks,
+so the first walk of such a window can be slower
+
 ## Windows devices (`winui-svelte/devices`)
 
 Windows' own device APIs (`Windows.Devices.*`, `Windows.System.Power`,

package/README.md

@@ -882,6 +882,8 @@ conditions on `exports`), which your Vite compiles (`winuiSvelte()`)
 | `winui-svelte/chrome/permissions` | `ChromePermissions`: `chrome.permissions` (`getAll`, `contains`, `request`, `remove`, `onAdded`, `onRemoved`) over the Permissions API providers and the OS consent; the grants are saved in the app's data folder (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#chromepermissions-winui-sveltechromepermissions)) |
 | `winui-svelte/chrome/context-menus` | `ChromeContextMenus`: `chrome.contextMenus` (`create`, `update`, `remove`, `removeAll`, `onClicked`; normal, checkbox, radio and separator items, `contexts`, `parentId`) drawn by the tray menu model, for the tray icon and a window's context flyout (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#chromecontextmenus-winui-sveltechromecontext-menus)) |
 | `winui-svelte/downloads` | `Downloads`: `chrome.downloads` with the same names and shapes, and `fetchToFile` for `showSaveFilePicker` handles; streamed, resumable, with the Mark of the Web and optional taskbar progress (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#downloads-winui-sveltedownloads)) |
+| `winui-svelte/progress/core` | The registry, `ProgressOperation`, `trackOperation` and `progressText` of `winui-svelte/progress` without `<TaskbarProgress />`: no Svelte component and no window code, for a tray-only process (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#trays-and-windows-are-independent)) |
+| `winui-svelte/progress` | `ProgressOperation` (a promise, an `EventTarget` with `progress` and `loadend`, and reactive `value`), `ProgressRegistry`, `<TaskbarProgress />`, `trackOperation`; downloads, file reads and your own work report through it, scoped by group per window or tray icon (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#progress-winui-svelteprogress)) |
 | `winui-svelte/chrome/runtime` | `Runtime`: `chrome.runtime` for a native app (manifest, messages and ports between the app's contexts, native messaging hosts, `onInstalled`, `onStartup`, `onSuspend`) (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#chrome-runtime-winui-sveltechromeruntime)) |
 | `winui-svelte/chrome/notifications` | `ChromeNotifications`: `chrome.notifications` (`create`, `update`, `clear`, `getAll`, `getPermissionLevel`, `onClicked`, `onButtonClicked`, `onClosed`; basic, image, list and progress templates, buttons) over the web `Notification`, one notification pipeline (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#chrome-notifications-winui-sveltechromenotifications)) |
 | `winui-svelte/chrome/commands` | `ChromeCommands`: `chrome.commands` (`getAll`, `onCommand`) with `suggested_key` shortcuts as global hotkeys (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#chrome-commands-winui-sveltechromecommands)) |
@@ -900,9 +902,11 @@ conditions on `exports`), which your Vite compiles (`winuiSvelte()`)
 | `winui-svelte/tray/standalone` | `createStandaloneTray`: a notification-area icon and a native popup menu, the model of `winui-svelte/tray/menu` (levels and a user profile when you pass `resolve: resolveMenu`; balloons, `bounds` and a light and dark icon pair when you pass `balloons`, `bounds` and `themedIcon` in `extras`), in a plain Node process, with no window, no WinUI and no components, that starts or signals the full app; `defineTray` for `entrypoints/tray.ts`, or the menu as markup in `entrypoints/tray.svelte`, lowered at build with no Svelte runtime: a tray the build bundles apart so the app never imports it (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#tray-with-no-window-winui-sveltetraystandalone), [entrypoint](https://github.com/avi12/winui-svelte/blob/main/API.md#tray-as-an-entrypoint-entrypointstrayts)) |
 | `winui-svelte/notice` | `showNotice`: a message box with no window or app, for a check that ends a run before it starts (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#notice-with-no-app-winui-sveltenotice)) |
 | `winui-svelte/window/taskbar` | `handle.taskbar`: a progress bar, an overlay icon or badge, flashing and the thumbnail's tooltip and clip on the window's taskbar button, and the unpackaged `setAppBadge` fallback (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#taskbar-button-winui-sveltewindowtaskbar)) |
+| `winui-svelte/window/foreground` | `trackForeground`: which app is in front, event driven, ignoring the shell and the app's own windows, and `bringWindowToFront` for another app's window (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#following-the-foreground-app-winui-sveltewindowforeground)) |
 | `winui-svelte/forms` | `Form`, `FormField` and the attachments that join a control to a form by name, with HTML's constraint validation and zod (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#forms-winui-svelteforms)) |
 | `winui-svelte/store` | `getAppLicense`, `watchLicense`, `checkForUpdates`, `watchPackages`, `getStartupTask`: the Store licence, updates, package events and startup task, answering `hasPackage: false` outside a package (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#store-and-package-winui-sveltestore)) |
 | `winui-svelte/accessibility`, `/accessibility/audit` | `announce` and `liveRegion` say a change to a screen reader (`aria-live`, `role="alert"`) over UI Automation notifications; `auditAccessibility` checks a window for unnamed buttons, unlabeled inputs, duplicate access keys and low contrast (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#accessibility-winui-svelteaccessibility)) |
+| `winui-svelte/automation` | `createUiaWorker` and `withUiaClient` read the exact text and headings of another window over UI Automation (a worker with a hard deadline, so a hung app cannot stall yours); [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#ui-automation-client-winui-svelteautomation) |
 | `winui-svelte/devices`, `/devices/enumeration`, `/devices/input`, `/devices/bluetooth`, `/devices/printers`, `/devices/power`, `/devices/network`, `/devices/audio`, `/devices/display`, `/devices/gamepad`, `/devices/sensors` | device enumeration, input devices, Bluetooth, printers, power, network, displays, audio, gamepads, sensors: Windows' own device APIs as runes (opt-in; [`API.md`](https://github.com/avi12/winui-svelte/blob/main/API.md#windows-devices-winui-sveltedevices)) |
 | `winui-svelte/implicit-layout-animation` | `implicitLayoutAnimation`, `LayoutEasing`: the children of a panel slide to their new places when the layout moves them |
 | `winui-svelte/settings` | `SettingsCard`, `SettingsExpander`: Fluent settings cards after the Community Toolkit's |

package/dist/app/launch-command.d.ts

@@ -29,18 +29,23 @@ export declare function commandOf({ executable, nodeFlags, script, appArguments
 };
 /**
  * The command that starts this app again, copied from the running process.
+ * A single executable application (a Node `node:sea` build) is its own
+ * program: `process.execPath` is the exe, it has no entry script and takes no
+ * Node flags, so the command is the exe and the app's arguments.
  *
- * @param options - The arguments the new copy gets, and the entry script when
- *   it is not `process.argv[1]`.
+ * @param options - The arguments the new copy gets, the entry script when it
+ *   is not `process.argv[1]`, and `isSingleExecutable` (the running process's
+ *   answer by default; a test stands in).
  * @returns The program and its arguments.
- * @throws {Error} When the process has no entry script (an interactive
- *   session).
+ * @throws {Error} When the process has no entry script and is not a single
+ *   executable (an interactive session).
  */
-export declare function launchCommand({ appArguments, entryScript }: {
+export declare function launchCommand({ appArguments, entryScript, isSingleExecutable }: {
     appArguments: readonly string[];
     entryScript?: string | undefined;
+    isSingleExecutable?: boolean;
 }): {
     executable: string;
-    arguments: string[];
+    arguments: readonly string[];
 };
 //# sourceMappingURL=launch-command.d.ts.map

package/dist/app/launch-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"launch-command.d.ts","sourceRoot":"","sources":["../../src/app/launch-command.ts"],"names":[],"mappings":"AAOA,+DAA+D;AAC/D,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAcD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,UAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE;IACzE,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;;;EAKA;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,EAAE,YAAY,EAAE,WAA6B,EAAE,EAAE;IAC7E,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;;;EAYA"}
+{"version":3,"file":"launch-command.d.ts","sourceRoot":"","sources":["../../src/app/launch-command.ts"],"names":[],"mappings":"AASA,+DAA+D;AAC/D,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAcD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,UAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE;IACzE,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;;;EAKA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,EAAE,YAAY,EAAE,WAA6B,EAAE,kBAA4B,EAAE,EAAE;IAC3G,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;;;EAmBA"}

package/dist/app/launch-command.js

@@ -1,3 +1,4 @@
+import { isSea } from "node:sea";
 const SPACE = " ";
 const QUOTE = "\"";
 const BACKSLASH = "\\";
@@ -39,14 +40,24 @@ export function commandOf({ executable, nodeFlags, script, appArguments }) {
 }
 /**
  * The command that starts this app again, copied from the running process.
+ * A single executable application (a Node `node:sea` build) is its own
+ * program: `process.execPath` is the exe, it has no entry script and takes no
+ * Node flags, so the command is the exe and the app's arguments.
  *
- * @param options - The arguments the new copy gets, and the entry script when
- *   it is not `process.argv[1]`.
+ * @param options - The arguments the new copy gets, the entry script when it
+ *   is not `process.argv[1]`, and `isSingleExecutable` (the running process's
+ *   answer by default; a test stands in).
  * @returns The program and its arguments.
- * @throws {Error} When the process has no entry script (an interactive
- *   session).
+ * @throws {Error} When the process has no entry script and is not a single
+ *   executable (an interactive session).
  */
-export function launchCommand({ appArguments, entryScript = process.argv[1] }) {
+export function launchCommand({ appArguments, entryScript = process.argv[1], isSingleExecutable = isSea() }) {
+    if (isSingleExecutable) {
+        return {
+            executable: process.execPath,
+            arguments: appArguments
+        };
+    }
     const isScriptMissing = entryScript === undefined;
     if (isScriptMissing) {
         throw new Error("relaunch and restartAfterCrash need a process started from a script");

package/dist/app/launch-command.js.map

@@ -1 +1 @@
-{"version":3,"file":"launch-command.js","sourceRoot":"","sources":["../../src/app/launch-command.ts"],"names":[],"mappings":"AAAA,MAAM,KAAK,GAAG,GAAG,CAAC;AAClB,MAAM,KAAK,GAAG,IAAI,CAAC;AACnB,MAAM,SAAS,GAAG,IAAI,CAAC;AACvB,MAAM,YAAY,GAAG,QAAQ,CAAC;AAC9B,MAAM,oBAAoB,GAAG,SAAS,CAAC;AACvC,MAAM,wBAAwB,GAAG,UAAU,CAAC;AAQ5C,SAAS,aAAa,CAAC,QAAgB;IACrC,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACpE,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,MAAM,OAAO,GAAG,QAAQ;SACrB,OAAO,CAAC,wBAAwB,EAAE,CAAC,MAAM,EAAE,WAAmB,EAAE,EAAE,CAAC,GAAG,WAAW,GAAG,WAAW,GAAG,SAAS,GAAG,KAAK,EAAE,CAAC;SACtH,OAAO,CAAC,oBAAoB,EAAE,CAAC,MAAM,EAAE,WAAmB,EAAE,EAAE,CAAC,GAAG,WAAW,GAAG,WAAW,EAAE,CAAC,CAAC;IAClG,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,KAAK,EAAE,CAAC;AACtC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,YAA+B;IAC7D,OAAO,YAAY,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAKtE;IACC,OAAO;QACL,UAAU;QACV,SAAS,EAAE,CAAC,GAAG,SAAS,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC;KAC3B,CAAC;AAC5B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,EAAE,YAAY,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAG1E;IACC,MAAM,eAAe,GAAG,WAAW,KAAK,SAAS,CAAC;IAClD,IAAI,eAAe,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;IACzF,CAAC;IAED,OAAO,SAAS,CAAC;QACf,UAAU,EAAE,OAAO,CAAC,QAAQ;QAC5B,SAAS,EAAE,OAAO,CAAC,QAAQ;QAC3B,MAAM,EAAE,WAAW;QACnB,YAAY;KACb,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"launch-command.js","sourceRoot":"","sources":["../../src/app/launch-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,MAAM,KAAK,GAAG,GAAG,CAAC;AAClB,MAAM,KAAK,GAAG,IAAI,CAAC;AACnB,MAAM,SAAS,GAAG,IAAI,CAAC;AACvB,MAAM,YAAY,GAAG,QAAQ,CAAC;AAC9B,MAAM,oBAAoB,GAAG,SAAS,CAAC;AACvC,MAAM,wBAAwB,GAAG,UAAU,CAAC;AAQ5C,SAAS,aAAa,CAAC,QAAgB;IACrC,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACpE,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,MAAM,OAAO,GAAG,QAAQ;SACrB,OAAO,CAAC,wBAAwB,EAAE,CAAC,MAAM,EAAE,WAAmB,EAAE,EAAE,CAAC,GAAG,WAAW,GAAG,WAAW,GAAG,SAAS,GAAG,KAAK,EAAE,CAAC;SACtH,OAAO,CAAC,oBAAoB,EAAE,CAAC,MAAM,EAAE,WAAmB,EAAE,EAAE,CAAC,GAAG,WAAW,GAAG,WAAW,EAAE,CAAC,CAAC;IAClG,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,KAAK,EAAE,CAAC;AACtC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,YAA+B;IAC7D,OAAO,YAAY,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAKtE;IACC,OAAO;QACL,UAAU;QACV,SAAS,EAAE,CAAC,GAAG,SAAS,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC;KAC3B,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAAC,EAAE,YAAY,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,kBAAkB,GAAG,KAAK,EAAE,EAIxG;IACC,IAAI,kBAAkB,EAAE,CAAC;QACvB,OAAO;YACL,UAAU,EAAE,OAAO,CAAC,QAAQ;YAC5B,SAAS,EAAE,YAAY;SACA,CAAC;IAC5B,CAAC;IAED,MAAM,eAAe,GAAG,WAAW,KAAK,SAAS,CAAC;IAClD,IAAI,eAAe,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;IACzF,CAAC;IAED,OAAO,SAAS,CAAC;QACf,UAAU,EAAE,OAAO,CAAC,QAAQ;QAC5B,SAAS,EAAE,OAAO,CAAC,QAAQ;QAC3B,MAAM,EAAE,WAAW;QACnB,YAAY;KACb,CAAC,CAAC;AACL,CAAC"}

package/dist/app/tray-instance.d.ts

@@ -8,8 +8,9 @@ import { activateOrLaunch } from "./activate.js";
  */
 export declare function trayInstanceKey(guid: string): string;
 /**
- * Claims the right to be the one tray process for `guid`: the built `tray.js`
- * calls it first. A second copy finds the first and gets false, and exits.
+ * Claims the right to be the one tray process for `guid` (the first tray's,
+ * when the entrypoint defines several): the built `tray.js` calls it first.
+ * A second copy finds the first and gets false, and exits.
  * Needs no window or UI thread.
  *
  * @param options - The tray's guid.
@@ -27,7 +28,7 @@ export interface StartTrayOptions {
 }
 /**
  * Starts the built `tray.js` as a process of its own, once: when one runs for
- * the same `guid` nothing starts. Optional, and never needed by the app's
+ * the same process guid nothing starts. Optional, and never needed by the app's
  * code: an installer, a launcher or the app's own `main` may call it.
  *
  * @param options - The folder of the build.

package/dist/app/tray-instance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tray-instance.d.ts","sourceRoot":"","sources":["../../src/app/tray-instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AASjD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,UAE3C;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,WAY3D;AAED,8BAA8B;AAC9B,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B,+FAA+F;IAC/F,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,gBAAgB,CAAC;CAC7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,EAAE,SAAyB,EAAE,QAA2B,EAAE,GAAE,gBAAqB,oBAc1G"}
+{"version":3,"file":"tray-instance.d.ts","sourceRoot":"","sources":["../../src/app/tray-instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AASjD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,UAE3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,WAY3D;AAED,8BAA8B;AAC9B,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B,+FAA+F;IAC/F,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,gBAAgB,CAAC;CAC7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,EAAE,SAAyB,EAAE,QAA2B,EAAE,GAAE,gBAAqB,oBAe1G"}