@prisma-next/cli-telemetry 0.10.0-dev.8

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2026] [Prisma Data, Inc]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,43 @@
+# `@prisma-next/cli-telemetry`
+
+Anonymous CLI usage telemetry client for Prisma Next. Runs in a
+detached child process at command start, never blocks the parent,
+and silently swallows every error in the sending path.
+
+## Responsibilities
+
+- **User config store.** Read/write `$XDG_CONFIG_HOME/prisma-next/config.json`
+  (or platform equivalent), holding the consent flag (`enableTelemetry`) and
+  the per-installation random UUID (`installationId`). Atomic writes;
+  unknown fields preserved.
+- **Gating.** Pure-function resolution over the two opt-out env vars
+  (`PRISMA_NEXT_DISABLE_TELEMETRY`, `DO_NOT_TRACK=1`), the stored
+  preference, and the default-off fallback when the file is missing.
+- **Sanitization.** Project the parent's parsed commander result into
+  the command name plus the array of flag names; never values, never
+  positionals.
+- **Agent detection.** Best-effort identification of AI coding-agent
+  sessions from an env-var allowlist. Detector runs in the child.
+- **Detached send.** Fork the sender script via
+  `child_process.fork(..., { detached: true, stdio: ['pipe','ignore','ignore','ipc'] })`,
+  pipe the payload over IPC, `disconnect()` + `unref()`, return to the
+  parent. The child enriches with system probes, POSTs to the backend
+  with a 1–2 s timeout, exits.
+
+## Dependencies
+
+- Node built-ins only. Config-dir resolution follows the XDG Base
+  Directory Specification on Unix (incl. macOS — the spec deliberately
+  picks XDG over the macOS-native `~/Library/Preferences/` convention so
+  the path is test-overridable and consistent across platforms) and uses
+  `%APPDATA%` on Windows. `child_process`, `node:crypto.randomUUID`,
+  `node:fs`, `node:os`, `node:path` are the only inbound modules.
+
+## For contributors
+
+The endpoint URL is a module-level constant pinned to the deployed
+backend. For local-development testing, set
+`PRISMA_NEXT_TELEMETRY_ENDPOINT` to override the destination URL
+(used by the integration tests to spin up a mock HTTP server on an
+ephemeral port). This is an integration-testing affordance, not a
+public knob: do not surface it in user-facing docs.

package/dist/exports/index.d.mts

