@microsoft/sp-component-base 1.22.0-beta.2 → 1.22.0-beta.4

package/lib/IComponentPropertyMetadata.d.ts

@@ -0,0 +1,100 @@
+/**
+ * This is the structure used for map values for component properties metadata.
+ *
+ * @public
+ */
+export interface IComponentPropertyMetadata {
+    /**
+     * Indicates whether the property should be serialized as HTML.
+     *
+     * @remarks
+     * This flag instructs framework to store the value as HTML, so that SharePoint can perform the following
+     * services on it:
+     *
+     * - normalizing HTML encodings
+     *
+     * - stripping unsafe HTML tags (i.e. for usage with Element.innerHTML)
+     *
+     * - search indexing
+     *
+     * - SharePoint link fix-up
+     *
+     * Only enable this flag for HTML content where these modifications are acceptable. If non-HTML content is
+     * provided, SharePoint framework might make modifications to convert it to HTML valid. For plain text content
+     * that simply needs to be exposed to the search index (without any rewriting), use the `isSearchablePlainText`
+     * flag instead.
+     */
+    isHtmlString?: boolean;
+    /**
+     * Indicates if the property contains plain text that should be search-indexed by SharePoint.
+     *
+     * @remarks
+     * This flag instructs the framework to store the property in a representation that supports search indexing.
+     * The content will be treated as plain text; SharePoint will not modify the string in any way, and
+     * special HTML characters may be stored encoded and appear in search results. If your string contains
+     * HTML markup, use the isHtmlString setting instead.
+     *
+     * Security note: For security reasons, never assign a plain text string to `Element.innerHTML`.
+     */
+    isSearchablePlainText?: boolean;
+    /**
+     * Indicates if the property contains a link. This allows SharePoint server to treat the value as such and
+     * perform services like search indexing, link fix-up, loading from CDN, etc.
+     */
+    isLink?: boolean;
+    /**
+     * Indicates if the property contains a link. This allows SharePoint server to treat the value as such and
+     * perform services like link fix-up, search indexing, loading from CDN, etc.
+     */
+    isImageSource?: boolean;
+    /**
+     * Indicates that property value is components id, required to be loaded before this component can render or initialize.
+     *
+     * @remarks
+     * The component should use this property to declare dynamic runtime component dependencies, which are required only
+     * for specific states of the property. The framework will ensure that this component is preloaded for the component.
+     *
+     * For example, the user can select one of the multiple layouts available for a web part or component during edit mode.
+     * This will optimize the bundle to avoid embedding code for all layout code; instead, the framework will load the
+     * required layout selectively at runtime.
+     *
+     * @alpha
+     */
+    isComponentDependency?: boolean;
+    /**
+     * Indicates if the framework should persist the property on the server.
+     *
+     * @remarks
+     * Use this for properties that are only important in run-time, and do not need to persist on the server.
+     * This can reduce the size of the serialized data of the component and optimize the component load time.
+     * The property value will be removed from the serialized data sent to the server, but this has no effect on
+     * the run-time property bag. The property value will still be available in the `onBeforeSerialize()` method,
+     * and the value will not be cleared from the run-time property bag. The initial render of your component should
+     * not depend on the value of the property. Setting a default value for the property can be done in `onInit()` method.
+     *
+     * Note that if the property path refers to a property that has a complex object as the value, the whole object
+     * will be removed from the persisted data.
+     */
+    shouldNotPersist?: boolean;
+    /**
+     * Additional custom metadata associated with the original metadata.
+     *
+     * @remarks
+     * This can be used to supply additional related metadata information.
+     * For example, image metadata along with a URL could be provided.
+     *
+     * @privateRemarks
+     * We should find a way to associate type to this object before this API becomes available to 3rd
+     * parties. (SPPPLAT VSO bug#504028) tracks that fix. For now, we are not doing that because that will require a
+     * bigger public API change to exiting APIs. We do not want to change existing public APIs before we make this
+     * feature available to third parties.
+     * key is Name of the custom property name and value is path of the property.
+     * e.g. 'width': 'managerPhotoWidth'
+     *
+     * @alpha
+     */
+    customMetadata?: {
+        [key: string]: string;
+    };
+}
+//# sourceMappingURL=IComponentPropertyMetadata.d.ts.map

