@warp-drive/ember 5.4.1-beta.1 → 5.4.1-beta.2

package/unstable-preview-types/index.d.ts

@@ -1,7 +1,6 @@
-/// <reference path="./-private/request-state.d.ts" />
-/// <reference path="./-private/promise-state.d.ts" />
-/// <reference path="./-private/await.d.ts" />
+/// <reference path="./install.d.ts" />
 /// <reference path="./-private/request.d.ts" />
+/// <reference path="./-private/await.d.ts" />
 declare module '@warp-drive/ember' {
   /**
    * <h3 align="center">⚛️ Data utilities for using <em style="color: lightgreen">Warp</em><strong style="color: magenta">Drive</strong> with 🐹 <em style="color: orange">Ember</em><em style="color: lightblue">.js</em></h3>
@@ -19,12 +18,211 @@ declare module '@warp-drive/ember' {
    * and components that enable you to build robust performant apps with
    * elegant control flow.
    *
+   * ## Using .hbs
+   *
+   * The components and utils this library exports are intended for use with Glimmer
+   * Flavored JavaScript (gjs). To use them in handlebars files, your app should re-
+   * export them. For instance:
+   *
+   * *app/components/await.ts*
+   * ```ts
+   * export { Await as default } from '@warp-drive/ember';
+   * ```
+   *
+   * ```hbs
+   * <Await @promise={{this.getTheData}}></Await>
+   * ```
+   *
+   * This allows renaming them to avoid conflicts just by using a different filename
+   * if desired:
+   *
+   * *app/components/warp-drive-await.ts*
+   * ```ts
+   * export { Await as default } from '@warp-drive/ember';
+   * ```
+   *
+   * ```hbs
+   * <WarpDriveAwait @promise={{this.getTheData}}></WarpDriveAwait>
+   * ```
+   *
    * @module @warp-drive/ember
    * @main @warp-drive/ember
    */
-  export { getRequestState } from '@warp-drive/ember/-private/request-state';
-  export { getPromiseState } from '@warp-drive/ember/-private/promise-state';
-  export { Request } from '@warp-drive/ember/-private/request.gts';
-  export { Await, Throw } from '@warp-drive/ember/-private/await.gts';
+  export { Request } from './-private/request';
+  export { Await, Throw } from './-private/await';
+  /**
+   * PromiseState provides a reactive wrapper for a promise which allows you write declarative
+   * code around a promise's control flow. It is useful in both Template and JavaScript contexts,
+   * allowing you to quickly derive behaviors and data from pending, error and success states.
+   *
+   * ```ts
+   * interface PromiseState<T = unknown, E = unknown> {
+   *   isPending: boolean;
+   *   isSuccess: boolean;
+   *   isError: boolean;
+   *   result: T | null;
+   *   error: E | null;
+   * }
+   * ```
+   *
+   * To get the state of a promise, use `getPromiseState`.
+   *
+   * @class PromiseState
+   * @public
+   */
+  /**
+   * Returns a reactive state-machine for the provided promise or awaitable.
+   *
+   * Repeat calls to `getPromiseState` with the same promise will return the same state object
+   * making is safe and easy to use in templates and JavaScript code to produce reactive
+   * behaviors around promises.
+   *
+   * `getPromiseState` can be used in both JavaScript and Template contexts.
+   *
+   * ```ts
+   * import { getPromiseState } from '@warp-drive/ember';
+   *
+   * const state = getPromiseState(promise);
+   * ```
+   *
+   * For instance, we could write a getter on a component that updates whenever
+   * the promise state advances or the promise changes, by combining the function
+   * with the use of `@cached`
+   *
+   * ```ts
+   * class Component {
+   *   @cached
+   *   get title() {
+   *     const state = getPromiseState(this.args.request);
+   *     if (state.isPending) {
+   *       return 'loading...';
+   *     }
+   *     if (state.isError) { return null; }
+   *     return state.result.title;
+   *   }
+   * }
+   * ```
+   *
+   * Or in a template as a helper:
+   *
+   * ```gjs
+   * import { getPromiseState } from '@warp-drive/ember';
+   *
+   * <template>
+   *   {{#let (getPromiseState @request) as |state|}}
+   *     {{#if state.isPending}} <Spinner />
+   *     {{else if state.isError}} <ErrorForm @error={{state.error}} />
+   *     {{else}}
+   *       <h1>{{state.result.title}}</h1>
+   *     {{/if}}
+   *   {{/let}}
+   * </template>
+   * ```
+   *
+   * If looking to use in a template, consider also the `<Await />` component.
+   *
+   * @method getPromiseState
+   * @for @warp-drive/ember
+   * @static
+   * @public
+   * @param {Promise<T> | Awaitable<T, E>} promise
+   * @return {PromiseState<T, E>}
+   */
+  export { getPromiseState } from '@ember-data/store/-private';
+  /**
+   * Lazily consumes the stream of a request, providing a number of
+   * reactive properties that can be used to build UIs that respond
+   * to the progress of a request.
+   *
+   * @class RequestLoadingState
+   * @public
+   */
+  /**
+   * RequestState extends the concept of PromiseState to provide a reactive
+   * wrapper for a request `Future` which allows you write declarative code
+   * around a Future's control flow.
+   *
+   * It is useful in both Template and JavaScript contexts, allowing you
+   * to quickly derive behaviors and data from pending, error and success
+   * states.
+   *
+   * The key difference between a Promise and a Future is that Futures provide
+   * access to a stream of their content, the identity of the request (if any)
+   * as well as the ability to attempt to abort the request.
+   *
+   * ```ts
+   * interface Future<T> extends Promise<T>> {
+   *   getStream(): Promise<ReadableStream>;
+   *   abort(): void;
+   *   lid: StableDocumentIdentifier | null;
+   * }
+   * ```
+   *
+   * These additional APIs allow us to craft even richer state experiences.
+   *
+   * To get the state of a request, use `getRequestState`.
+   *
+   * @class RequestState
+   * @public
+   */
+  /**
+   *
+   *
+   * `getRequestState` can be used in both JavaScript and Template contexts.
+   *
+   * ```ts
+   * import { getRequestState } from '@warp-drive/ember';
+   *
+   * const state = getRequestState(future);
+   * ```
+   *
+   * For instance, we could write a getter on a component that updates whenever
+   * the request state advances or the future changes, by combining the function
+   * with the use of `@cached`
+   *
+   * ```ts
+   * class Component {
+   *   @cached
+   *   get title() {
+   *     const state = getRequestState(this.args.request);
+   *     if (state.isPending) {
+   *       return 'loading...';
+   *     }
+   *     if (state.isError) { return null; }
+   *     return state.result.title;
+   *   }
+   * }
+   * ```
+   *
+   * Or in a template as a helper:
+   *
+   * ```gjs
+   * import { getRequestState } from '@warp-drive/ember';
+   *
+   * <template>
+   *   {{#let (getRequestState @request) as |state|}}
+   *     {{#if state.isPending}}
+   *       <Spinner />
+   *     {{else if state.isError}}
+   *       <ErrorForm @error={{state.error}} />
+   *     {{else}}
+   *       <h1>{{state.result.title}}</h1>
+   *     {{/if}}
+   *   {{/let}}
+   * </template>
+   * ```
+   *
+   * If looking to use in a template, consider also the `<Request />` component
+   * which offers a numbe of additional capabilities for requests *beyond* what
+   * `RequestState` provides.
+   *
+   * @method getRequestState
+   * @for @warp-drive/ember
+   * @static
+   * @public
+   * @param future
+   * @return {RequestState}
+   */
+  export { getRequestState, type RequestLoadingState } from '@ember-data/store/-private';
 }
 //# sourceMappingURL=index.d.ts.map

