@embedpdf/vue 0.0.0-stage → 3.0.0-next.15

package/dist/commands.d.cts

@@ -0,0 +1,61 @@
+/**
+ * @embedpdf/vue/commands: the Vue surface of `@embedpdf/plugin-commands`. The
+ * standard commands, a command as a button needs it, the settings, and keyboard
+ * shortcuts. A command's state is derived from live state on read, so
+ * `useCommand` re-reads it on the kernel's one change stream and its ref
+ * changes only when what the command shows changed.
+ */
+export * from '@embedpdf/plugin-commands';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { BoundCommand, CommandId, CommandRefusal, CommandsCapability } from '@embedpdf/plugin-commands';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The commands every viewer has: zoom, pages, view rotation, `tool:<id>` for every tool, copy,
+ * delete, download and print, with shortcuts and labels in EmbedPDF's eight languages. Spread
+ * them into `commandsPlugin({ commands })`.
+ */
+export declare const standardCommands: readonly (import("@embedpdf/plugin-commands").CommandDef | import("@embedpdf/plugin-commands").CommandFamily)[];
+/** The commands API: `execute`, `searchCommands`, `registerCommand`, the categories, the settings calls. The object never changes. */
+export declare function useCommands(): CommandsCapability;
+/** Subscribe to one commands event while the component lives: `useCommandsEvent((commands) => commands.onExecuted, handler)`. */
+export declare function useCommandsEvent<Event>(select: (commands: CommandsCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The commands settings (`commands`, `disabledCategories`, `disabledCommands`, `notAllowed`) as refs,
+ * with or without a document. Takes a selector.
+ */
+export declare const useCommandsSettings: import("./state.cjs").SettingsComposable<import("@embedpdf/plugin-commands").CommandsSettings & object>;
+/** A shortcut as a tooltip shows it, for this platform: `'⌘K'` on a Mac, `'Ctrl+K'` elsewhere. */
+export declare function formatShortcut(shortcut: string, options?: {
+    isMac?: boolean;
+}): string;
+/**
+ * A command for this component's document (the nearest `<DocumentScope>`, else
+ * the active one), as a ref: its label, icon, state, `run` and `shortcut`. Pass
+ * a getter to follow a prop: `useCommand(() => props.id)`. The ref changes only
+ * when what the command shows does. Always a command: an id no plugin
+ * registered is labelled with its id, neither visible nor enabled, and warns
+ * once in development.
+ */
+export declare function useCommand(id: MaybeRefOrGetter<string>): Readonly<Ref<BoundCommand>>;
+/** Where {@link useCommandShortcuts} listens, and how it reads `Mod`. */
+export interface CommandShortcutsOptions {
+    /** Whether `Mod` is Cmd (a Mac) or Ctrl. Default: what the browser says. */
+    isMac?: MaybeRefOrGetter<boolean | undefined>;
+    /**
+     * Listen only while focus is inside this element (a template ref), for a
+     * page with more than one viewer. The keys work once it has mounted.
+     */
+    target?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+    /** Called when a key's command is turned off or not allowed, with why: say so to the user. */
+    onRefused?: (commandId: CommandId, refusal: CommandRefusal) => void;
+}
+/**
+ * Turn every command's shortcut into a working key, for the active document.
+ * Call it once, near the top of your viewer. Keys typed into text fields are
+ * left alone, and so is a key whose command can't run right now. A command
+ * that's turned off or not allowed still takes its key, and `onRefused` says
+ * why. The keys work anywhere on the page; with `target`, only while focus is
+ * inside that element.
+ * They stop when the component unmounts.
+ */
+export declare function useCommandShortcuts(options?: CommandShortcutsOptions): void;

package/dist/commands.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @embedpdf/vue/commands: the Vue surface of `@embedpdf/plugin-commands`. The
+ * standard commands, a command as a button needs it, the settings, and keyboard
+ * shortcuts. A command's state is derived from live state on read, so
+ * `useCommand` re-reads it on the kernel's one change stream and its ref
+ * changes only when what the command shows changed.
+ */
+export * from '@embedpdf/plugin-commands';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { BoundCommand, CommandId, CommandRefusal, CommandsCapability } from '@embedpdf/plugin-commands';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The commands every viewer has: zoom, pages, view rotation, `tool:<id>` for every tool, copy,
+ * delete, download and print, with shortcuts and labels in EmbedPDF's eight languages. Spread
+ * them into `commandsPlugin({ commands })`.
+ */
+export declare const standardCommands: readonly (import("@embedpdf/plugin-commands").CommandDef | import("@embedpdf/plugin-commands").CommandFamily)[];
+/** The commands API: `execute`, `searchCommands`, `registerCommand`, the categories, the settings calls. The object never changes. */
+export declare function useCommands(): CommandsCapability;
+/** Subscribe to one commands event while the component lives: `useCommandsEvent((commands) => commands.onExecuted, handler)`. */
+export declare function useCommandsEvent<Event>(select: (commands: CommandsCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The commands settings (`commands`, `disabledCategories`, `disabledCommands`, `notAllowed`) as refs,
+ * with or without a document. Takes a selector.
+ */
+export declare const useCommandsSettings: import("./state.js").SettingsComposable<import("@embedpdf/plugin-commands").CommandsSettings & object>;
+/** A shortcut as a tooltip shows it, for this platform: `'⌘K'` on a Mac, `'Ctrl+K'` elsewhere. */
+export declare function formatShortcut(shortcut: string, options?: {
+    isMac?: boolean;
+}): string;
+/**
+ * A command for this component's document (the nearest `<DocumentScope>`, else
+ * the active one), as a ref: its label, icon, state, `run` and `shortcut`. Pass
+ * a getter to follow a prop: `useCommand(() => props.id)`. The ref changes only
+ * when what the command shows does. Always a command: an id no plugin
+ * registered is labelled with its id, neither visible nor enabled, and warns
+ * once in development.
+ */
+export declare function useCommand(id: MaybeRefOrGetter<string>): Readonly<Ref<BoundCommand>>;
+/** Where {@link useCommandShortcuts} listens, and how it reads `Mod`. */
+export interface CommandShortcutsOptions {
+    /** Whether `Mod` is Cmd (a Mac) or Ctrl. Default: what the browser says. */
+    isMac?: MaybeRefOrGetter<boolean | undefined>;
+    /**
+     * Listen only while focus is inside this element (a template ref), for a
+     * page with more than one viewer. The keys work once it has mounted.
+     */
+    target?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+    /** Called when a key's command is turned off or not allowed, with why: say so to the user. */
+    onRefused?: (commandId: CommandId, refusal: CommandRefusal) => void;
+}
+/**
+ * Turn every command's shortcut into a working key, for the active document.
+ * Call it once, near the top of your viewer. Keys typed into text fields are
+ * left alone, and so is a key whose command can't run right now. A command
+ * that's turned off or not allowed still takes its key, and `onRefused` says
+ * why. The keys work anywhere on the page; with `target`, only while focus is
+ * inside that element.
+ * They stop when the component unmounts.
+ */
+export declare function useCommandShortcuts(options?: CommandShortcutsOptions): void;

package/dist/commands.js

@@ -0,0 +1,76 @@
+import { resolvedCommandsEqual, unknownCommandWarning, boundCommandOf, unregisteredCommand, CommandsToken } from "@embedpdf/plugin-commands";
+export * from "@embedpdf/plugin-commands";
+import { toValue, computed, watch } from "vue";
+import { formatShortcut as formatShortcut$1 } from "@embedpdf/core-ui";
+import { CommandsToken as CommandsToken$1 } from "@embedpdf/plugin-commands/contract/host";
+import { createStandardCommands } from "@embedpdf/plugin-commands/standard";
+import { isMacPlatform, standardCommandsBrowser, bindCommandShortcuts } from "@embedpdf/web";
+import { d as devWarn } from "./dev-CtMlvxjZ.js";
+import { a as useCapability, d as useDocumentId, g as useKernelValue, b as useCapabilityEvent } from "./capabilities-C7YzgPCX.js";
+import { s as settingsComposable } from "./state-DZg8q3v6.js";
+const standardCommands = /* @__PURE__ */ createStandardCommands(standardCommandsBrowser);
+function useCommands() {
+  return useCapability(CommandsToken);
+}
+function useCommandsEvent(select, handler) {
+  useCapabilityEvent(CommandsToken, select, handler);
+}
+const useCommandsSettings = settingsComposable(CommandsToken);
+function formatShortcut(shortcut, options = {}) {
+  return formatShortcut$1(shortcut, { isMac: options.isMac ?? isMacPlatform() });
+}
+function useCommand(id) {
+  const commands = useCapability(CommandsToken);
+  const documentId = useDocumentId();
+  const resolved = useKernelValue(
+    () => commands.resolveCommand(toValue(id), documentId.value ?? void 0),
+    resolvedCommandsEqual
+  );
+  return computed(() => {
+    const command = resolved.value;
+    const requested = toValue(id);
+    if (command === null) {
+      devWarn(
+        `useCommand:${requested}`,
+        `useCommand(): ${unknownCommandWarning(requested, commands.listCommandIds())}`
+      );
+    }
+    const scope = documentId.value ?? void 0;
+    return boundCommandOf(
+      command ?? unregisteredCommand(requested),
+      (commandId) => commands.execute(commandId, { documentId: scope }),
+      { isMac: isMacPlatform() }
+    );
+  });
+}
+function useCommandShortcuts(options = {}) {
+  const commands = useCapability(CommandsToken$1);
+  const scoped = options.target !== void 0;
+  watch(
+    () => [toValue(options.isMac), toValue(options.target)],
+    ([isMac, target], _previous, onCleanup) => {
+      if (scoped && !target) return;
+      onCleanup(
+        bindCommandShortcuts(commands, {
+          isMac,
+          target: target ?? void 0,
+          onRefused: (commandId, refusal) => {
+            var _a;
+            return (_a = options.onRefused) == null ? void 0 : _a.call(options, commandId, refusal);
+          }
+        })
+      );
+    },
+    { immediate: true, flush: "post" }
+  );
+}
+export {
+  formatShortcut,
+  standardCommands,
+  useCommand,
+  useCommandShortcuts,
+  useCommands,
+  useCommandsEvent,
+  useCommandsSettings
+};
+//# sourceMappingURL=commands.js.map

package/dist/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.js","sources":["../src/commands.ts"],"sourcesContent":["/**\n * @embedpdf/vue/commands: the Vue surface of `@embedpdf/plugin-commands`. The\n * standard commands, a command as a button needs it, the settings, and keyboard\n * shortcuts. A command's state is derived from live state on read, so\n * `useCommand` re-reads it on the kernel's one change stream and its ref\n * changes only when what the command shows changed.\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-commands';\nimport { computed, toValue, watch } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport { formatShortcut as formatKeys } from '@embedpdf/core-ui';\nimport {\n  CommandsToken,\n  boundCommandOf,\n  resolvedCommandsEqual,\n  unknownCommandWarning,\n  unregisteredCommand,\n} from '@embedpdf/plugin-commands';\nimport type {\n  BoundCommand,\n  CommandId,\n  CommandRefusal,\n  CommandsCapability,\n} from '@embedpdf/plugin-commands';\nimport { CommandsToken as CommandsHostToken } from '@embedpdf/plugin-commands/contract/host';\nimport { createStandardCommands } from '@embedpdf/plugin-commands/standard';\nimport type { EventHook } from '@embedpdf/core';\nimport { bindCommandShortcuts, isMacPlatform, standardCommandsBrowser } from '@embedpdf/web';\nimport { devWarn } from './dev';\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { useDocumentId, useKernelValue } from './runtime/kernel';\nimport { settingsComposable } from './state';\n\n/**\n * The commands every viewer has: zoom, pages, view rotation, `tool:<id>` for every tool, copy,\n * delete, download and print, with shortcuts and labels in EmbedPDF's eight languages. Spread\n * them into `commandsPlugin({ commands })`.\n */\nexport const standardCommands = /* @__PURE__ */ createStandardCommands(standardCommandsBrowser);\n\n/** The commands API: `execute`, `searchCommands`, `registerCommand`, the categories, the settings calls. The object never changes. */\nexport function useCommands(): CommandsCapability {\n  return useCapability(CommandsToken);\n}\n\n/** Subscribe to one commands event while the component lives: `useCommandsEvent((commands) => commands.onExecuted, handler)`. */\nexport function useCommandsEvent<Event>(\n  select: (commands: CommandsCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(CommandsToken, select, handler);\n}\n\n/**\n * The commands settings (`commands`, `disabledCategories`, `disabledCommands`, `notAllowed`) as refs,\n * with or without a document. Takes a selector.\n */\nexport const useCommandsSettings = settingsComposable(CommandsToken);\n\n/** A shortcut as a tooltip shows it, for this platform: `'⌘K'` on a Mac, `'Ctrl+K'` elsewhere. */\nexport function formatShortcut(shortcut: string, options: { isMac?: boolean } = {}): string {\n  return formatKeys(shortcut, { isMac: options.isMac ?? isMacPlatform() });\n}\n\n/**\n * A command for this component's document (the nearest `<DocumentScope>`, else\n * the active one), as a ref: its label, icon, state, `run` and `shortcut`. Pass\n * a getter to follow a prop: `useCommand(() => props.id)`. The ref changes only\n * when what the command shows does. Always a command: an id no plugin\n * registered is labelled with its id, neither visible nor enabled, and warns\n * once in development.\n */\nexport function useCommand(id: MaybeRefOrGetter<string>): Readonly<Ref<BoundCommand>> {\n  const commands = useCapability(CommandsToken);\n  const documentId = useDocumentId();\n  const resolved = useKernelValue(\n    () => commands.resolveCommand(toValue(id), documentId.value ?? undefined),\n    resolvedCommandsEqual,\n  );\n  return computed(() => {\n    const command = resolved.value;\n    const requested = toValue(id);\n    if (command === null) {\n      devWarn(\n        `useCommand:${requested}`,\n        `useCommand(): ${unknownCommandWarning(requested, commands.listCommandIds())}`,\n      );\n    }\n    const scope = documentId.value ?? undefined;\n    return boundCommandOf(\n      command ?? unregisteredCommand(requested),\n      (commandId) => commands.execute(commandId, { documentId: scope }),\n      { isMac: isMacPlatform() },\n    );\n  });\n}\n\n/** Where {@link useCommandShortcuts} listens, and how it reads `Mod`. */\nexport interface CommandShortcutsOptions {\n  /** Whether `Mod` is Cmd (a Mac) or Ctrl. Default: what the browser says. */\n  isMac?: MaybeRefOrGetter<boolean | undefined>;\n  /**\n   * Listen only while focus is inside this element (a template ref), for a\n   * page with more than one viewer. The keys work once it has mounted.\n   */\n  target?: MaybeRefOrGetter<HTMLElement | null | undefined>;\n  /** Called when a key's command is turned off or not allowed, with why: say so to the user. */\n  onRefused?: (commandId: CommandId, refusal: CommandRefusal) => void;\n}\n\n/**\n * Turn every command's shortcut into a working key, for the active document.\n * Call it once, near the top of your viewer. Keys typed into text fields are\n * left alone, and so is a key whose command can't run right now. A command\n * that's turned off or not allowed still takes its key, and `onRefused` says\n * why. The keys work anywhere on the page; with `target`, only while focus is\n * inside that element.\n * They stop when the component unmounts.\n */\nexport function useCommandShortcuts(options: CommandShortcutsOptions = {}): void {\n  const commands = useCapability(CommandsHostToken);\n  const scoped = options.target !== undefined;\n  watch(\n    () => [toValue(options.isMac), toValue(options.target)] as const,\n    ([isMac, target], _previous, onCleanup) => {\n      // A target that hasn't mounted yet binds nothing; its ref being set runs this again.\n      if (scoped && !target) return;\n      onCleanup(\n        bindCommandShortcuts(commands, {\n          isMac,\n          target: target ?? undefined,\n          onRefused: (commandId, refusal) => options.onRefused?.(commandId, refusal),\n        }),\n      );\n    },\n    { immediate: true, flush: 'post' },\n  );\n}\n"],"names":["formatKeys","CommandsHostToken"],"mappings":";;;;;;;;;;AAwCO,MAAM,0DAA0D,uBAAuB;AAGvF,SAAS,cAAkC;AAChD,SAAO,cAAc,aAAa;AACpC;AAGO,SAAS,iBACd,QACA,SACM;AACN,qBAAmB,eAAe,QAAQ,OAAO;AACnD;AAMO,MAAM,sBAAsB,mBAAmB,aAAa;AAG5D,SAAS,eAAe,UAAkB,UAA+B,IAAY;AAC1F,SAAOA,iBAAW,UAAU,EAAE,OAAO,QAAQ,SAAS,cAAA,GAAiB;AACzE;AAUO,SAAS,WAAW,IAA2D;AACpF,QAAM,WAAW,cAAc,aAAa;AAC5C,QAAM,aAAa,cAAA;AACnB,QAAM,WAAW;AAAA,IACf,MAAM,SAAS,eAAe,QAAQ,EAAE,GAAG,WAAW,SAAS,MAAS;AAAA,IACxE;AAAA,EAAA;AAEF,SAAO,SAAS,MAAM;AACpB,UAAM,UAAU,SAAS;AACzB,UAAM,YAAY,QAAQ,EAAE;AAC5B,QAAI,YAAY,MAAM;AACpB;AAAA,QACE,cAAc,SAAS;AAAA,QACvB,iBAAiB,sBAAsB,WAAW,SAAS,eAAA,CAAgB,CAAC;AAAA,MAAA;AAAA,IAEhF;AACA,UAAM,QAAQ,WAAW,SAAS;AAClC,WAAO;AAAA,MACL,WAAW,oBAAoB,SAAS;AAAA,MACxC,CAAC,cAAc,SAAS,QAAQ,WAAW,EAAE,YAAY,OAAO;AAAA,MAChE,EAAE,OAAO,cAAA,EAAc;AAAA,IAAE;AAAA,EAE7B,CAAC;AACH;AAwBO,SAAS,oBAAoB,UAAmC,IAAU;AAC/E,QAAM,WAAW,cAAcC,eAAiB;AAChD,QAAM,SAAS,QAAQ,WAAW;AAClC;AAAA,IACE,MAAM,CAAC,QAAQ,QAAQ,KAAK,GAAG,QAAQ,QAAQ,MAAM,CAAC;AAAA,IACtD,CAAC,CAAC,OAAO,MAAM,GAAG,WAAW,cAAc;AAEzC,UAAI,UAAU,CAAC,OAAQ;AACvB;AAAA,QACE,qBAAqB,UAAU;AAAA,UAC7B;AAAA,UACA,QAAQ,UAAU;AAAA,UAClB,WAAW,CAAC,WAAW;;AAAY,iCAAQ,cAAR,iCAAoB,WAAW;AAAA;AAAA,QAAO,CAC1E;AAAA,MAAA;AAAA,IAEL;AAAA,IACA,EAAE,WAAW,MAAM,OAAO,OAAA;AAAA,EAAO;AAErC;"}

package/dist/composables-BGBsNDf9.cjs

@@ -0,0 +1,25 @@
+"use strict";
+const vue = require("vue");
+const pluginSignature = require("@embedpdf/plugin-signature");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const stamp = require("./stamp.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useSignature() {
+  return capabilities.useCapability(pluginSignature.SignatureToken);
+}
+const useSignatureState = state.stateComposable(pluginSignature.signatureState);
+const useSignatureSettings = state.settingsComposable(pluginSignature.SignatureToken);
+function useSignatureEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginSignature.SignatureToken, select, handler);
+}
+function useSignerRows() {
+  const libraries = stamp.useStampLibraries({ kind: pluginSignature.SIGNATURES_LIBRARY_KIND });
+  const assets = stamp.useStampAssets();
+  return vue.computed(() => pluginSignature.signerRowsOf(libraries.value, assets.value));
+}
+exports.useSignature = useSignature;
+exports.useSignatureEvent = useSignatureEvent;
+exports.useSignatureSettings = useSignatureSettings;
+exports.useSignatureState = useSignatureState;
+exports.useSignerRows = useSignerRows;
+//# sourceMappingURL=composables-BGBsNDf9.cjs.map

package/dist/composables-BGBsNDf9.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composables-BGBsNDf9.cjs","sources":["../src/signature/composables.ts"],"sourcesContent":["/**\n * The signature composables: `useSignature()` (the API), the state and the\n * settings as refs, `useSignatureEvent()`, and `useSignerRows()`, the people\n * whose marks this browser holds, for a signature picker.\n */\nimport { computed } from 'vue';\nimport type { Ref } from 'vue';\nimport type { EventHook } from '@embedpdf/core';\nimport {\n  signatureState,\n  signerRowsOf,\n  SIGNATURES_LIBRARY_KIND,\n  SignatureToken,\n} from '@embedpdf/plugin-signature';\nimport type { SignatureCapability, SignerRow } from '@embedpdf/plugin-signature';\nimport { useCapability, useCapabilityEvent } from '../runtime/capabilities';\nimport { useStampAssets, useStampLibraries } from '../stamp';\nimport { settingsComposable, stateComposable } from '../state';\nimport type { StateComposable } from '../state';\n\n/**\n * The signature API for the document in scope: sign, place a mark, fill or\n * clear a field, check the signatures. The object never changes, so it's\n * safe to keep in a closure; keep it whole (`signature.sign(…)`), since a\n * member taken out of it once stays the one of that moment.\n */\nexport function useSignature(): SignatureCapability {\n  return useCapability(SignatureToken);\n}\n\n/**\n * The signatures' state as refs: the signed fields with their verdicts\n * (`signatures`), what they allow, the `target`, whether a signing runs\n * (`busy`), a two-step signing in progress, and whether they're read,\n * declared once in `signatureState`. With a selector, one ref that updates\n * only when the value it picks changes. Empty without a document.\n *\n * Typed through the declaration, so the published types name it from\n * `@embedpdf/plugin-signature`, a dependency of this package, and not from the\n * engine package `protection`'s type comes from, which isn't one.\n */\nexport const useSignatureState: StateComposable<ReturnType<typeof signatureState.read>> =\n  stateComposable(signatureState);\n\n/**\n * The signature settings (`key`, `mode`, `trust`, `allowCertify`) as refs, or\n * one ref for the value `select` picks. They belong to the plugin, so they\n * read without a document.\n */\nexport const useSignatureSettings = settingsComposable(SignatureToken);\n\n/** Subscribe to one signature event while the component lives: `useSignatureEvent((signature) => signature.onSigned, handler)`. */\nexport function useSignatureEvent<Event>(\n  select: (signature: SignatureCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(SignatureToken, select, handler);\n}\n\n/**\n * The people whose marks this browser holds, one row per library of kind\n * `signatures`, for a picker, as a ref: `const rows = useSignerRows()`.\n * Derived from the stamp plugin, so it needs `stampPlugin()`: rename, delete\n * and export are the library verbs, and nothing is stored beyond the file.\n */\nexport function useSignerRows(): Readonly<Ref<readonly SignerRow[]>> {\n  const libraries = useStampLibraries({ kind: SIGNATURES_LIBRARY_KIND });\n  const assets = useStampAssets();\n  return computed(() => signerRowsOf(libraries.value, assets.value));\n}\n"],"names":["useCapability","SignatureToken","stateComposable","signatureState","settingsComposable","useCapabilityEvent","useStampLibraries","SIGNATURES_LIBRARY_KIND","useStampAssets","computed","signerRowsOf"],"mappings":";;;;;;AA0BO,SAAS,eAAoC;AAClD,SAAOA,aAAAA,cAAcC,gBAAAA,cAAc;AACrC;AAaO,MAAM,oBACXC,MAAAA,gBAAgBC,gBAAAA,cAAc;AAOzB,MAAM,uBAAuBC,MAAAA,mBAAmBH,gBAAAA,cAAc;AAG9D,SAAS,kBACd,QACA,SACM;AACNI,kCAAmBJ,gBAAAA,gBAAgB,QAAQ,OAAO;AACpD;AAQO,SAAS,gBAAqD;AACnE,QAAM,YAAYK,MAAAA,kBAAkB,EAAE,MAAMC,gBAAAA,yBAAyB;AACrE,QAAM,SAASC,MAAAA,eAAA;AACf,SAAOC,IAAAA,SAAS,MAAMC,6BAAa,UAAU,OAAO,OAAO,KAAK,CAAC;AACnE;;;;;;"}