@serenity-js/core 3.0.0-rc.8 → 3.0.0

package/lib/stage/Cast.d.ts

@@ -1,74 +1,167 @@
-import { Ability, Actor } from '../screenplay';
+import { Actor } from '../screenplay';
 /**
- * @desc
- *  Describes the {@link Actor}s available to take part in the performance.
+ * Serenity/JS uses the concept of a _**cast of actors**_ to centralise the process of configuring the {@apilink Actor|actors} and assigning their {@apilink Ability|abilities}.
  *
- * @example <caption>Define a cast of actors interacting with a Web UI</caption>
+ * When you invoke {@apilink actorCalled} for the first time in a test scenario,
+ * Serenity/JS {@apilink Actor|instantiates a new actor}
+ * and passes it through the {@apilink Cast.prepare} method.
+ * Specifying a **custom cast** gives you an opportunity to configure the actor with the abilities
+ * they need before it's returned to the caller,
+ * or configure the actors differently **depending on their name**.
+ * It also helps you to avoid having to configure abilities individually in every test scenario.
  *
- *  import { engage, Actor, Cast } from '@serenity-js/core';
- *  import { BrowseTheWeb } from '@serenity-js/protractor';
- *  import { protractor } from 'protractor';
+ * :::tip Remember
+ * A **cast** is responsible for assigning **abilities** to **actors** in a central location.
+ * :::
  *
- *  class UIActors implements Cast {
- *      prepare(actor: Actor) {
- *          return actor.whoCan(BrowseTheWeb.using(protractor.browser));
- *      }
- *  }
+ * ## Configuring a cast of actors for the entire test suite
  *
- *  beforeEach(() => engage(new UIActors()));
+ * When working with relatively **simple scenarios** where all the actors should always receive the same set of abilities,
+ * you can {@apilink configure} Serenity/JS to use a generic {@apilink Cast.where}:
  *
- * @example <caption>Using a generic cast</caption>
+ * ```typescript
+ * import { Cast, configure } from '@serenity-js/core'
+ * import { CallAnApi } from '@serenity-js/rest'
  *
- *  import { engage, Cast } from '@serenity-js/core';
- *  import { BrowseTheWeb } from '@serenity-js/protractor';
- *  import { protractor } from 'protractor';
+ * configure({
+ *   actors: Cast.where(actor => actor.whoCan(
+ *     CallAnApi.at('http://api.example.org'),
+ *     // other abilities
+ *   ))
+ * })
+ * ```
  *
- *  beforeEach(() => engage(BrowseTheWeb.using(protractor.browser)));
+ * If you're using Serenity/JS with one of the [supported test runners](/handbook/test-runners/),
+ * you might prefer to use your test runner's native configuration mechanism
+ * instead of invoking {@apilink configure} explicitly.
  *
- * @example <caption>Preparing actors differently based on their name</caption>
+ * :::tip configure vs engage
+ * Calling {@apilink configure} resets the entire Serenity/JS configuration
+ * and should be done exactly once in your entire test suite.
+ * If you want to retain the configuration but reset the cast, use {@apilink engage} instead.
+ * :::
  *
- *  import { actorCalled, engage, Cast } from '@serenity-js/core';
- *  import { BrowseTheWeb } from '@serenity-js/protractor';
- *  import { CallAnApi } from '@serenity-js/rest';
- *  import { protractor } from 'protractor';
+ * Learn more about configuring Serenity/JS with:
+ * - [Cucumber.js](/handbook/test-runners/cucumber)
+ * - [Jasmine](/handbook/test-runners/jasmine)
+ * - [Mocha](/handbook/test-runners/mocha)
+ * - [Playwright Test](/handbook/test-runners/playwright-test)
+ * - [Protractor](/handbook/test-runners/protractor)
+ * - [WebdriverIO](/handbook/test-runners/webdriverio)
  *
- *  class Actors implements Cast {
- *      prepare(actor: Actor) {
- *          switch (actor.name) {
- *              case 'James':
- *                  return actor.whoCan(BrowseTheWeb.using(protractor.browser));
- *              default:
- *                  return actor.whoCan(CallAnApi.at(protractor.browser.baseUrl));
- *          }
- *      }
- *  }
+ * ## Engaging a cast of actors for the specific scenario
  *
- *  beforeEach(() => engage(new Actors()));
+ * If you want to retain Serenity/JS configuration, but set a different {@apilink Cast}
+ * for the given test scenario you should use {@apilink engage} instead of {@apilink configure}.
  *
- *  actorCalled('James') // returns an actor using a browser
- *  actorCalled('Alice') // returns an actor interacting with an API
+ * This approach is useful for example when your entire test suite is dedicated to interacting with the system
+ * under test via its REST APIs, and you have a handful of scenarios that need a web browser.
  *
- * @see {@link Stage}
- * @interface
+ * ```ts
+ * import { describe, beforeEach } from 'mocha'
+ * import { engage, Cast } from '@serenity-js/core';
+ * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+ * import { Browser, chromium } from 'playwright'
+ *
+ * describe('My UI feature', () => {
+ *   beforeEach(async () => {
+ *     const browser = await chromium.launch({ headless: true })
+ *     engage(Cast.where(actor => actor.whoCan(BrowseTheWebWithPlaywright.using(browser))))
+ *   })
+ *
+ *   // test scenarios
+ * })
+ * ```
+ *
+ * ## Writing custom casts for complex scenarios
+ *
+ * In **complex scenarios** that involve multiple **actors with different abilities**,
+ * you should create a custom implementation of the {@apilink Cast}.
+ *
+ * Examples of such scenarios include those where actors use separate browser instances, interact with different REST APIs,
+ * or start with different data in their {@apilink Notepad|notepads}.
+ *
+ * ### Defining a custom cast of actors interacting with a Web UI
+ *
+ * ```ts
+ * import { beforeEach } from 'mocha'
+ * import { engage, Actor, Cast } from '@serenity-js/core'
+ * import { BrowseTheWebWithPlaywright, PlaywrightOptions } from '@serenity-js/playwright'
+ * import { Browser, chromium } from 'playwright'
+ *
+ * export class UIActors implements Cast {
+ *   constructor(
+ *     private readonly browser: Browser,
+ *     private readonly options?: PlaywrightOptions,
+ *   ) {
+ *   }
+ *
+ *   prepare(actor: Actor): Actor {
+ *     return actor.whoCan(
+ *       BrowseTheWebWithPlaywright.using(this.browser, this.options),
+ *     )
+ *   }
+ * }
+ *
+ * beforeEach(async () => {
+ *   const browser = await chromium.launch({ headless: true })
+ *   engage(new UIActors(browser));
+ * });
+ * ```
+ *
+ * ### Preparing actors differently based on their name
+ *
+ * ```ts
+ * import { beforeEach } from 'mocha'
+ * import { actorCalled, engage, Cast } from '@serenity-js/core'
+ * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+ * import { CallAnApi } from '@serenity-js/rest'
+ * import { Browser, chromium } from 'playwright'
+ *
+ * class Actors implements Cast {
+ *   constructor(
+ *     private readonly browser: Browser,
+ *     private readonly options: PlaywrightOptions,
+ *   ) {
+ *   }
+ *
+ *   prepare(actor: Actor) {
+ *     switch (actor.name) {
+ *       case 'James':
+ *         return actor.whoCan(BrowseTheWebWithPlaywright.using(this.browser, this.options));
+ *       default:
+ *         return actor.whoCan(CallAnApi.at(this.options.baseURL));
+ *     }
+ *   }
+ * }
+ *
+ * beforeEach(async () => {
+ *   const browser = await chromium.launch({ headless: true })
+ *   engage(new Actors(browser, { baseURL: 'https://example.org' }));
+ * });
+ *
+ * actorCalled('James') // returns an actor using a browser
+ * actorCalled('Alice') // returns an actor interacting with an API
+ * ```
+ *
+ * @group Stage
  */
 export declare abstract class Cast {
     /**
-     * @desc
-     *  Creates a generic `Cast` implementation, where every actor
-     *  is given all the abilities specified when the method is called.
+     * Creates a generic `Cast` implementation, where new actors receive the abilities
+     * configured by the `prepareFunction`.
      *
-     * @param {Ability[]} abilities
-     * @returns {Cast}
+     * @param prepareFunction
      */
-    static whereEveryoneCan(...abilities: Ability[]): Cast;
+    static where(prepareFunction: (actor: Actor) => Actor): Cast;
     /**
-     * @desc
-     *  Configures an {@link Actor} instantiated when {@link Stage#actor} is invoked.
+     * Configures an {@apilink Actor} instantiated when {@apilink Stage.actor} is invoked.
      *
-     * @param {Actor} actor
-     * @return {Actor}
+     * @param actor
      *
-     * @see {@link engage}
+     * #### Learn more
+     * - {@apilink engage}
      */
     abstract prepare(actor: Actor): Actor;
 }