package/unstable-preview-types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,OAAO,EAAE,eAAe,EAAE,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/unstable-preview-types/install.d.ts

@@ -0,0 +1,17 @@
+declare module '@warp-drive/ember/install' {
+  import { tagForProperty } from '@ember/-internals/metal';
+  type Tag = ReturnType<typeof tagForProperty>;
+  export function buildSignalConfig(options: {
+      wellknown: {
+          Array: symbol | string;
+      };
+  }): {
+      createSignal(obj: object, key: string | symbol): import("@glimmer/validator").Tag | [import("@glimmer/validator").Tag, import("@glimmer/validator").Tag, import("@glimmer/validator").Tag];
+      consumeSignal(signal: Tag | [Tag, Tag, Tag]): void;
+      notifySignal(signal: Tag | [Tag, Tag, Tag]): void;
+      createMemo: <F>(object: object, key: string | symbol, fn: () => F) => (() => F);
+      willSyncFlushWatchers: () => boolean;
+  };
+  export {};
+}
+//# sourceMappingURL=install.d.ts.map

package/unstable-preview-types/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAQzD,KAAK,GAAG,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAG7C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,SAAS,EAAE;QACT,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;KACxB,CAAC;CACH;sBAIqB,MAAM,OAAO,MAAM,GAAG,MAAM;0BAQxB,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;yBAYtB,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;iBAW7B,CAAC,UAAU,MAAM,OAAO,MAAM,GAAG,MAAM,MAAM,MAAM,CAAC,KAAG,CAAC,MAAM,CAAC,CAAC;;EAwBhF"}

