@bendyline/docblocks 1.1.2 → 2.0.0

package/dist/types-eOlt9J7n.d.ts

@@ -0,0 +1,478 @@
+import { S as SerializedFsError, r as FileSystemProviderCapabilities, k as FileSystemEntrySnapshot, m as FileSystemFileRead, K as FileSystemWriteOptions, n as FileSystemFileSnapshot, g as FileSystemCreateDirectoryOptions, h as FileSystemDirectorySnapshot, u as FileSystemRemoveOptions, v as FileSystemRemoveResult, o as FileSystemMoveOptions, w as FileSystemSnapshot, C as FileSystemWatchEvent, F as FileCommitResult, j as FileSystemEntry, b as FileMeta } from './types-CsX6EN2t.js';
+import { a as WorkspacePath } from './workspace-path-CWVrcuPL.js';
+
+/** Stable capabilities shared by the Electron v2 client and native backend. */
+declare const ELECTRON_FILE_SYSTEM_V2_CAPABILITIES: FileSystemProviderCapabilities;
+/** Explicit result envelope; Electron does not preserve custom Error fields. */
+type HostFileSystemV2Result<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: SerializedFsError;
+};
+interface HostFileSystemV2OpenRequest {
+    readonly instanceId: string;
+    /** Main-owned persisted workspace authority, never an absolute path. */
+    readonly providerId: string;
+    readonly label: string;
+}
+type HostFileSystemV2WatchMessage = {
+    readonly instanceId: string;
+    readonly subscriptionId: string;
+    readonly kind: 'event';
+    readonly event: FileSystemWatchEvent;
+} | {
+    readonly instanceId: string;
+    readonly subscriptionId: string;
+    readonly kind: 'error';
+    readonly error: SerializedFsError;
+};
+/** Wire-level filesystem v2 API exposed by preload. */
+interface DocBlocksHostFsV2API {
+    open(request: HostFileSystemV2OpenRequest): Promise<HostFileSystemV2Result<FileSystemProviderCapabilities>>;
+    stat(instanceId: string, path: WorkspacePath): Promise<HostFileSystemV2Result<FileSystemEntrySnapshot | null>>;
+    readFile(instanceId: string, path: WorkspacePath): Promise<HostFileSystemV2Result<FileSystemFileRead | null>>;
+    readDirectory(instanceId: string, path: WorkspacePath): Promise<HostFileSystemV2Result<readonly FileSystemEntrySnapshot[]>>;
+    writeFile(instanceId: string, path: WorkspacePath, data: ArrayBuffer | Uint8Array, options?: FileSystemWriteOptions): Promise<HostFileSystemV2Result<FileSystemFileSnapshot>>;
+    createDirectory(instanceId: string, path: WorkspacePath, options?: FileSystemCreateDirectoryOptions): Promise<HostFileSystemV2Result<FileSystemDirectorySnapshot>>;
+    remove(instanceId: string, path: WorkspacePath, options?: FileSystemRemoveOptions): Promise<HostFileSystemV2Result<FileSystemRemoveResult>>;
+    move(instanceId: string, oldPath: WorkspacePath, newPath: WorkspacePath, options?: FileSystemMoveOptions): Promise<HostFileSystemV2Result<FileSystemEntrySnapshot>>;
+    snapshot(instanceId: string): Promise<HostFileSystemV2Result<FileSystemSnapshot>>;
+    watchSubscribe(instanceId: string, subscriptionId: string): Promise<HostFileSystemV2Result<null>>;
+    watchUnsubscribe(instanceId: string, subscriptionId: string): Promise<HostFileSystemV2Result<null>>;
+    dispose(instanceId: string): Promise<HostFileSystemV2Result<null>>;
+    onWatchMessage(listener: (message: HostFileSystemV2WatchMessage) => void): () => void;
+}
+
+/**
+ * Git host API — wire types for the desktop shell's git integration.
+ *
+ * The desktop app spawns the user's system git from the main process, so
+ * credentials (helpers, SSH agent, signing config and raw remote URLs) remain
+ * in the main process. Everything here is generic git; the only host-specific
+ * conveniences are remote-URL parsing (`GitRemoteInfo.web`) and PR creation
+ * via the GitHub CLI when installed.
+ *
+ * Expected git failures cross IPC as data (`GitResult`), never as thrown
+ * errors — `ipcMain.handle` rejections lose structure. Throwing is reserved
+ * for contract violations (unregistered root, path escape).
+ */
+
+/** Every git operation resolves this — expected failures are data, not throws. */
+type GitResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: GitError;
+};
+interface GitError {
+    code: GitErrorCode;
+    /** One-line human summary (classified stderr or synthesized). */
+    message: string;
+    /** Truncated raw stderr for a details disclosure in the UI. */
+    stderr?: string;
+    exitCode?: number;
+}
+type GitErrorCode = 'git-not-available' | 'not-a-repository' | 'auth-failed' | 'remote-not-found' | 'no-upstream' | 'network' | 'non-fast-forward' | 'merge-conflict' | 'uncommitted-changes' | 'detached-head' | 'unborn-branch' | 'identity-not-configured' | 'branch-exists' | 'invalid-ref-name' | 'nothing-to-commit' | 'invalid-url' | 'destination-exists' | 'pr-exists' | 'gh-not-available' | 'timeout' | 'cancelled' | 'permission-denied' | 'unknown';
+interface GitCapabilities {
+    /** False in store-sandboxed builds, when git is absent, or git < 2.23. */
+    gitAvailable: boolean;
+    gitVersion: string | null;
+    ghAvailable: boolean;
+    ghVersion: string | null;
+}
+interface GitRepoDetection {
+    isRepo: boolean;
+    /** False when the workspace root is a subdirectory of a larger repo. */
+    rootIsToplevel?: boolean;
+    /** Main-owned repository authority; absent when expanded access was declined. */
+    repositoryId?: string;
+    /** True when Git metadata or the work tree extends beyond the workspace grant. */
+    requiresExpandedGrant?: boolean;
+}
+type GitFileStatusCode = 'added' | 'modified' | 'deleted' | 'renamed' | 'copied' | 'type-changed' | 'untracked' | 'ignored' | 'unmerged';
+interface GitFileChange {
+    /** Slash-prefixed path relative to the WORKSPACE root (fs API convention). */
+    path: string;
+    /** Previous path for renames/copies (workspace-relative, slash-prefixed). */
+    origPath?: string;
+    /** Index-vs-HEAD state (staged), if any. */
+    index?: GitFileStatusCode;
+    /** Worktree-vs-index state (unstaged), if any. */
+    worktree?: GitFileStatusCode;
+    conflicted: boolean;
+}
+interface GitStatus {
+    /** Branch name; null when detached or unborn with no branch. */
+    branch: string | null;
+    detached: boolean;
+    /** HEAD points at a branch with no commits yet. */
+    unborn: boolean;
+    /** Full HEAD SHA; null when unborn. */
+    head: string | null;
+    /** Upstream ref short name, e.g. "origin/main". */
+    upstream: string | null;
+    ahead: number;
+    behind: number;
+    changes: GitFileChange[];
+    /** True when `changes` was capped. */
+    truncated: boolean;
+    operation: 'merge' | 'rebase' | 'cherry-pick' | 'revert' | 'bisect' | null;
+}
+interface GitBranchInfo {
+    /** "main" for local branches, "origin/main" for remote entries. */
+    name: string;
+    kind: 'local' | 'remote';
+    current: boolean;
+    upstream: string | null;
+    ahead: number;
+    behind: number;
+    upstreamGone: boolean;
+    headSha: string;
+    headSubject: string;
+    /** ISO 8601. */
+    headDate: string;
+}
+interface GitLogOptions {
+    /** Workspace-relative file path — per-file history (follows renames). */
+    path?: string;
+    /** Default 100; the host caps at 1000. */
+    maxCount?: number;
+    skip?: number;
+}
+interface GitLogEntry {
+    sha: string;
+    parents: string[];
+    authorName: string;
+    authorEmail: string;
+    /** ISO 8601. */
+    authorDate: string;
+    subject: string;
+    /** Ref decorations ("HEAD -> main", "origin/main", "tag: v1"). */
+    refs: string[];
+}
+/** Typed revision selector — the renderer never passes raw rev strings. */
+type GitRevision = {
+    kind: 'head';
+} | {
+    kind: 'index';
+} | {
+    kind: 'commit';
+    sha: string;
+} | {
+    kind: 'parent-of';
+    sha: string;
+};
+interface GitFileAtRevision {
+    /** Null when the file is absent at that revision, or binary/too large. */
+    content: string | null;
+    binary: boolean;
+}
+interface GitRemoteInfo {
+    name: string;
+    /** Sanitized web location. Raw fetch/push URLs never cross IPC. */
+    web: {
+        host: string;
+        owner: string;
+        repo: string;
+        webUrl: string;
+    } | null;
+}
+interface GitCloneProgress {
+    /** e.g. "Receiving objects", "Resolving deltas", "Checking out files". */
+    phase: string;
+    percent: number | null;
+    /** Raw progress line for display. */
+    detail?: string;
+}
+interface GitCloneHandle {
+    /**
+     * Resolves `ok(null)` if the user cancels the destination picker; on
+     * success resolves the registered workspace ready to open.
+     */
+    result: Promise<GitResult<ElectronWorkspaceInfo | null>>;
+    /** Kill git and remove the partial clone directory. */
+    cancel: () => void;
+}
+interface DocBlocksHostGitAPI {
+    capabilities(): Promise<GitCapabilities>;
+    /** Detect a persisted workspace by opaque workspace id and mint repository authority. */
+    detectRepo(workspaceId: string): Promise<GitResult<GitRepoDetection>>;
+    init(workspaceId: string): Promise<GitResult<void>>;
+    status(repositoryId: string): Promise<GitResult<GitStatus>>;
+    stage(repositoryId: string, paths: string[]): Promise<GitResult<void>>;
+    unstage(repositoryId: string, paths: string[]): Promise<GitResult<void>>;
+    /** Revert tracked files to HEAD; delete untracked ones. Destructive — the renderer confirms. */
+    discard(repositoryId: string, paths: string[]): Promise<GitResult<void>>;
+    /**
+     * With `paths`: stages exactly those files (`add -A -- <paths>`) and commits
+     * them, leaving other staged entries staged. Without: commits the index as-is.
+     */
+    commit(repositoryId: string, message: string, paths?: string[]): Promise<GitResult<{
+        sha: string;
+    }>>;
+    push(repositoryId: string, opts?: {
+        setUpstream?: boolean;
+    }): Promise<GitResult<void>>;
+    pull(repositoryId: string): Promise<GitResult<void>>;
+    fetch(repositoryId: string): Promise<GitResult<void>>;
+    listBranches(repositoryId: string): Promise<GitResult<GitBranchInfo[]>>;
+    createBranch(repositoryId: string, name: string, opts?: {
+        checkout?: boolean;
+    }): Promise<GitResult<void>>;
+    checkoutBranch(repositoryId: string, name: string): Promise<GitResult<void>>;
+    log(repositoryId: string, opts?: GitLogOptions): Promise<GitResult<GitLogEntry[]>>;
+    /** Files changed in one commit plus the full message body. */
+    commitFiles(repositoryId: string, sha: string): Promise<GitResult<{
+        body: string;
+        files: GitFileChange[];
+    }>>;
+    readFileAtRevision(repositoryId: string, path: string, revision: GitRevision): Promise<GitResult<GitFileAtRevision>>;
+    listRemotes(repositoryId: string): Promise<GitResult<GitRemoteInfo[]>>;
+    /**
+     * Clone a remote repository. The main process shows a native picker for the
+     * destination parent directory, then registers the clone as a workspace.
+     */
+    clone(url: string, onProgress?: (p: GitCloneProgress) => void): GitCloneHandle;
+    /** `gh pr create --web` (falls back to `gh pr view --web` if one exists). */
+    createPullRequest(repositoryId: string): Promise<GitResult<void>>;
+    /**
+     * Throttled status stream for a workspace root. Emits once immediately on
+     * subscribe. Returns an unsubscribe function.
+     */
+    onStatusChanged(repositoryId: string, listener: (status: GitStatus) => void): () => void;
+}
+
+/**
+ * DocBlocksHostAPI — the contract exposed by the Electron desktop shell
+ * to its renderer process via contextBridge.
+ *
+ * This file is the single source of truth for the host ↔ renderer
+ * bridge. The Electron preload script exposes an implementation matching
+ * this shape; the React renderer calls it through `window.docBlocksHost`.
+ */
+
+/** Filesystem operations scoped to a main-owned registered workspace id. */
+interface DocBlocksHostFsAPI {
+    readFile(workspaceId: string, path: string): Promise<string | null>;
+    writeFile(workspaceId: string, path: string, content: string): Promise<void>;
+    commitFile(workspaceId: string, path: string, content: string, expectedContent: string | null): Promise<FileCommitResult>;
+    delete(workspaceId: string, path: string): Promise<void>;
+    rename(workspaceId: string, oldPath: string, newPath: string): Promise<void>;
+    readDirectory(workspaceId: string, path: string): Promise<FileSystemEntry[]>;
+    exists(workspaceId: string, path: string): Promise<boolean>;
+    createDirectory(workspaceId: string, path: string): Promise<void>;
+    stat(workspaceId: string, path: string): Promise<FileMeta | null>;
+    readBinary(workspaceId: string, path: string): Promise<ArrayBuffer | null>;
+    writeBinary(workspaceId: string, path: string, data: ArrayBuffer | Uint8Array): Promise<void>;
+    /**
+     * Subscribe to change notifications for a watched root. Returns an
+     * unsubscribe function. The main process uses chokidar under the hood.
+     */
+    watch(workspaceId: string, onChange: (path: string) => void): () => void;
+}
+/** Descriptor returned for an Electron-managed workspace (backed by a folder). */
+interface ElectronWorkspaceInfo {
+    id: string;
+    name: string;
+    /** Display/persistence metadata only. Privileged host calls accept `id`, never this path. */
+    rootPath: string;
+}
+/** Workspace-management operations exposed to the renderer. */
+interface DocBlocksHostWorkspacesAPI {
+    /** List only folders already persisted as trusted main-process roots. */
+    list(): Promise<ElectronWorkspaceInfo[]>;
+    /**
+     * Return the default workspace (creating DocBlocks inside the operating
+     * system's Documents folder on first call, or the user's configured default).
+     */
+    getDefault(): Promise<ElectronWorkspaceInfo>;
+    /**
+     * Open the native folder picker. Returns null if the user cancels.
+     * The selected folder is registered in the main process whitelist.
+     */
+    pickFolder(): Promise<ElectronWorkspaceInfo | null>;
+    /**
+     * Re-register a previously picker-approved workspace by main-owned id.
+     * Called on app startup before any filesystem operation.
+     */
+    register(workspaceId: string): Promise<void>;
+    /** Remove a workspace from the trusted whitelist. */
+    unregister(id: string): Promise<void>;
+}
+/** Shell operations — reveal in Finder/Explorer, open external URLs. */
+interface DocBlocksHostShellAPI {
+    /** Reveal a registered workspace root or one root-relative entry. */
+    revealInFolder(workspaceId: string, workspacePath?: string): Promise<void>;
+    /** Open a URL in the default browser. */
+    openExternal(url: string): Promise<void>;
+}
+/** Exact, main-owned export authority. The display path is never authority. */
+interface HostExportTargetGrant {
+    /** Null means this is a display-only suggestion and save must show a picker. */
+    grantId: string | null;
+    displayPath: string;
+}
+/** Native export target selection and binary file writing. */
+interface DocBlocksHostExportAPI {
+    /** Resolve an exact remembered grant or a display-only host suggestion. */
+    resolveTarget(documentId: string, filename: string): Promise<HostExportTargetGrant>;
+    /** Open the native Save dialog and remember the selected target. */
+    pickTarget(documentId: string, filename: string, currentGrantId?: string | null): Promise<HostExportTargetGrant | null>;
+    /** Write only to an exact target granted by the main process. */
+    save(documentId: string, filename: string, grantId: string | null, data: ArrayBuffer | Uint8Array): Promise<HostExportTargetGrant | null>;
+}
+/** System ffmpeg detection and invocation. */
+interface DocBlocksHostFfmpegAPI {
+    /** True if `ffmpeg` is available on PATH (or bundled). */
+    available(): Promise<boolean>;
+    /** Version string from `ffmpeg -version`, or null if unavailable. */
+    version(): Promise<string | null>;
+    /** Render a physically contained workspace-relative Markdown file to MP4. */
+    renderVideo(workspaceId: string, markdownPath: string, options: {
+        fps?: number;
+        quality?: 'draft' | 'normal' | 'high';
+    }): Promise<string>;
+}
+/** Auto-updater control. */
+interface DocBlocksHostUpdaterAPI {
+    /** Kick off a check; resolves to true if an update is available. */
+    checkForUpdates(): Promise<boolean>;
+    /** Current app version string. */
+    getVersion(): Promise<string>;
+    /**
+     * Quit the app and apply a downloaded update. Should only be called
+     * after an `UpdaterStatus` of kind `'downloaded'` has been observed.
+     */
+    quitAndInstall(): Promise<UpdateInstallResult>;
+    /**
+     * Subscribe to updater status events. Returns an unsubscribe function.
+     */
+    onStatus(listener: (status: UpdaterStatus) => void): () => void;
+}
+type UpdateInstallResult = 'installing' | 'cancelled' | 'not-ready';
+type UpdaterStatus = {
+    kind: 'checking';
+} | {
+    kind: 'available';
+    version: string;
+    releaseNotes?: string;
+    releaseUrl?: string;
+} | {
+    kind: 'not-available';
+} | {
+    kind: 'downloading';
+    percent: number;
+} | {
+    kind: 'downloaded';
+    version: string;
+    releaseNotes?: string;
+    releaseUrl?: string;
+} | {
+    kind: 'error';
+    message: string;
+};
+/** Menu-command events pushed from the main process to the renderer. */
+type MenuCommand = 'file:new' | 'file:openFolder' | 'file:revealWorkspace' | 'file:settings' | 'git:commit' | 'git:push' | 'git:pull' | 'git:fetch' | 'git:newBranch' | 'git:switchBranch' | 'git:history' | 'git:clone' | 'git:openOnRemote' | 'git:createPullRequest' | 'help:about' | 'help:checkForUpdates' | 'help:viewOnGitHub';
+/**
+ * OS open-file / deep-link event resolved by the host.
+ * - 'workspace-file': a file inside an already-registered workspace.
+ * - 'external-file': a loose markdown file outside any workspace — opened in a
+ *   transient workspace and saved through an opaque resource grant.
+ * - 'external-bundle': a `.dbk`/zip bundle — unpacked into a transient
+ *   workspace and re-zipped through an opaque resource grant on save.
+ */
+type OpenRequest = {
+    kind: 'workspace-file';
+    workspaceId: string;
+    /** Slash-prefixed path relative to the workspace root. */
+    path: string;
+} | {
+    kind: 'external-file';
+    resourceId: string;
+    name: string;
+} | {
+    kind: 'external-bundle';
+    resourceId: string;
+    name: string;
+};
+/**
+ * Read/write access to individual OS files the user has explicitly opened
+ * (via "Open With" / deep link), outside the workspace-root whitelist. The
+ * main process gates these with owner-scoped, exact-file capabilities.
+ */
+interface DocBlocksHostExternalAPI {
+    readText(resourceId: string): Promise<string | null>;
+    readBinary(resourceId: string): Promise<ArrayBuffer | null>;
+    writeText(resourceId: string, content: string): Promise<void>;
+    writeBinary(resourceId: string, data: ArrayBuffer | Uint8Array): Promise<void>;
+    commitText(resourceId: string, content: string, expectedContent: string | null): Promise<FileCommitResult>;
+    commitBinary(resourceId: string, data: ArrayBuffer | Uint8Array, expectedVersion: string | null): Promise<ExternalBinaryCommitResult>;
+    /** Revoke one external resource when its transient document is closed. */
+    revoke(resourceId: string): Promise<void>;
+}
+type ExternalBinaryCommitResult = {
+    status: 'committed';
+    version: string;
+} | {
+    status: 'conflict';
+    version: string | null;
+    data: ArrayBuffer | null;
+};
+/** Environment metadata provided by the host. */
+interface HostEnvironment {
+    platform: 'darwin' | 'win32' | 'linux';
+    appVersion: string;
+    isDev: boolean;
+}
+type HostCloseReason = 'window-close' | 'app-quit' | 'update-install' | 'reload' | 'force-reload';
+interface HostPrepareCloseRequest {
+    requestId: string;
+    reason: HostCloseReason;
+    /** Absolute epoch-millisecond deadline chosen by the main process. */
+    deadline: number;
+}
+type HostPrepareCloseResult = {
+    status: 'ready';
+    persistedRevision: number;
+} | {
+    status: 'blocked';
+    code: 'save-failed' | 'external-conflict' | 'not-ready';
+    message: string;
+};
+/**
+ * Main-owned close handshake. Preload privately correlates replies; the
+ * renderer never chooses request or window identifiers.
+ */
+interface DocBlocksHostLifecycleAPI {
+    onPrepareClose(listener: (request: HostPrepareCloseRequest) => Promise<HostPrepareCloseResult>): () => void;
+    onCancelClose(listener: (requestId: string) => void): () => void;
+}
+/** The full DocBlocks desktop host API. */
+interface DocBlocksHostAPI {
+    env: HostEnvironment;
+    fs: DocBlocksHostFsAPI;
+    fsV2: DocBlocksHostFsV2API;
+    external: DocBlocksHostExternalAPI;
+    workspaces: DocBlocksHostWorkspacesAPI;
+    shell: DocBlocksHostShellAPI;
+    exports: DocBlocksHostExportAPI;
+    ffmpeg: DocBlocksHostFfmpegAPI;
+    git: DocBlocksHostGitAPI;
+    updater: DocBlocksHostUpdaterAPI;
+    lifecycle: DocBlocksHostLifecycleAPI;
+    /**
+     * Subscribe to menu commands dispatched by the native menu.
+     * Returns an unsubscribe function.
+     */
+    onMenuCommand(listener: (cmd: MenuCommand) => void): () => void;
+    /**
+     * Subscribe to open-file / open-url requests from the OS.
+     * Returns an unsubscribe function.
+     */
+    onOpenRequest(listener: (request: OpenRequest) => void): () => void;
+}
+
+export { type GitStatus as A, type HostEnvironment as B, type HostExportTargetGrant as C, type DocBlocksHostAPI as D, ELECTRON_FILE_SYSTEM_V2_CAPABILITIES as E, type HostFileSystemV2OpenRequest as F, type GitBranchInfo as G, type HostCloseReason as H, type HostFileSystemV2Result as I, type HostFileSystemV2WatchMessage as J, type HostPrepareCloseRequest as K, type HostPrepareCloseResult as L, type MenuCommand as M, type UpdaterStatus as N, type OpenRequest as O, type UpdateInstallResult as U, type DocBlocksHostExportAPI as a, type DocBlocksHostExternalAPI as b, type DocBlocksHostFfmpegAPI as c, type DocBlocksHostFsAPI as d, type DocBlocksHostFsV2API as e, type DocBlocksHostGitAPI as f, type DocBlocksHostLifecycleAPI as g, type DocBlocksHostShellAPI as h, type DocBlocksHostUpdaterAPI as i, type DocBlocksHostWorkspacesAPI as j, type ElectronWorkspaceInfo as k, type ExternalBinaryCommitResult as l, type GitCapabilities as m, type GitCloneHandle as n, type GitCloneProgress as o, type GitError as p, type GitErrorCode as q, type GitFileAtRevision as r, type GitFileChange as s, type GitFileStatusCode as t, type GitLogEntry as u, type GitLogOptions as v, type GitRemoteInfo as w, type GitRepoDetection as x, type GitResult as y, type GitRevision as z };

package/dist/vscode/index.d.ts

@@ -0,0 +1,3 @@
+/** Runtime-validated VS Code host/webview wire protocol. */
+export * from './messages.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/vscode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vscode/index.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,cAAc,eAAe,CAAC"}

package/dist/vscode/index.js

@@ -0,0 +1,3 @@
+/** Runtime-validated VS Code host/webview wire protocol. */
+export * from './messages.js';
+//# sourceMappingURL=index.js.map

package/dist/vscode/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/vscode/index.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,cAAc,eAAe,CAAC"}