+//# sourceMappingURL=Cast.d.ts.map

package/lib/stage/Cast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cast.d.ts","sourceRoot":"","sources":["../../src/stage/Cast.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkJG;AACH,8BAAsB,IAAI;IAEtB;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,GAAG,IAAI;IAQ5D;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;CACxC"}

package/lib/stage/Cast.js

@@ -2,80 +2,166 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cast = void 0;
 /**
- * @desc
- *  Describes the {@link Actor}s available to take part in the performance.
+ * Serenity/JS uses the concept of a _**cast of actors**_ to centralise the process of configuring the {@apilink Actor|actors} and assigning their {@apilink Ability|abilities}.
  *
- * @example <caption>Define a cast of actors interacting with a Web UI</caption>
+ * When you invoke {@apilink actorCalled} for the first time in a test scenario,
+ * Serenity/JS {@apilink Actor|instantiates a new actor}
+ * and passes it through the {@apilink Cast.prepare} method.
+ * Specifying a **custom cast** gives you an opportunity to configure the actor with the abilities
+ * they need before it's returned to the caller,
+ * or configure the actors differently **depending on their name**.
+ * It also helps you to avoid having to configure abilities individually in every test scenario.
  *
- *  import { engage, Actor, Cast } from '@serenity-js/core';
- *  import { BrowseTheWeb } from '@serenity-js/protractor';
- *  import { protractor } from 'protractor';
+ * :::tip Remember
+ * A **cast** is responsible for assigning **abilities** to **actors** in a central location.
+ * :::
  *
- *  class UIActors implements Cast {
- *      prepare(actor: Actor) {
- *          return actor.whoCan(BrowseTheWeb.using(protractor.browser));
- *      }
- *  }
+ * ## Configuring a cast of actors for the entire test suite
  *
- *  beforeEach(() => engage(new UIActors()));
+ * When working with relatively **simple scenarios** where all the actors should always receive the same set of abilities,
+ * you can {@apilink configure} Serenity/JS to use a generic {@apilink Cast.where}:
  *
- * @example <caption>Using a generic cast</caption>
+ * ```typescript
+ * import { Cast, configure } from '@serenity-js/core'
+ * import { CallAnApi } from '@serenity-js/rest'
  *
- *  import { engage, Cast } from '@serenity-js/core';
- *  import { BrowseTheWeb } from '@serenity-js/protractor';
- *  import { protractor } from 'protractor';
+ * configure({
+ *   actors: Cast.where(actor => actor.whoCan(
+ *     CallAnApi.at('http://api.example.org'),
+ *     // other abilities
+ *   ))
+ * })
+ * ```
  *
- *  beforeEach(() => engage(BrowseTheWeb.using(protractor.browser)));
+ * If you're using Serenity/JS with one of the [supported test runners](/handbook/test-runners/),
+ * you might prefer to use your test runner's native configuration mechanism
+ * instead of invoking {@apilink configure} explicitly.
  *
- * @example <caption>Preparing actors differently based on their name</caption>
+ * :::tip configure vs engage
+ * Calling {@apilink configure} resets the entire Serenity/JS configuration
+ * and should be done exactly once in your entire test suite.
+ * If you want to retain the configuration but reset the cast, use {@apilink engage} instead.
+ * :::
  *
- *  import { actorCalled, engage, Cast } from '@serenity-js/core';
- *  import { BrowseTheWeb } from '@serenity-js/protractor';
- *  import { CallAnApi } from '@serenity-js/rest';
- *  import { protractor } from 'protractor';
+ * Learn more about configuring Serenity/JS with:
+ * - [Cucumber.js](/handbook/test-runners/cucumber)
+ * - [Jasmine](/handbook/test-runners/jasmine)
+ * - [Mocha](/handbook/test-runners/mocha)
+ * - [Playwright Test](/handbook/test-runners/playwright-test)
+ * - [Protractor](/handbook/test-runners/protractor)
+ * - [WebdriverIO](/handbook/test-runners/webdriverio)
  *
- *  class Actors implements Cast {
- *      prepare(actor: Actor) {
- *          switch (actor.name) {
- *              case 'James':
- *                  return actor.whoCan(BrowseTheWeb.using(protractor.browser));
- *              default:
- *                  return actor.whoCan(CallAnApi.at(protractor.browser.baseUrl));
- *          }
- *      }
- *  }
+ * ## Engaging a cast of actors for the specific scenario
  *
- *  beforeEach(() => engage(new Actors()));
+ * If you want to retain Serenity/JS configuration, but set a different {@apilink Cast}
+ * for the given test scenario you should use {@apilink engage} instead of {@apilink configure}.
  *
- *  actorCalled('James') // returns an actor using a browser
- *  actorCalled('Alice') // returns an actor interacting with an API
+ * This approach is useful for example when your entire test suite is dedicated to interacting with the system
+ * under test via its REST APIs, and you have a handful of scenarios that need a web browser.
  *
- * @see {@link Stage}
- * @interface
+ * ```ts
+ * import { describe, beforeEach } from 'mocha'
+ * import { engage, Cast } from '@serenity-js/core';
+ * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+ * import { Browser, chromium } from 'playwright'
+ *
+ * describe('My UI feature', () => {
+ *   beforeEach(async () => {
+ *     const browser = await chromium.launch({ headless: true })
+ *     engage(Cast.where(actor => actor.whoCan(BrowseTheWebWithPlaywright.using(browser))))
+ *   })
+ *
+ *   // test scenarios
+ * })
+ * ```
+ *
+ * ## Writing custom casts for complex scenarios
+ *
+ * In **complex scenarios** that involve multiple **actors with different abilities**,
+ * you should create a custom implementation of the {@apilink Cast}.
+ *
+ * Examples of such scenarios include those where actors use separate browser instances, interact with different REST APIs,
+ * or start with different data in their {@apilink Notepad|notepads}.
+ *
+ * ### Defining a custom cast of actors interacting with a Web UI
+ *
+ * ```ts
+ * import { beforeEach } from 'mocha'
+ * import { engage, Actor, Cast } from '@serenity-js/core'
+ * import { BrowseTheWebWithPlaywright, PlaywrightOptions } from '@serenity-js/playwright'
+ * import { Browser, chromium } from 'playwright'
+ *
+ * export class UIActors implements Cast {
+ *   constructor(
+ *     private readonly browser: Browser,
+ *     private readonly options?: PlaywrightOptions,
+ *   ) {
+ *   }
+ *
+ *   prepare(actor: Actor): Actor {
+ *     return actor.whoCan(
+ *       BrowseTheWebWithPlaywright.using(this.browser, this.options),
+ *     )
+ *   }
+ * }
+ *
+ * beforeEach(async () => {
+ *   const browser = await chromium.launch({ headless: true })
+ *   engage(new UIActors(browser));
+ * });
+ * ```
+ *
+ * ### Preparing actors differently based on their name
+ *
+ * ```ts
+ * import { beforeEach } from 'mocha'
+ * import { actorCalled, engage, Cast } from '@serenity-js/core'
+ * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+ * import { CallAnApi } from '@serenity-js/rest'
+ * import { Browser, chromium } from 'playwright'
+ *
+ * class Actors implements Cast {
+ *   constructor(
+ *     private readonly browser: Browser,
+ *     private readonly options: PlaywrightOptions,
+ *   ) {
+ *   }
+ *
+ *   prepare(actor: Actor) {
+ *     switch (actor.name) {
+ *       case 'James':
+ *         return actor.whoCan(BrowseTheWebWithPlaywright.using(this.browser, this.options));
+ *       default:
+ *         return actor.whoCan(CallAnApi.at(this.options.baseURL));
+ *     }
+ *   }
+ * }
+ *
+ * beforeEach(async () => {
+ *   const browser = await chromium.launch({ headless: true })
+ *   engage(new Actors(browser, { baseURL: 'https://example.org' }));
+ * });
+ *
+ * actorCalled('James') // returns an actor using a browser
+ * actorCalled('Alice') // returns an actor interacting with an API
+ * ```
+ *
+ * @group Stage
  */
 class Cast {
     /**
-     * @desc
-     *  Creates a generic `Cast` implementation, where every actor
-     *  is given all the abilities specified when the method is called.
+     * Creates a generic `Cast` implementation, where new actors receive the abilities
+     * configured by the `prepareFunction`.
      *
-     * @param {Ability[]} abilities
-     * @returns {Cast}
+     * @param prepareFunction
      */
-    static whereEveryoneCan(...abilities) {
-        return new GenericCast(abilities);
+    static where(prepareFunction) {
+        return new class GenericCast extends Cast {
+            prepare(actor) {
+                return prepareFunction(actor);
+            }
+        };
     }
 }
 exports.Cast = Cast;
-/**
- * @package
- */
-class GenericCast {
-    constructor(abilities) {
-        this.abilities = abilities;
-    }
-    prepare(actor) {
-        return actor.whoCan(...this.abilities);
-    }
-}
 //# sourceMappingURL=Cast.js.map

package/lib/stage/Cast.js.map

@@ -1 +1 @@
-{"version":3,"file":"Cast.js","sourceRoot":"","sources":["../../src/stage/Cast.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAsB,IAAI;IACtB;;;;;;;OAOG;IACH,MAAM,CAAC,gBAAgB,CAAC,GAAG,SAAoB;QAC3C,OAAO,IAAI,WAAW,CAAC,SAAS,CAAC,CAAC;IACtC,CAAC;CAYJ;AAvBD,oBAuBC;AAED;;GAEG;AACH,MAAM,WAAW;IACb,YAA6B,SAAoB;QAApB,cAAS,GAAT,SAAS,CAAW;IACjD,CAAC;IAED,OAAO,CAAC,KAAY;QAChB,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;CACJ"}
+{"version":3,"file":"Cast.js","sourceRoot":"","sources":["../../src/stage/Cast.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkJG;AACH,MAAsB,IAAI;IAEtB;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,eAAwC;QACjD,OAAO,IAAI,MAAM,WAAY,SAAQ,IAAI;YACrC,OAAO,CAAC,KAAY;gBAChB,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC;YAClC,CAAC;SACJ,CAAA;IACL,CAAC;CAWJ;AAzBD,oBAyBC"}

package/lib/stage/Extras.d.ts

@@ -1,11 +1,9 @@
 import { Actor } from '../screenplay';
 import { Cast } from './Cast';
 /**
- * @desc
- *  Produces no-op actors with no special {@link Ability}
- *
- * @private
+ * Produces no-op actors with no special {@apilink Ability}
  */
 export declare class Extras implements Cast {
     prepare(actor: Actor): Actor;
 }
+//# sourceMappingURL=Extras.d.ts.map

package/lib/stage/Extras.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Extras.d.ts","sourceRoot":"","sources":["../../src/stage/Extras.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B;;GAEG;AACH,qBAAa,MAAO,YAAW,IAAI;IAC/B,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;CAG/B"}

package/lib/stage/Extras.js

@@ -2,10 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Extras = void 0;
 /**
- * @desc
- *  Produces no-op actors with no special {@link Ability}
- *
- * @private
+ * Produces no-op actors with no special {@apilink Ability}
  */
 class Extras {
     prepare(actor) {

package/lib/stage/Extras.js.map

@@ -1 +1 @@
-{"version":3,"file":"Extras.js","sourceRoot":"","sources":["../../src/stage/Extras.ts"],"names":[],"mappings":";;;AAGA;;;;;GAKG;AACH,MAAa,MAAM;IACf,OAAO,CAAC,KAAY;QAChB,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ;AAJD,wBAIC"}
+{"version":3,"file":"Extras.js","sourceRoot":"","sources":["../../src/stage/Extras.ts"],"names":[],"mappings":";;;AAGA;;GAEG;AACH,MAAa,MAAM;IACf,OAAO,CAAC,KAAY;QAChB,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ;AAJD,wBAIC"}

package/lib/stage/ListensToDomainEvents.d.ts

@@ -1,20 +1,23 @@
 import { DomainEvent } from '../events';
 /**
- * @desc
- *  A {@link StageCrewMember} that can listen and react to {@link DomainEvent}s
+ * A {@apilink StageCrewMember} that can listen and react to {@apilink DomainEvent|DomainEvents}
  *
- * @see {@link StageCrewMember}
- * @see {@link StageCrewMemberBuilder}
- * @see {@link Serenity#configure}
- * @see {@link SerenityConfig#crew}
+ * ## Learn more
+ *
+ * - {@apilink StageCrewMember}
+ * - {@apilink StageCrewMemberBuilder}
+ * - {@apilink configure}
+ * - {@apilink SerenityConfig.crew}
+ *
+ * @group Stage
  */
 export interface ListensToDomainEvents {
     /**
-     * @desc
-     *  Handles {@link DomainEvent} objects emitted by the {@link Stage}
-     *  that this {@link StageCrewMember} is assigned to.
+     * Handles {@apilink DomainEvent} objects emitted by the {@apilink Stage}
+     * that this {@apilink StageCrewMember} is assigned to.
      *
-     * @type {function(event: DomainEvent): void}
+     * @param event
      */
-    notifyOf: (event: DomainEvent) => void;
+    notifyOf(event: DomainEvent): void;
 }
+//# sourceMappingURL=ListensToDomainEvents.d.ts.map

package/lib/stage/ListensToDomainEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ListensToDomainEvents.d.ts","sourceRoot":"","sources":["../../src/stage/ListensToDomainEvents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IAElC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;CACtC"}