package/unstable-preview-types/-private/promise-state.d.ts

@@ -1,91 +0,0 @@
-declare module '@warp-drive/ember/-private/promise-state' {
-  import type { Awaitable } from '@ember-data/request';
-  /**
-   * PromiseState provides a reactive wrapper for a promise which allows you write declarative
-   * code around a promise's control flow. It is useful in both Template and JavaScript contexts,
-   * allowing you to quickly derive behaviors and data from pending, error and success states.
-   *
-   * ```ts
-   * interface PromiseState<T = unknown, E = unknown> {
-   *   isPending: boolean;
-   *   isSuccess: boolean;
-   *   isError: boolean;
-   *   result: T | null;
-   *   error: E | null;
-   * }
-   * ```
-   *
-   * To get the state of a promise, use `getPromiseState`.
-   *
-   * @class PromiseState
-   * @public
-   */
-  export class PromiseState<T = unknown, E = unknown> {
-      result: T | null;
-      error: E | null;
-      isPending: boolean;
-      isSuccess: boolean;
-      isError: boolean;
-      constructor(promise: Promise<T> | Awaitable<T, E>);
-  }
-  /**
-   * Returns a reactive state-machine for the provided promise or awaitable.
-   *
-   * Repeat calls to `getPromiseState` with the same promise will return the same state object
-   * making is safe and easy to use in templates and JavaScript code to produce reactive
-   * behaviors around promises.
-   *
-   * `getPromiseState` can be used in both JavaScript and Template contexts.
-   *
-   * ```ts
-   * import { getPromiseState } from '@warp-drive/ember';
-   *
-   * const state = getPromiseState(promise);
-   * ```
-   *
-   * For instance, we could write a getter on a component that updates whenever
-   * the promise state advances or the promise changes, by combining the function
-   * with the use of `@cached`
-   *
-   * ```ts
-   * class Component {
-   *   @cached
-   *   get title() {
-   *     const state = getPromiseState(this.args.request);
-   *     if (state.isPending) {
-   *       return 'loading...';
-   *     }
-   *     if (state.isError) { return null; }
-   *     return state.result.title;
-   *   }
-   * }
-   * ```
-   *
-   * Or in a template as a helper:
-   *
-   * ```gjs
-   * import { getPromiseState } from '@warp-drive/ember';
-   *
-   * <template>
-   *   {{#let (getPromiseState @request) as |state|}}
-   *     {{#if state.isPending}} <Spinner />
-   *     {{else if state.isError}} <ErrorForm @error={{state.error}} />
-   *     {{else}}
-   *       <h1>{{state.result.title}}</h1>
-   *     {{/if}}
-   *   {{/let}}
-   * </template>
-   * ```
-   *
-   * If looking to use in a template, consider also the `<Await />` component.
-   *
-   * @method getPromiseState
-   * @for @warp-drive/ember
-   * @static
-   * @public
-   * @param {Promise<T> | Awaitable<T, E>} promise
-   * @return {PromiseState<T, E>}
-   */
-  export function getPromiseState<T = unknown, E = unknown>(promise: Promise<T> | Awaitable<T, E>): PromiseState<T, E>;
-}
-//# sourceMappingURL=promise-state.d.ts.map