package/lib/IComponentPropertyMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IComponentPropertyMetadata.d.ts","sourceRoot":"","sources":["../src/IComponentPropertyMetadata.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;;;;;;OAUG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;;;;;;;;;OAYG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;;;;;;;;;;;;OAgBG;IACH,cAAc,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CAC5C"}

package/lib/IComponentPropertyMetadata.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IComponentPropertyMetadata.js.map

package/lib/ISerializedServerProcessedData.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Server processed data type.
+ *
+ * @internal
+ */
+export declare const ServerProcessedDataType: {
+    /**
+     * The date type is valid html string.
+     */
+    readonly htmlString: 1;
+    /**
+     * The date type is a link to a resource.
+     * The link can be a SharePoint content link or non-SharePoint link.
+     */
+    readonly link: 2;
+    /**
+     * The date type is a link to a image.
+     * The link can be a SharePoint content link or non-SharePoint link.
+     */
+    readonly imageSource: 3;
+    /**
+     * The data type is a string that should be search indexed.
+     */
+    readonly searchablePlainText: 4;
+};
+/**
+ * {@inheritdoc (ServerProcessedDataType:variable)}
+ * @internal
+ */
+export type ServerProcessedDataType = typeof ServerProcessedDataType[keyof typeof ServerProcessedDataType];
+/**
+ * Contains collections of data that can be processed by server side services like search index and link fixup
+ *
+ * @public
+ */
+export interface ISerializedServerProcessedData {
+    /**
+     * A key-value map where keys are string identifiers and values are rich text with HTML format.
+     *
+     * @remarks
+     * SharePoint servers treat the values as HTML content and run services like safety checks, search index
+     * and link fixup on them.
+     *
+     * Example:
+     * ```
+     * {
+     *   'myRichDescription': '<div>Some standard <b>HTML content</b><a href='http://somelink'>A Link</a></div>'
+     *   'anotherRichText': <div class='aClass'><span style='color:red'>Some red text</div>
+     * }
+     * ```
+     *
+     */
+    htmlStrings?: {
+        [key: string]: string;
+    };
+    /**
+     * A key-value map where keys are string identifiers and values are strings that should be search indexed.
+     *
+     * @remarks
+     * The values are HTML-encoded before being sent to the server. The encoded values are visible to the search
+     * indexer, but are not treated as valid HTML. So, other services such as link fixup will not run on them.
+     *
+     * Example:
+     * ```
+     * {
+     *  'justSomeText': 'This is some plain text',
+     *  'anotherText': 'Can have <any> characters here: "<>&\''
+     * }
+     * ```
+     */
+    searchablePlainTexts?: {
+        [key: string]: string;
+    };
+    /**
+     * A key-value map where keys are string identifiers and values are links.
+     *
+     * @remarks
+     * SharePoint servers treat the values as links and run services like link fixup on them.
+     *
+     * Example:
+     * ```
+     * {
+     *   'myWebURL': 'http://contoso.com'
+     *   'myFileLink': 'https://res.contoso.com/file.docx'
+     * }
+     * ```
+     */
+    links?: {
+        [key: string]: string;
+    };
+    /**
+     * A key-value map where keys are string identifiers and values are image sources.
+     *
+     * @remarks
+     * SharePoint servers treat the values as image sources and run services like search index and link fixup on them.
+     *
+     * Example:
+     * ```
+     * {
+     *   'myImage1': 'http://res.contoso.com/path/to/file'
+     *   'myImage2': 'https://res.contoso.com/someName.jpg'
+     * }
+     * ```
+     */
+    imageSources?: {
+        [key: string]: string;
+    };
+    /**
+     * A key-value map where keys are string identifiers and values are component ids.
+     *
+     * @remarks
+     * SharePoint servers might decide to use this hint to preload the script for corresponding components for
+     * performance boost.
+     *
+     * Example:
+     * ```
+     * {
+     *   'layoutComponent': 'abfccb4d-fcbc-4720-8bcc-6183ce66c391',
+     *   'dataComponent': 'f0baf432-de3f-4f0f-8444-d1280b2f8cc5'
+     * }
+     * ```
+     * @alpha
+     */
+    componentDependencies?: {
+        [key: string]: string;
+    };
+    /**
+     * A key-value map where keys are string identifier and values are object of custom key-value pair
+     *
+     * @remarks
+     *
+     * SharePoint servers might treat custom medata values in context of the other properties like imageSources.
+     * E.g. When the key of imageSources and customMetadata is same, custom metadata can be used to expand information
+     * of image data.
+     *
+     * Example:
+     * ```
+     * ISerializedServerProcessedData {
+     *   imageSources: {
+     *    'myImage1': 'http://res.contoso.com/path/to/file',
+     *    'myImage2': 'https://res.contoso.com/someName.jpg'
+     *   },
+     *
+     *   customMetadata: {
+     *     'myImage1': {'height': '100', 'width': '100'}
+     *     'myImage2': {'height': '400', 'width': '600'}
+     *   }
+     * }
+     * ```
+     *
+     * @privateRemarks
+     *
+     * We should find a way to associate type to this object before this API becomes available to 3rd
+     * parties. (SPPPLAT VSO bug#504028) tracks that fix. For now, we are not doing that because that will require a
+     * bigger public API change to exiting APIs. We do not want to change existing public APIs before we make this
+     * feature available to third parties.
+     *
+     * @alpha
+     */
+    customMetadata?: {
+        [key: string]: {
+            [key: string]: {};
+        };
+    };
+}
+//# sourceMappingURL=ISerializedServerProcessedData.d.ts.map

