@sentry/ember 11.0.0-alpha.1 → 11.0.0-beta.0

package/README.md

@@ -6,53 +6,43 @@
 
 # Official Sentry SDK for Ember.js
 
-## Links
-
-- [Official SDK Docs](https://docs.sentry.io/quickstart/)
-
-## General
-
-This package is an Ember addon that wraps `@sentry/browser`, with added functionality related to Ember. All methods
-available in `@sentry/browser` can be imported from `@sentry/ember`.
+[![npm version](https://img.shields.io/npm/v/@sentry/ember.svg)](https://www.npmjs.com/package/@sentry/ember)
+[![npm dm](https://img.shields.io/npm/dm/@sentry/ember.svg)](https://www.npmjs.com/package/@sentry/ember)
+[![npm dt](https://img.shields.io/npm/dt/@sentry/ember.svg)](https://www.npmjs.com/package/@sentry/ember)
 
-### Installation
+This SDK is a v2 Ember addon that provides error tracking and performance monitoring for Ember.js applications.
 
-As with other Ember addons, run: `ember install @sentry/ember`
+## Requirements
 
-Then add the following to your `<your-app>/app.js`
+- Ember.js 4.0+
+- Node.js 20.19.0+
 
-```javascript
-  import * as Sentry from "@sentry/ember";
+## Installation
 
-  Sentry.init({
-    dsn: '__DSN__' // replace __DSN__ with your DSN,
-
-    // Set tracesSampleRate to 1.0 to capture 100%
-    // of transactions for performance monitoring.
-    // We recommend adjusting this value in production,
-    tracesSampleRate: 1.0,
-  });
+```bash
+npm install @sentry/ember
+# or
+yarn add @sentry/ember
+# or
+pnpm add @sentry/ember
 ```
 
-### Usage
+## Basic Setup
 
-To use this SDK, call `Sentry.init` before the application is initialized, in `app.js`. This will allow Sentry to
-capture information while your app is starting. Any additional SDK settings can be modified via the usual config in
-`environment.js` for you, see the Additional Configuration section for more details.
+Initialize Sentry early in your application, typically in `app/app.ts` or `app/app.js`:
 
-```javascript
+```typescript
 import Application from '@ember/application';
 import Resolver from 'ember-resolver';
 import loadInitializers from 'ember-load-initializers';
-import config from './config/environment';
-import * as Sentry from "@sentry/ember";
+import config from 'my-app/config/environment';
+import * as Sentry from '@sentry/ember';
 
+// Initialize Sentry before the application
 Sentry.init({
-  dsn: '__DSN__' // replace __DSN__ with your DSN,
-
-  // Set tracesSampleRate to 1.0 to capture 100%
-  // of transactions for performance monitoring.
-  // We recommend adjusting this value in production,
+  dsn: '__YOUR_DSN__',
+  // Set tracesSampleRate to 1.0 to capture 100% of transactions for tracing.
+  // We recommend adjusting this value in production
   tracesSampleRate: 1.0,
 });
 
@@ -61,126 +51,118 @@ export default class App extends Application {
   podModulePrefix = config.podModulePrefix;
   Resolver = Resolver;
 }
-```
-
-### Additional Configuration
 
-Aside from configuration passed from this addon into `@sentry/browser` via the `sentry` property, there is also the
-following Ember specific configuration:
+loadInitializers(App, config.modulePrefix);
+```
 
-```javascript
-ENV['@sentry/ember'] = {
-  // Will disable automatic instrumentation of performance.
-  // Manual instrumentation will still be sent.
-  disablePerformance: true,
+## Performance Monitoring
 
-  // All runloop queue durations will be added as spans.
-  minimumRunloopQueueDuration: 0,
+For automatic performance instrumentation (page loads, navigation, runloop, components), create an instance-initializer:
 
-  // Will disable automatic instrumentation for components.
-  disableInstrumentComponents: true,
+```typescript
+// app/instance-initializers/sentry-performance.ts
+import type ApplicationInstance from '@ember/application/instance';
+import { instrumentAppInstancePerformance } from '@sentry/ember';
 
-  // All (non-glimmer) component render durations will be added as spans.
-  minimumComponentRenderDuration: 0,
+export function initialize(appInstance: ApplicationInstance): void {
+  instrumentAppInstancePerformance(appInstance, optionalOptions);
+}
 
-  // All component definitions will be added as spans.
-  enableComponentDefinition: true,
+export default {
+  initialize,
 };
 ```
 
-#### Disabling Performance
+### Performance Options
 
-`@sentry/ember` captures performance by default, if you would like to disable the automatic performance instrumentation,
-you can add the following to your `config/environment.js`:
+| Option                           | Type                  | Default    | Description                               |
+| -------------------------------- | --------------------- | ---------- | ----------------------------------------- |
+| `appInstance`                    | `ApplicationInstance` | _required_ | The Ember application instance            |
+| `disableRunloopPerformance`      | `boolean`             | `false`    | Disable runloop queue tracking            |
+| `disableInstrumentComponents`    | `boolean`             | `false`    | Disable component render tracking         |
+| `enableComponentDefinitions`     | `boolean`             | `false`    | Enable component definition tracking      |
+| `minimumRunloopQueueDuration`    | `number`              | `5`        | Minimum duration (ms) for runloop spans   |
+| `minimumComponentRenderDuration` | `number`              | `2`        | Minimum duration (ms) for component spans |
+| `instrumentPageLoad`             | `boolean`             | `true`     | Instrument page load spans                |
+| `instrumentNavigation`           | `boolean`             | `true`     | Instrument navigation spans               |
+| `idleTimeout`                    | `number`              | `1000`     | Idle timeout (ms) for tracing             |
 
-```javascript
-ENV['@sentry/ember'] = {
-  disablePerformance: true, // Will disable automatic instrumentation of performance. Manual instrumentation will still be sent.
-};
-```
+### Route Performance Instrumentation
 
-### Performance
+To instrument individual routes with detailed lifecycle tracking, use the `instrumentRoutePerformance` decorator:
 
-#### Routes
-
-If you would like to capture `beforeModel`, `model`, `afterModel` and `setupController` times for one of your routes,
-you can import `instrumentRoutePerformance` and wrap your route with it.
-
-```javascript
+```typescript
+// app/routes/application.ts
 import Route from '@ember/routing/route';
 import { instrumentRoutePerformance } from '@sentry/ember';
 
-class MyRoute extends Route {
-  model() {
-    //...
+class ApplicationRoute extends Route {
+  async model() {
+    return this.store.findAll('post');
   }
 }
 
-export default instrumentRoutePerformance(MyRoute);
+export default instrumentRoutePerformance(ApplicationRoute);
 ```
 
-#### Runloop
+This wraps the route's `beforeModel`, `model`, `afterModel`, and `setupController` hooks with Sentry spans.
 
-The runloop queue durations are instrumented by default, as long as they are longer than a threshold (by default 5ms).
-This helps (via the render queue) capturing the entire render in case component render times aren't fully instrumented,
-such as when using glimmer components.
+## API
 
-If you would like to change the runloop queue threshold, add the following to your config:
+This package re-exports everything from `@sentry/browser`, so you have access to the full Sentry Browser SDK API:
 
-```javascript
-ENV['@sentry/ember'] = {
-  minimumRunloopQueueDuration: 0, // All runloop queue durations will be added as spans.
-};
-```
+```typescript
+import * as Sentry from '@sentry/ember';
 
-#### Components
+// Capture an error
+Sentry.captureException(new Error('Something went wrong'));
 
-Non-glimmer component render times will automatically get captured.
+// Capture a message
+Sentry.captureMessage('Something happened');
 
-If you would like to disable component render being instrumented, add the following to your config:
+// Set user context
+Sentry.setUser({ id: '123', email: 'user@example.com' });
 
-```javascript
-ENV['@sentry/ember'] = {
-  disableInstrumentComponents: true, // Will disable automatic instrumentation for components.
-};
+// Add breadcrumb
+Sentry.addBreadcrumb({
+  category: 'ui.click',
+  message: 'User clicked button',
+  level: 'info',
+});
+
+// Create a span
+Sentry.startSpan({ name: 'my-operation', op: 'task' }, () => {
+  // ... do work
+});
 ```
 
-Additionally, components whose render time is below a threshold (by default 2ms) will not be included as spans. If you
-would like to change this threshold, add the following to your config:
+## Migration from v1 Addon
 
-```javascript
-ENV['@sentry/ember'] = {
-  minimumComponentRenderDuration: 0, // All (non-glimmer) component render durations will be added as spans.
-};
-```
+If you're upgrading from an older version of `@sentry/ember` (v1 addon format), here are the key changes:
 
-#### Glimmer components
+### What Changed
 
-Currently glimmer component render durations can only be captured indirectly via the runloop instrumentation. You can
-optionally enable a setting to show component definitions (which will indicate which components are being rendered) be
-adding the following to your config:
+1. **No automatic instance initializer**: You must now explicitly set up performance instrumentation by creating an instance-initializer that calls `instrumentAppInstancePerformance(appInstance)`.
 
-```javascript
-ENV['@sentry/ember'] = {
-  enableComponentDefinition: true, // All component definitions will be added as spans.
-};
-```
+2. **No `contentFor` hooks**: The addon no longer injects scripts via `contentFor`.
 
-### Supported Versions
+3. **No environment config via `ENV['@sentry/ember']`**: Configure Sentry directly via `Sentry.init()` in your app.ts.
 
-- **Ember.js**: v4.0 or above
-- **Node**: v14.18 or above
+4. **Simpler dependency tree**: The v2 addon format has fewer dependencies and works better with modern build tools like Vite and Embroider.
 
-### Previous Integration
+### Migration Steps
 
-Previously we've recommended using the Ember integration from `@sentry/integrations` but moving forward we will be using
-this Ember addon to offer more Ember-specific error and performancing monitoring.
+1. Update your `app/app.ts` to call `Sentry.init()` directly with your configuration.
 
-## Testing
+2. Create `app/instance-initializers/sentry-performance.ts` to set up performance monitoring using `instrumentAppInstancePerformance`.
 
-For this package itself, you can find example instrumentation in the `dummy` application, which is also used for
-testing. To test with the dummy application, you must pass the dsn as an environment variable.
+3. Remove any `@sentry/ember` configuration from `config/environment.js`.
 
-```javascript
-SENTRY_DSN=__DSN__ ember serve
-```
+## Links
+
+- [Official SDK Docs](https://docs.sentry.io/platforms/javascript/guides/ember/)
+- [TypeDoc](http://getsentry.github.io/sentry-javascript/)
+
+## License
+
+MIT

package/addon-main.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+const { addonV1Shim } = require('@embroider/addon-shim');
+module.exports = addonV1Shim(__dirname);

package/declarations/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @sentry/ember - Official Sentry SDK for Ember.js
+ *
+ * @see {@link https://docs.sentry.io/platforms/javascript/guides/ember/ Sentry Ember Documentation}
+ */
+export * from '@sentry/browser';
+export { init } from './init.ts';
+export { instrumentRoutePerformance } from './utils/instrumentRoutePerformance.ts';
+export { browserTracingIntegration, instrumentAppInstancePerformance } from './utils/browserTracingIntegration.ts';
+//# sourceMappingURL=index.d.ts.map

package/declarations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,iBAAiB,CAAC;AAGhC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,yBAAyB,EAAE,gCAAgC,EAAE,MAAM,sCAAsC,CAAC"}

package/declarations/init.d.ts

@@ -0,0 +1,23 @@
+import type { BrowserOptions } from '@sentry/browser';
+import type { Client } from '@sentry/core';
+/**
+ * Initialize the Sentry SDK for Ember.
+ *
+ * This should be called early in your application's startup, typically in app/app.ts
+ * before your Application class is defined.
+ *
+ * @param config - Sentry browser options
+ * @returns The Sentry client instance
+ *
+ * @example
+ * ```typescript
+ * import * as Sentry from '@sentry/ember';
+ *
+ * Sentry.init({
+ *   dsn: 'YOUR_DSN_HERE',
+ *   tracesSampleRate: 1.0,
+ * });
+ * ```
+ */
+export declare function init(config?: BrowserOptions): Client | undefined;
+//# sourceMappingURL=init.d.ts.map

package/declarations/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAMhE"}

package/{utils → declarations/utils}/browserTracingIntegration.d.ts

@@ -1,8 +1,8 @@
 import { browserTracingIntegration as originalBrowserTracingIntegration } from '@sentry/browser';
-import { type Integration } from '@sentry/core';
+import type { Integration } from '@sentry/core';
 import type ApplicationInstance from '@ember/application/instance';
 type EmberBrowserTracingIntegrationOptions = Parameters<typeof originalBrowserTracingIntegration>[0] & {
-    appInstance?: ApplicationInstance;
+    appInstance: ApplicationInstance;
     disableRunloopPerformance?: boolean;
     minimumRunloopQueueDuration?: number;
     disableInstrumentComponents?: boolean;
@@ -11,4 +11,9 @@ type EmberBrowserTracingIntegrationOptions = Parameters<typeof originalBrowserTr
     disableInitialLoadInstrumentation?: boolean;
 };
 export declare function browserTracingIntegration(options: EmberBrowserTracingIntegrationOptions): Integration;
+/**
+ * Utility to simplify adding the browser tracing integration to an app instance.
+ */
+export declare function instrumentAppInstancePerformance(appInstance: ApplicationInstance, options?: Partial<Parameters<typeof browserTracingIntegration>[0]>): void;
 export {};
+//# sourceMappingURL=browserTracingIntegration.d.ts.map

package/declarations/utils/browserTracingIntegration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserTracingIntegration.d.ts","sourceRoot":"","sources":["../../src/utils/browserTracingIntegration.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,yBAAyB,IAAI,iCAAiC,EAG/D,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,mBAAmB,MAAM,6BAA6B,CAAC;AAKnE,KAAK,qCAAqC,GAAG,UAAU,CAAC,OAAO,iCAAiC,CAAC,CAAC,CAAC,CAAC,GAAG;IACrG,WAAW,EAAE,mBAAmB,CAAC;IACjC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,8BAA8B,CAAC,EAAE,MAAM,CAAC;IACxC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,iCAAiC,CAAC,EAAE,OAAO,CAAC;CAC7C,CAAC;AAIF,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,qCAAqC,GAAG,WAAW,CAmDrG;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAC9C,WAAW,EAAE,mBAAmB,EAChC,OAAO,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC,GACjE,IAAI,CAaN"}

package/{utils → declarations/utils}/instrumentEmberAppInstanceForPerformance.d.ts

@@ -1,11 +1,19 @@
 import type ApplicationInstance from '@ember/application/instance';
 import type { startBrowserTracingNavigationSpan as startBrowserTracingNavigationSpanType, startBrowserTracingPageLoadSpan as startBrowserTracingPageLoadSpanType } from '@sentry/browser';
-import type { Client } from '@sentry/core';
-import type { EmberRouterMain } from '../types';
+import { type Client } from '@sentry/core';
+interface EmberRouterMain {
+    location: {
+        formatURL?: (url: string) => string;
+        getURL?: () => string;
+        implementation?: string;
+        rootURL: string;
+    };
+}
 export declare function instrumentEmberAppInstanceForPerformance(client: Client, appInstance: ApplicationInstance, config: {
     disableRunloopPerformance?: boolean;
     instrumentPageLoad?: boolean;
     instrumentNavigation?: boolean;
 }, startBrowserTracingPageLoadSpan: typeof startBrowserTracingPageLoadSpanType, startBrowserTracingNavigationSpan: typeof startBrowserTracingNavigationSpanType): void;
-export declare function _getRouteUrlAttributes(url: string, params?: Record<string, unknown>, fullUrl?: string): Record<string, string>;
 export declare function _getLocationURL(location: EmberRouterMain['location']): string;
+export {};
+//# sourceMappingURL=instrumentEmberAppInstanceForPerformance.d.ts.map

package/declarations/utils/instrumentEmberAppInstanceForPerformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentEmberAppInstanceForPerformance.d.ts","sourceRoot":"","sources":["../../src/utils/instrumentEmberAppInstanceForPerformance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,mBAAmB,MAAM,6BAA6B,CAAC;AAGnE,OAAO,KAAK,EACV,iCAAiC,IAAI,qCAAqC,EAC1E,+BAA+B,IAAI,mCAAmC,EACvE,MAAM,iBAAiB,CAAC;AAUzB,OAAO,EAOL,KAAK,MAAM,EAEZ,MAAM,cAAc,CAAC;AAGtB,UAAU,eAAe;IACvB,QAAQ,EAAE;QACR,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;QACpC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;QACtB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAID,wBAAgB,wCAAwC,CACtD,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,mBAAmB,EAChC,MAAM,EAAE;IAAE,yBAAyB,CAAC,EAAE,OAAO,CAAC;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAAE,EAC7G,+BAA+B,EAAE,OAAO,mCAAmC,EAC3E,iCAAiC,EAAE,OAAO,qCAAqC,GAC9E,IAAI,CAyIN;AA+ED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,GAAG,MAAM,CAW7E"}

package/{utils → declarations/utils}/instrumentEmberGlobals.d.ts

@@ -19,3 +19,4 @@ export declare function instrumentGlobalsForPerformance(config: {
 export declare function _processComponentRenderBefore(payload: Payload, beforeEntries: RenderEntries): void;
 export declare function _processComponentRenderAfter(payload: Payload, beforeEntries: RenderEntries, op: string, minComponentDuration: number): void;
 export {};
+//# sourceMappingURL=instrumentEmberGlobals.d.ts.map

package/declarations/utils/instrumentEmberGlobals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentEmberGlobals.d.ts","sourceRoot":"","sources":["../../src/utils/instrumentEmberGlobals.ts"],"names":[],"mappings":"AAYA,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;AAE1D,2DAA2D;AAC3D,wBAAgB,+BAA+B,CAAC,MAAM,EAAE;IACtD,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,8BAA8B,CAAC,EAAE,MAAM,CAAC;IACxC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,iCAAiC,CAAC,EAAE,OAAO,CAAC;CAC7C,GAAG,IAAI,CAwBP;AAwED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,aAAa,GAAG,IAAI,CAElG;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,EAC5B,EAAE,EAAE,MAAM,EACV,oBAAoB,EAAE,MAAM,GAC3B,IAAI,CA4BN"}

package/declarations/utils/instrumentRoutePerformance.d.ts

@@ -0,0 +1,28 @@
+import type Route from '@ember/routing/route';
+type RouteConstructor = new (...args: ConstructorParameters<typeof Route>) => Route;
+/**
+ * Enables monitoring the performance of an Ember app.
+ *
+ * This wraps the route's lifecycle hooks (beforeModel, model, afterModel, setupController)
+ * with Sentry spans to track their performance.
+ *
+ * @param BaseRoute - The Route class to instrument
+ * @returns The instrumented Route class
+ *
+ * @example
+ * ```ts
+ * import Route from '@ember/routing/route';
+ * import { instrumentRoutePerformance } from '@sentry/ember';
+ *
+ * class ApplicationRoute extends Route {
+ *   async model() {
+ *     return this.store.findAll('post');
+ *   }
+ * }
+ *
+ * export default instrumentRoutePerformance(ApplicationRoute);
+ * ```
+ */
+export declare function instrumentRoutePerformance<T extends RouteConstructor>(BaseRoute: T): T;
+export {};
+//# sourceMappingURL=instrumentRoutePerformance.d.ts.map

package/declarations/utils/instrumentRoutePerformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentRoutePerformance.d.ts","sourceRoot":"","sources":["../../src/utils/instrumentRoutePerformance.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAC;AAE9C,KAAK,gBAAgB,GAAG,KAAK,GAAG,IAAI,EAAE,qBAAqB,CAAC,OAAO,KAAK,CAAC,KAAK,KAAK,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,gBAAgB,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,CA8CtF"}

package/declarations/utils/utils.d.ts

@@ -0,0 +1,7 @@
+interface ExtendedBackburner {
+    on(eventName: string, callback: (...args: unknown[]) => void): void;
+    off(eventName: string, callback: (...args: unknown[]) => void): void;
+}
+export declare function getBackburner(): Pick<ExtendedBackburner, 'on' | 'off'>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/declarations/utils/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAEA,UAAU,kBAAkB;IAC1B,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IACpE,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;CACtE;AAED,wBAAgB,aAAa,IAAI,IAAI,CAAC,kBAAkB,EAAE,IAAI,GAAG,KAAK,CAAC,CAiBtE"}