@@ -0,0 +1,278 @@
+//#region src/endpoint.d.ts
+/**
+ * Production endpoint pinned to the deployed Prisma Compute backend.
+ * Compiled as a build-time constant; not user-configurable.
+ */
+declare const TELEMETRY_BACKEND_URL = "https://cmpbfbsdp09hr3jf7pojjs5qs.ewr.prisma.build";
+/**
+ * Path within the backend that accepts telemetry POSTs.
+ */
+declare const TELEMETRY_ENDPOINT_PATH = "/events";
+/**
+ * Resolve the full POST URL the sender targets. The
+ * `PRISMA_NEXT_TELEMETRY_ENDPOINT` env var is an integration-testing
+ * affordance only — it lets the test suite spin up a mock HTTP server
+ * on an ephemeral port and point the spawned sender at it. The override
+ * is intentionally undocumented in user-facing material.
+ *
+ * Fail-open: a malformed override (typo in a dev shell, bad CI config)
+ * silently falls back to the production backend rather than throwing,
+ * matching the telemetry layer's broader silent-on-failure contract.
+ */
+declare function resolveTelemetryEndpoint(env?: Readonly<Record<string, string | undefined>>): string;
+//#endregion
+//#region src/user-config.d.ts
+/**
+ * The user-level config file. Persists the consent flag and the
+ * installation UUID together so an env-var opt-out never mutates disk,
+ * and so an opt-in → opt-out → opt-in cycle keeps the same UUID (correct
+ * for MAU continuity).
+ *
+ * Readers tolerate unknown fields for forward compat; writers merge
+ * partials into the existing object so unknown fields are preserved.
+ */
+interface UserConfig {
+  readonly enableTelemetry?: boolean;
+  readonly installationId?: string;
+  readonly [key: string]: unknown;
+}
+/**
+ * Path to the user-level config file. Resolved per call so test
+ * harnesses can mutate `$XDG_CONFIG_HOME` between cases.
+ */
+declare function userConfigPath(): string;
+/**
+ * Reads the user-level config. File-missing, unreadable, or malformed →
+ * `{}` (the absence of consent is the same answer in every error mode).
+ * Unknown fields from a future client are passed through verbatim.
+ */
+declare function readUserConfig(): UserConfig;
+/**
+ * Merges `partial` into the current config and writes the result
+ * atomically (temp file + rename) so a crash mid-write never leaves a
+ * half-baked file readable on disk. Unknown fields already on disk are
+ * preserved.
+ *
+ * When `partial.enableTelemetry === true` and no `installationId` is
+ * stored yet, generates a v4 random UUID and persists both fields in
+ * the same write. An existing `installationId` is never rotated.
+ *
+ * `writeUserConfig({ enableTelemetry: false })` does *not* generate an
+ * installation id — only an affirmative consent answer produces one.
+ */
+declare function writeUserConfig(partial: Partial<UserConfig>): void;
+//#endregion
+//#region src/gating.d.ts
+/**
+ * Why telemetry was disabled. Useful for debug-mode logging in the
+ * parent; never surfaces to users.
+ */
+type GatingDisabledReason = 'env-override' | 'stored-opt-out' | 'default-off';
+type GatingResolution = {
+  readonly enabled: true;
+} | {
+  readonly enabled: false;
+  readonly reason: GatingDisabledReason;
+};
+interface GatingInputs {
+  /**
+   * Environment-variable lookups the resolver consults. Tests pass a
+   * literal record; production passes `process.env`. The two opt-out
+   * signals are `PRISMA_NEXT_DISABLE_TELEMETRY` (Prisma-specific) and
+   * `DO_NOT_TRACK` (community convention).
+   */
+  readonly env: Readonly<Record<string, string | undefined>>;
+  /** Result of `readUserConfig()` — file-missing tolerated as `{}`. */
+  readonly config: UserConfig;
+}
+/**
+ * Pure-function resolution of the gating decision. Same input → same
+ * output; no I/O. The caller is responsible for reading the env and the
+ * user config.
+ *
+ * Decision order:
+ *   1. Env-var override (`PRISMA_NEXT_DISABLE_TELEMETRY` truthy, or
+ *      `DO_NOT_TRACK=1`) → disabled.
+ *   2. Stored `enableTelemetry === true` → enabled.
+ *   3. Stored `enableTelemetry === false` → disabled (`stored-opt-out`).
+ *   4. Stored `enableTelemetry === undefined` (file missing, or field
+ *      not set) → disabled (`default-off`).
+ *
+ * Telemetry is enabled only when no env override is active **and**
+ * `enableTelemetry` is explicitly `true`.
+ */
+declare function resolveGating(inputs: GatingInputs): GatingResolution;
+//#endregion
+//#region src/payload.d.ts
+/**
+ * Wire-shape payload the parent IPC-sends to the forked child sender.
+ * Mirrors the fields the parent has naturally in hand at command start
+ * (installation id, sanitised command + flags, CLI version, db target,
+ * extension-pack ids, project root for TS-version lookup). The child
+ * fills in the rest (runtime/os/arch, package manager, ts version,
+ * agent) on its side.
+ *
+ * Both sides version-couple on this shape because the IPC carrier is
+ * structured-cloned by Node and there's no on-wire compat to maintain.
+ */
+interface ParentToSenderPayload {
+  readonly installationId: string;
+  readonly version: string;
+  readonly command: string;
+  readonly flags: readonly string[];
+  readonly databaseTarget: string | null;
+  readonly extensions: readonly string[];
+  /** Absolute path of the user's project. The child reads `<projectRoot>/package.json` for `tsVersion`. */
+  readonly projectRoot: string;
+  /** Resolved endpoint URL (already includes the `/events` path). */
+  readonly endpoint: string;
+}
+/**
+ * The full event the child POSTs to the backend. Shape matches the
+ * backend's arktype schema (`apps/telemetry-backend/src/schema.ts`).
+ */
+interface TelemetryEvent {
+  readonly installationId: string;
+  readonly version: string;
+  readonly command: string;
+  readonly flags: readonly string[];
+  readonly runtimeName: string;
+  readonly runtimeVersion: string;
+  readonly os: string;
+  readonly arch: string;
+  readonly packageManager: string | null;
+  readonly databaseTarget: string | null;
+  readonly tsVersion: string | null;
+  readonly agent: string | null;
+  readonly extensions: readonly string[];
+}
+//#endregion
+//#region src/sanitize.d.ts
+interface CommanderOptionShape {
+  /** Commander's option attribute name, e.g. `dryRun` for `--dry-run`. */
+  readonly attributeName: string;
+  /** Commander's long, user-facing flag spelling, e.g. `--dry-run` or `--no-install`. */
+  readonly longName: string | null;
+  /** Commander's value source for this option. Only `cli` is user-supplied. */
+  readonly source: string | null;
+}
+/**
+ * Input shape: a thin projection of commander's parsed-result surface.
+ * The parent extracts the command path, positional args, and per-option
+ * metadata from the leaf command. The sanitiser never consumes raw
+ * argv, never reads `process.argv`, and never sees flag values.
+ */
+interface CommanderResultShape {
+  /**
+   * The full command path from the root program to the leaf, including
+   * the root program name as the first element (the sanitiser drops it).
+   * Example: `['prisma-next', 'migration', 'new']`.
+   */
+  readonly commandPath: readonly string[];
+  /**
+   * Positional arguments commander parsed for the leaf command.
+   * **Intentionally never read.** Accepted so the call site doesn't have
+   * to think about whether to pass it; the sanitiser's contract is that
+   * positionals never leave the parent process.
+   */
+  readonly positionalArgs: readonly string[];
+  /**
+   * Per-option Commander metadata. The sanitiser emits only options whose
+   * source is `cli`, and uses `longName` so telemetry sees user-facing
+   * names (`dry-run`, `connection-string`, `no-install`) rather than
+   * Commander's internal camelCase attribute names or defaulted options.
+   */
+  readonly options: readonly CommanderOptionShape[];
+}
+/**
+ * Output shape: the sanitised projection that flows into the telemetry
+ * payload. Two fields only — command name (space-delimited subcommand
+ * path) and flag names (in commander's option declaration order).
+ */
+interface SanitisedCommand {
+  readonly command: string;
+  readonly flags: readonly string[];
+}
+/**
+ * Project commander's parsed result into the wire-shape command and
+ * flag-name list. Pure; the only allowed inputs are the fields of
+ * `CommanderResultShape`.
+ *
+ * Sanitiser contract — no flag values, no positionals, no raw argv:
+ *   - Drop the root program name (`commandPath[0]`); the wire ships
+ *     `migration new`, not `prisma-next migration new`.
+ *   - Emit only options whose Commander source is `cli`.
+ *   - Emit the long user-facing flag spelling without the `--` prefix;
+ *     never emit Commander's camelCase attribute names.
+ *   - `positionalArgs` is accepted but never consumed; the field exists
+ *     in the input type to make it obvious at the call site that
+ *     positionals were deliberately excluded.
+ */
+declare function sanitizeCommanderResult(input: CommanderResultShape): SanitisedCommand;
+//#endregion
+//#region src/spawn.d.ts
+/**
+ * Inputs the CLI entry point hands the telemetry layer at command
+ * start. The CLI is responsible for stitching commander's result, the
+ * loaded config, and the project root together; the telemetry module
+ * does no I/O of its own except for the user-config read (skipped when
+ * `userConfig` is provided).
+ */
+interface RunTelemetryInputs {
+  /** Sanitised commander snapshot — see `CommanderResultShape`. */
+  readonly command: CommanderResultShape;
+  /** This CLI's own version (from its `package.json`). */
+  readonly version: string;
+  /** Resolved `config.target.targetId`, or `null` when the config could not be loaded. */
+  readonly databaseTarget: string | null;
+  /** Declared extension-pack IDs, in any deterministic order. */
+  readonly extensions: readonly string[];
+  /** Absolute path of the project root (typically `process.cwd()`). */
+  readonly projectRoot: string;
+  /**
+   * Path to the sender entry compiled into this package's `dist/`.
+   * Resolved by the caller because the compiled sender lives at
+   * `<package>/dist/sender.mjs` and only the consumer knows its own
+   * `import.meta.url`.
+   */
+  readonly senderPath: string;
+  /**
+   * `isCI()` result from the consumer. Telemetry is suppressed when
+   * `true` regardless of the stored consent answer — CI environments
+   * never emit (matches the colour-output convention's CI suppression).
+   */
+  readonly isCI: boolean;
+  /** Process env to read for opt-out signals. Defaults to `process.env`. */
+  readonly env?: Readonly<Record<string, string | undefined>>;
+  /** Cached user config when the caller already read it to resolve gates before other work. */
+  readonly userConfig?: UserConfig;
+}
+/**
+ * Best-effort telemetry spawn at command start. Returns synchronously —
+ * the fork runs in the background and never blocks the parent. Every
+ * failure mode is swallowed; the parent's stdout/stderr is untouched in
+ * normal operation, the only escape valve being
+ * `PRISMA_NEXT_DEBUG=1` which routes diagnostics to stderr.
+ *
+ * Returns the spawn outcome so debug-mode logging and the test-harness
+ * probe (which verifies test runs short-circuit the fork) can inspect
+ * the decision without scraping stderr.
+ */
+type TelemetryRunOutcome = {
+  readonly spawned: true;
+} | {
+  readonly spawned: false;
+  readonly reason: 'gated-off' | 'ci' | 'fork-failed';
+};
+declare function runTelemetry(inputs: RunTelemetryInputs): TelemetryRunOutcome;
+/**
+ * Resolve the path to the compiled sender entry relative to a consumer
+ * that has captured its own `import.meta.url`. The CLI's
+ * `tsdown`-emitted entry sits at `<package>/dist/sender.mjs`; the
+ * consumer asks `senderModuleUrl()` and forwards the result to
+ * `runTelemetry({ senderPath })`.
+ */
+declare function senderModuleUrl(importMetaUrl: string): string;
+//#endregion
+export { type CommanderOptionShape, type CommanderResultShape, type GatingDisabledReason, type GatingInputs, type GatingResolution, type ParentToSenderPayload, type RunTelemetryInputs, type SanitisedCommand, TELEMETRY_BACKEND_URL, TELEMETRY_ENDPOINT_PATH, type TelemetryEvent, type TelemetryRunOutcome, type UserConfig, readUserConfig, resolveGating, resolveTelemetryEndpoint, runTelemetry, sanitizeCommanderResult, senderModuleUrl, userConfigPath, writeUserConfig };
+//# sourceMappingURL=index.d.mts.map