package/lib/ISerializedServerProcessedData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ISerializedServerProcessedData.d.ts","sourceRoot":"","sources":["../src/ISerializedServerProcessedData.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH,eAAO,MAAM,uBAAuB;IAClC;;OAEG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;OAEG;;CAEK,CAAC;AACX;;;GAGG;AAEH,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,MAAM,OAAO,uBAAuB,CAAC,CAAC;AAE3G;;;;GAIG;AACH,MAAM,WAAW,8BAA8B;IAC7C;;;;;;;;;;;;;;;OAeG;IACH,WAAW,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAExC;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAEjD;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAElC;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAEzC;;;;;;;;;;;;;;;OAeG;IACH,qBAAqB,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,cAAc,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,EAAE,CAAA;SAAE,CAAA;KAAE,CAAC;CAC3D"}

package/lib/ISerializedServerProcessedData.js

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft. All rights reserved.
+/**
+ * Server processed data type.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/typedef
+export var ServerProcessedDataType = {
+    /**
+     * The date type is valid html string.
+     */
+    htmlString: 1,
+    /**
+     * The date type is a link to a resource.
+     * The link can be a SharePoint content link or non-SharePoint link.
+     */
+    link: 2,
+    /**
+     * The date type is a link to a image.
+     * The link can be a SharePoint content link or non-SharePoint link.
+     */
+    imageSource: 3,
+    /**
+     * The data type is a string that should be search indexed.
+     */
+    searchablePlainText: 4
+};
+//# sourceMappingURL=ISerializedServerProcessedData.js.map

package/lib/LegacyThirdPartyFabricCoreLoader.d.ts

@@ -0,0 +1,40 @@
+import type { IClientSideComponentManifest } from '@microsoft/sp-module-interfaces';
+/**
+ * Class to load async chunks.
+ *
+ * @internal
+ */
+export default class LegacyThirdPartyFabricCoreLoader {
+    /**
+     * Indicates whether the fabric-core styles are loaded on the page or not.
+     */
+    private static _isLoaded;
+    /**
+     * Method to dynamically load the legacy third-party fabric core styles.
+     * This method should be called only when a third-party component(web part or extension)
+     * is being loaded on to the page.
+     *
+     * NOTE: Remove this method when the below killswitch is graduated from \@microsoft/sp-webpart-base.
+     * 'isStopLoadingLegacyFabricCSSKillSwitchActivated' - '57b771ed-2b57-41c2-aaaa-0e21c587c6dc'
+     *
+     * @param isComponentInternal - indicates whether the requesting component is internal to Microsoft or not.
+     */
+    static load(isComponentInternal: boolean | undefined): Promise<void>;
+    /**
+     * Method to dynamically force load the legacy third-party fabric core styles.
+     * All the below conditions are checked and needs to be true to force load the legacy css:
+     *   1. Should be third party component (web part or extension)
+     *   2. Should not be already loaded
+     *   3. Component should ask to load the legacy css or if the component is built version \< 1.8
+     *
+     * @param manifest - component's manifest
+     */
+    static forceLoad(manifest: IClientSideComponentManifest): Promise<void>;
+    /**
+     * Method to check if the web part need to load the legacy css.
+     * @param manifest - component's manifest
+     */
+    static needLegacyFabricCss(manifest: IClientSideComponentManifest): boolean;
+    private static _shouldLoad;
+}
+//# sourceMappingURL=LegacyThirdPartyFabricCoreLoader.d.ts.map