package/unstable-preview-types/-private/promise-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"promise-state.d.ts","sourceRoot":"","sources":["../../src/-private/promise-state.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAKrD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IACvC,MAAM,EAAE,CAAC,GAAG,IAAI,CAAQ;IACxB,KAAK,EAAE,CAAC,GAAG,IAAI,CAAQ;IACvB,SAAS,UAAQ;IACjB,SAAS,UAAS;IAClB,OAAO,UAAS;gBAEb,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;CA8BlD;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAgB,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAUnH"}

package/unstable-preview-types/-private/request-state.d.ts

@@ -1,149 +0,0 @@
-declare module '@warp-drive/ember/-private/request-state' {
-  import type { Future, ImmutableRequestInfo, ResponseInfo, StructuredErrorDocument } from '@ember-data/request';
-  /**
-   * Lazily consumes the stream of a request, providing a number of
-   * reactive properties that can be used to build UIs that respond
-   * to the progress of a request.
-   *
-   * @class RequestLoadingState
-   * @public
-   */
-  export class RequestLoadingState {
-      _stream: TransformStream | null;
-      _future: Future<unknown>;
-      _triggered: boolean;
-      _trigger(): void;
-      promise: Promise<void> | null;
-      _sizeHint: number;
-      _bytesLoaded: number;
-      _startTime: number;
-      _endTime: number;
-      _lastPacketTime: number;
-      _isPending: boolean;
-      _isStarted: boolean;
-      _isComplete: boolean;
-      _isCancelled: boolean;
-      _isErrored: boolean;
-      _error: Error | null;
-      get isPending(): boolean;
-      get sizeHint(): number;
-      get stream(): ReadableStream | null;
-      get isStarted(): boolean;
-      get bytesLoaded(): number;
-      get startTime(): number;
-      get endTime(): number;
-      get lastPacketTime(): number;
-      get isComplete(): boolean;
-      get isCancelled(): boolean;
-      get isErrored(): boolean;
-      get error(): Error | null;
-      get elapsedTime(): number;
-      get completedRatio(): number;
-      get remainingRatio(): number;
-      get duration(): number;
-      get speed(): number;
-      constructor(future: Future<unknown>);
-      abort: () => void;
-  }
-  /**
-   * RequestState extends the concept of PromiseState to provide a reactive
-   * wrapper for a request `Future` which allows you write declarative code
-   * around a Future's control flow.
-   *
-   * It is useful in both Template and JavaScript contexts, allowing you
-   * to quickly derive behaviors and data from pending, error and success
-   * states.
-   *
-   * The key difference between a Promise and a Future is that Futures provide
-   * access to a stream of their content, the identity of the request (if any)
-   * as well as the ability to attempt to abort the request.
-   *
-   * ```ts
-   * interface Future<T> extends Promise<T>> {
-   *   getStream(): Promise<ReadableStream>;
-   *   abort(): void;
-   *   lid: StableDocumentIdentifier | null;
-   * }
-   * ```
-   *
-   * These additional APIs allow us to craft even richer state experiences.
-   *
-   * To get the state of a request, use `getRequestState`.
-   *
-   * @class RequestState
-   * @public
-   */
-  export class RequestState<T = unknown, RT = unknown> {
-      #private;
-      result: RT | null;
-      error: StructuredErrorDocument | null;
-      isLoading: boolean;
-      isSuccess: boolean;
-      isError: boolean;
-      request: ImmutableRequestInfo<T, RT> | null;
-      response: Response | ResponseInfo | null;
-      get isCancelled(): boolean;
-      get loadingState(): RequestLoadingState;
-      constructor(future: Future<RT>);
-  }
-  /**
-   *
-   *
-   * `getRequestState` can be used in both JavaScript and Template contexts.
-   *
-   * ```ts
-   * import { getRequestState } from '@warp-drive/ember';
-   *
-   * const state = getRequestState(future);
-   * ```
-   *
-   * For instance, we could write a getter on a component that updates whenever
-   * the request state advances or the future changes, by combining the function
-   * with the use of `@cached`
-   *
-   * ```ts
-   * class Component {
-   *   @cached
-   *   get title() {
-   *     const state = getRequestState(this.args.request);
-   *     if (state.isPending) {
-   *       return 'loading...';
-   *     }
-   *     if (state.isError) { return null; }
-   *     return state.result.title;
-   *   }
-   * }
-   * ```
-   *
-   * Or in a template as a helper:
-   *
-   * ```gjs
-   * import { getRequestState } from '@warp-drive/ember';
-   *
-   * <template>
-   *   {{#let (getRequestState @request) as |state|}}
-   *     {{#if state.isPending}}
-   *       <Spinner />
-   *     {{else if state.isError}}
-   *       <ErrorForm @error={{state.error}} />
-   *     {{else}}
-   *       <h1>{{state.result.title}}</h1>
-   *     {{/if}}
-   *   {{/let}}
-   * </template>
-   * ```
-   *
-   * If looking to use in a template, consider also the `<Request />` component
-   * which offers a numbe of additional capabilities for requests *beyond* what
-   * `RequestState` provides.
-   *
-   * @method getRequestState
-   * @for @warp-drive/ember
-   * @static
-   * @public
-   * @param future
-   * @return {RequestState}
-   */
-  export function getRequestState<RT, T>(future: Future<RT>): RequestState<T, RT>;
-}
-//# sourceMappingURL=request-state.d.ts.map