package/dist/exports/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/endpoint.ts","../../src/user-config.ts","../../src/gating.ts","../../src/payload.ts","../../src/sanitize.ts","../../src/spawn.ts"],"mappings":";;;;AAIA;cAAa,qBAAA;;;;cAKA,uBAAA;;;;;AAab;;;;;;;iBAAgB,wBAAA,CACd,GAAA,GAAK,QAAA,CAAS,MAAA;;;;;;AAnBhB;;;;;AAKA;UCKiB,UAAA;EAAA,SACN,eAAA;EAAA,SACA,cAAA;EAAA,UACC,GAAA;AAAA;;;;;iBA0CI,cAAA,CAAA;;;;;;iBASA,cAAA,CAAA,GAAkB,UAAA;AAtDlC;;;;;;;;;AA6CA;;;;AA7CA,iBAkFgB,eAAA,CAAgB,OAAA,EAAS,OAAA,CAAQ,UAAA;;;;;AD5FjD;;KEEY,oBAAA;AAAA,KAEA,gBAAA;EAAA,SACG,OAAA;AAAA;EAAA,SACA,OAAA;EAAA,SAAyB,MAAA,EAAQ,oBAAA;AAAA;AAAA,UAE/B,YAAA;EFUD;;;;;;EAAA,SEHL,GAAA,EAAK,QAAA,CAAS,MAAA;EFIwC;EAAA,SEFtD,MAAA,EAAQ,UAAA;AAAA;;;ADPnB;;;;;;;;;AA6CA;;;;;iBCHgB,aAAA,CAAc,MAAA,EAAQ,YAAA,GAAe,gBAAA;;;;;;AFpDrD;;;;;AAKA;;;UGIiB,qBAAA;EAAA,SACN,cAAA;EAAA,SACA,OAAA;EAAA,SACA,OAAA;EAAA,SACA,KAAA;EAAA,SACA,cAAA;EAAA,SACA,UAAA;EHIK;EAAA,SGFL,WAAA;EHEsD;EAAA,SGAtD,QAAA;AAAA;AFTX;;;;AAAA,UE6CiB,cAAA;EAAA,SACN,cAAA;EAAA,SACA,OAAA;EAAA,SACA,OAAA;EAAA,SACA,KAAA;EAAA,SACA,WAAA;EAAA,SACA,cAAA;EAAA,SACA,EAAA;EAAA,SACA,IAAA;EAAA,SACA,cAAA;EAAA,SACA,cAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA;EAAA,SACA,UAAA;AAAA;;;UCxEM,oBAAA;;WAEN,aAAA;EJEE;EAAA,SIAF,QAAA;;WAEA,MAAA;AAAA;AJGX;;;;;AAaA;AAbA,UIMiB,oBAAA;;;;;;WAMN,WAAA;EJEsD;;;;ACTjE;;EDSiE,SIKtD,cAAA;EHdgB;;;;;;EAAA,SGqBhB,OAAA,WAAkB,oBAAA;AAAA;;;;AHiC7B;;UGzBiB,gBAAA;EAAA,SACN,OAAA;EAAA,SACA,KAAA;AAAA;;;;;;;;;;;;AFvCX;;;;iBE+DgB,uBAAA,CAAwB,KAAA,EAAO,oBAAA,GAAuB,gBAAA;;;;AJjEtE;;;;;AAKA;UKMiB,kBAAA;;WAEN,OAAA,EAAS,oBAAA;ELRgB;EAAA,SKUzB,OAAA;ELG6B;EAAA,SKD7B,cAAA;ELEI;EAAA,SKAJ,UAAA;ELAK;EAAA,SKEL,WAAA;ELFsD;;;;;ACTjE;EDSiE,SKStD,UAAA;;;;;;WAMA,IAAA;EJrBY;EAAA,SIuBZ,GAAA,GAAM,QAAA,CAAS,MAAA;EJmBI;EAAA,SIjBnB,UAAA,GAAa,UAAA;AAAA;;AJ0BxB;;;;;AA4BA;;;;;KIxCY,mBAAA;EAAA,SACG,OAAA;AAAA;EAAA,SACA,OAAA;EAAA,SAAyB,MAAA;AAAA;AAAA,iBAExB,YAAA,CAAa,MAAA,EAAQ,kBAAA,GAAqB,mBAAA;AHtD1D;;;;;AAEA;;AAFA,iBGmHgB,eAAA,CAAgB,aAAA"}