package/lib/LegacyThirdPartyFabricCoreLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegacyThirdPartyFabricCoreLoader.d.ts","sourceRoot":"","sources":["../src/LegacyThirdPartyFabricCoreLoader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iCAAiC,CAAC;AAIpF;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,gCAAgC;IACnD;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS,CAAkB;IAE1C;;;;;;;;;OASG;WACW,IAAI,CAAC,mBAAmB,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAa3E;;;;;;;;OAQG;WACW,SAAS,CAAC,QAAQ,EAAE,4BAA4B,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB9E;;;OAGG;WACW,mBAAmB,CAAC,QAAQ,EAAE,4BAA4B,GAAG,OAAO;IAmBlF,OAAO,CAAC,MAAM,CAAC,WAAW;CAM3B"}

package/lib/LegacyThirdPartyFabricCoreLoader.js

@@ -0,0 +1,90 @@
+import { Version } from '@microsoft/sp-core-library';
+// Copyright (c) Microsoft. All rights reserved.
+/**
+ * Class to load async chunks.
+ *
+ * @internal
+ */
+var LegacyThirdPartyFabricCoreLoader = /** @class */ (function () {
+    function LegacyThirdPartyFabricCoreLoader() {
+    }
+    /**
+     * Method to dynamically load the legacy third-party fabric core styles.
+     * This method should be called only when a third-party component(web part or extension)
+     * is being loaded on to the page.
+     *
+     * NOTE: Remove this method when the below killswitch is graduated from \@microsoft/sp-webpart-base.
+     * 'isStopLoadingLegacyFabricCSSKillSwitchActivated' - '57b771ed-2b57-41c2-aaaa-0e21c587c6dc'
+     *
+     * @param isComponentInternal - indicates whether the requesting component is internal to Microsoft or not.
+     */
+    LegacyThirdPartyFabricCoreLoader.load = function (isComponentInternal) {
+        if (!isComponentInternal && !LegacyThirdPartyFabricCoreLoader._isLoaded) {
+            return import(
+            /* webpackChunkName: 'legacy-third-party-fabric-core-localfont' */ './chunks/legacy-third-party-fabric-core/FabricLocalFont').then(function () {
+                LegacyThirdPartyFabricCoreLoader._isLoaded = true;
+                return;
+            });
+        }
+        else {
+            return Promise.resolve();
+        }
+    };
+    /**
+     * Method to dynamically force load the legacy third-party fabric core styles.
+     * All the below conditions are checked and needs to be true to force load the legacy css:
+     *   1. Should be third party component (web part or extension)
+     *   2. Should not be already loaded
+     *   3. Component should ask to load the legacy css or if the component is built version \< 1.8
+     *
+     * @param manifest - component's manifest
+     */
+    LegacyThirdPartyFabricCoreLoader.forceLoad = function (manifest) {
+        try {
+            if (LegacyThirdPartyFabricCoreLoader._shouldLoad(manifest)) {
+                return import(
+                /* webpackChunkName: 'legacy-third-party-fabric-core-localfont' */ './chunks/legacy-third-party-fabric-core/FabricLocalFont').then(function () {
+                    LegacyThirdPartyFabricCoreLoader._isLoaded = true;
+                    return;
+                });
+            }
+            else {
+                return Promise.resolve();
+            }
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    };
+    /**
+     * Method to check if the web part need to load the legacy css.
+     * @param manifest - component's manifest
+     */
+    LegacyThirdPartyFabricCoreLoader.needLegacyFabricCss = function (manifest) {
+        if (manifest.isInternal) {
+            return false;
+        }
+        /*
+         * If loadLegacyFabricCss is not specified by the component, then load the css
+         * if the component is built before SPFx 1.8.2 or in some cases when we cannot get
+         * the version of the SPFx.
+         */
+        if (manifest.loadLegacyFabricCss === undefined) {
+            var version = Version._tryParseSPFxVersion(manifest);
+            return !version || version.lessThan(Version.parse('1.8.2'));
+        }
+        // Respect 'loadLegacyFabricCss' if a real value is provided.
+        return manifest.loadLegacyFabricCss;
+    };
+    LegacyThirdPartyFabricCoreLoader._shouldLoad = function (manifest) {
+        return (!LegacyThirdPartyFabricCoreLoader._isLoaded &&
+            LegacyThirdPartyFabricCoreLoader.needLegacyFabricCss(manifest));
+    };
+    /**
+     * Indicates whether the fabric-core styles are loaded on the page or not.
+     */
+    LegacyThirdPartyFabricCoreLoader._isLoaded = false;
+    return LegacyThirdPartyFabricCoreLoader;
+}());
+export default LegacyThirdPartyFabricCoreLoader;
+//# sourceMappingURL=LegacyThirdPartyFabricCoreLoader.js.map

package/lib/PropertyMetadataProcessor.d.ts

@@ -0,0 +1,54 @@
+import type { IClientSideComponentManifest } from '@microsoft/sp-module-interfaces';
+import type { IComponentPropertyMetadata } from './IComponentPropertyMetadata';
+import type { ISerializedServerProcessedData } from './ISerializedServerProcessedData';
+/**
+ * The processor to serialize and deserialize the server processed content and component properties
+ * based on component metadata.
+ *
+ * @internal
+ */
+export declare class PropertyMetadataProcessor {
+    /**
+     * Serialize the properties into server processed content as declared in metadata.
+     *
+     * @param propertiesMetadata - The component properties metadata.
+     * @param properties - The component properties. This object will be modified during serialization.
+     * @param serverProcessedContent - The serialized server processed content. This object will be modified.
+     */
+    static serializeServerProcessedData<TProperties extends {}>(propertiesMetadata: undefined | {
+        [key: string]: IComponentPropertyMetadata;
+    }, properties: TProperties, serverProcessedContent: ISerializedServerProcessedData): void;
+    /**
+     * Reapply the serialized server processed content on the properties based on the metadata.
+     * This process will result in the properties bag as it was when the serialization happened.
+     *
+     * @param propertiesMetadata - The component properties metadata.
+     * @param properties - The component properties. This object will be modified during serialization.
+     * @param serverProcessedContent - The serialized server processed content.
+     * @param manifest - The optional component manifest.
+     */
+    static reInstateServerProcessedData<TProperties extends {}>(propertiesMetadata: undefined | {
+        [key: string]: IComponentPropertyMetadata;
+    }, properties: TProperties, serverProcessedContent: undefined | ISerializedServerProcessedData, manifest?: IClientSideComponentManifest): void;
+    private static _isSafeLink;
+    private static _getSafeHtml;
+    /**
+     * Iterates and validates each metadata property before calling metadata processor.
+     *
+     * @param propertiesMetadata - Component properties metadata.
+     * @param properties - Component properties.
+     * @param metadataProcessor - Callback handler to to process validated metadata.
+     *
+     * @internal
+     */
+    private static _forEachPropertyWithMetaData;
+    /**
+     * Validates path and iterate over one or multiple wildcard paths
+     *
+     * @param propPath - Original property path provided in metadata
+     * @param properties - Properties to look for the given path.
+     * @param propertyPathHandler - Handler to process validated and fixed path
+     */
+    private static _validateAndIteratePath;
+}
+//# sourceMappingURL=PropertyMetadataProcessor.d.ts.map

package/lib/PropertyMetadataProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PropertyMetadataProcessor.d.ts","sourceRoot":"","sources":["../src/PropertyMetadataProcessor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iCAAiC,CAAC;AAEpF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC/E,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAKvF;;;;;GAKG;AACH,qBAAa,yBAAyB;IACpC;;;;;;OAMG;WACW,4BAA4B,CAAC,WAAW,SAAS,EAAE,EAC/D,kBAAkB,EAAE,SAAS,GAAG;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,0BAA0B,CAAA;KAAE,EAC7E,UAAU,EAAE,WAAW,EACvB,sBAAsB,EAAE,8BAA8B,GACrD,IAAI;IAoFP;;;;;;;;OAQG;WACW,4BAA4B,CAAC,WAAW,SAAS,EAAE,EAC/D,kBAAkB,EAAE,SAAS,GAAG;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,0BAA0B,CAAA;KAAE,EAC7E,UAAU,EAAE,WAAW,EACvB,sBAAsB,EAAE,SAAS,GAAG,8BAA8B,EAClE,QAAQ,CAAC,EAAE,4BAA4B,GACtC,IAAI;IAsHP,OAAO,CAAC,MAAM,CAAC,WAAW;IAc1B,OAAO,CAAC,MAAM,CAAC,YAAY;IAI3B;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAkB3C;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;CAyCvC"}