package/unstable-preview-types/-private/request-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"request-state.d.ts","sourceRoot":"","sources":["../../src/-private/request-state.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,MAAM,EACN,oBAAoB,EACpB,YAAY,EAEZ,uBAAuB,EACxB,MAAM,qBAAqB,CAAC;AAiE7B;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,EAAE,eAAe,GAAG,IAAI,CAAQ;IACvC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IACzB,UAAU,UAAS;IACnB,QAAQ;IAgCR,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAQ;IAC5B,SAAS,SAAK;IACd,YAAY,SAAK;IAEjB,UAAU,SAAK;IACf,QAAQ,SAAK;IACb,eAAe,SAAK;IAEpB,UAAU,UAAQ;IAClB,UAAU,UAAS;IACnB,WAAW,UAAS;IACpB,YAAY,UAAS;IACrB,UAAU,UAAS;IACnB,MAAM,EAAE,KAAK,GAAG,IAAI,CAAQ;IAErC,IAAI,SAAS,IAAI,OAAO,CAGvB;IAED,IAAI,QAAQ,IAAI,MAAM,CAGrB;IAED,IAAI,MAAM,IAAI,cAAc,GAAG,IAAI,CASlC;IAED,IAAI,SAAS,IAAI,OAAO,CAGvB;IAED,IAAI,WAAW,IAAI,MAAM,CAGxB;IAED,IAAI,SAAS,IAAI,MAAM,CAGtB;IAED,IAAI,OAAO,IAAI,MAAM,CAGpB;IAED,IAAI,cAAc,IAAI,MAAM,CAG3B;IAED,IAAI,UAAU,IAAI,OAAO,CAGxB;IAED,IAAI,WAAW,IAAI,OAAO,CAGzB;IAED,IAAI,SAAS,IAAI,OAAO,CAGvB;IAED,IAAI,KAAK,IAAI,KAAK,GAAG,IAAI,CAGxB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,cAAc,IAAI,MAAM,CAE3B;IAED,IAAI,cAAc,IAAI,MAAM,CAE3B;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,KAAK,IAAI,MAAM,CAGlB;gBAEW,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC;IAInC,KAAK,QAAO,IAAI,CAEd;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,EAAE,GAAG,OAAO;;IAIxC,MAAM,EAAE,EAAE,GAAG,IAAI,CAAQ;IACzB,KAAK,EAAE,uBAAuB,GAAG,IAAI,CAAQ;IAC7C,SAAS,UAAQ;IACjB,SAAS,UAAS;IAClB,OAAO,UAAS;IAChB,OAAO,EAAE,oBAAoB,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,CAAQ;IACnD,QAAQ,EAAE,QAAQ,GAAG,YAAY,GAAG,IAAI,CAAQ;IAEzD,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,IAAI,YAAY,wBAMf;gBAEW,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;CAqC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAS9E"}