appium 2.0.0-beta.3 → 2.0.0-beta.30

package/build/lib/extension/driver-config.js

@@ -0,0 +1,190 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DriverConfig = void 0;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _constants = require("../constants");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var _extensionConfig = require("./extension-config");
+
+class DriverConfig extends _extensionConfig.ExtensionConfig {
+  knownAutomationNames;
+  static _instances = new WeakMap();
+
+  constructor(manifest, {
+    logFn,
+    extData
+  } = {}) {
+    super(_constants.DRIVER_TYPE, manifest, logFn);
+    this.knownAutomationNames = new Set();
+
+    if (extData) {
+      this.validate(extData);
+    }
+  }
+
+  static create(manifest, {
+    extData,
+    logFn
+  } = {}) {
+    const instance = new DriverConfig(manifest, {
+      logFn,
+      extData
+    });
+
+    if (DriverConfig.getInstance(manifest)) {
+      throw new Error(`Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`);
+    }
+
+    DriverConfig._instances.set(manifest, instance);
+
+    return instance;
+  }
+
+  static getInstance(manifest) {
+    return DriverConfig._instances.get(manifest);
+  }
+
+  validate(exts) {
+    this.knownAutomationNames.clear();
+    return super.validate(exts);
+  }
+
+  getConfigProblems(extData) {
+    const problems = [];
+    const {
+      platformNames,
+      automationName
+    } = extData;
+
+    if (!_lodash.default.isArray(platformNames)) {
+      problems.push({
+        err: 'Missing or incorrect supported platformNames list.',
+        val: platformNames
+      });
+    } else {
+      if (_lodash.default.isEmpty(platformNames)) {
+        problems.push({
+          err: 'Empty platformNames list.',
+          val: platformNames
+        });
+      } else {
+        for (const pName of platformNames) {
+          if (!_lodash.default.isString(pName)) {
+            problems.push({
+              err: 'Incorrectly formatted platformName.',
+              val: pName
+            });
+          }
+        }
+      }
+    }
+
+    if (!_lodash.default.isString(automationName)) {
+      problems.push({
+        err: 'Missing or incorrect automationName',
+        val: automationName
+      });
+    }
+
+    if (this.knownAutomationNames.has(automationName)) {
+      problems.push({
+        err: 'Multiple drivers claim support for the same automationName',
+        val: automationName
+      });
+    }
+
+    this.knownAutomationNames.add(automationName);
+    return problems;
+  }
+
+  extensionDesc(driverName, {
+    version,
+    automationName
+  }) {
+    return `${driverName}@${version} (automationName '${automationName}')`;
+  }
+
+  findMatchingDriver({
+    automationName,
+    platformName
+  }) {
+    if (!_lodash.default.isString(platformName)) {
+      throw new Error('You must include a platformName capability');
+    }
+
+    if (!_lodash.default.isString(automationName)) {
+      throw new Error('You must include an automationName capability');
+    }
+
+    _logger.default.info(`Attempting to find matching driver for automationName ` + `'${automationName}' and platformName '${platformName}'`);
+
+    try {
+      const {
+        driverName,
+        mainClass,
+        version
+      } = this._getDriverBySupport(automationName, platformName);
+
+      _logger.default.info(`The '${driverName}' driver was installed and matched caps.`);
+
+      _logger.default.info(`Will require it at ${this.getInstallPath(driverName)}`);
+
+      const driver = this.require(driverName);
+
+      if (!driver) {
+        throw new Error(`Driver '${driverName}' did not export a class with name '${mainClass}'. Contact the author of the driver!`);
+      }
+
+      return {
+        driver,
+        version,
+        driverName
+      };
+    } catch (err) {
+      const msg = `Could not find a driver for automationName ` + `'${automationName}' and platformName ${platformName}'. ` + `Have you installed a driver that supports those ` + `capabilities? Run 'appium driver list --installed' to see. ` + `(Lower-level error: ${err.message})`;
+      throw new Error(msg);
+    }
+  }
+
+  _getDriverBySupport(matchAutomationName, matchPlatformName) {
+    const drivers = this.installedExtensions;
+
+    for (const [driverName, driverData] of _lodash.default.toPairs(drivers)) {
+      const {
+        automationName,
+        platformNames
+      } = driverData;
+      const aNameMatches = automationName.toLowerCase() === matchAutomationName.toLowerCase();
+
+      const pNameMatches = _lodash.default.includes(platformNames.map(_lodash.default.toLower), matchPlatformName.toLowerCase());
+
+      if (aNameMatches && pNameMatches) {
+        return {
+          driverName,
+          ...driverData
+        };
+      }
+
+      if (aNameMatches) {
+        throw new Error(`Driver '${driverName}' supports automationName ` + `'${automationName}', but Appium could not find ` + `support for platformName '${matchPlatformName}'. Supported ` + `platformNames are: ` + JSON.stringify(platformNames));
+      }
+    }
+
+    throw new Error(`Could not find installed driver to support given caps`);
+  }
+
+}
+
+exports.DriverConfig = DriverConfig;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/driver-config.js"],"names":["DriverConfig","ExtensionConfig","knownAutomationNames","_instances","WeakMap","constructor","manifest","logFn","extData","DRIVER_TYPE","Set","validate","create","instance","getInstance","Error","appiumHome","set","get","exts","clear","getConfigProblems","problems","platformNames","automationName","_","isArray","push","err","val","isEmpty","pName","isString","has","add","extensionDesc","driverName","version","findMatchingDriver","platformName","log","info","mainClass","_getDriverBySupport","getInstallPath","driver","require","msg","message","matchAutomationName","matchPlatformName","drivers","installedExtensions","driverData","toPairs","aNameMatches","toLowerCase","pNameMatches","includes","map","toLower","JSON","stringify"],"mappings":"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","sourcesContent":["\nimport _ from 'lodash';\nimport { DRIVER_TYPE } from '../constants';\nimport log from '../logger';\nimport { ExtensionConfig } from './extension-config';\n\n/**\n * @extends {ExtensionConfig<DriverType>}\n */\nexport class DriverConfig extends ExtensionConfig {\n\n  /**\n   * A set of unique automation names used by drivers.\n   * @type {Set<string>}\n   */\n  knownAutomationNames;\n\n  /**\n   * A mapping of {@link Manifest} instances to {@link DriverConfig} instances.\n   *\n   * `Manifest` and `ExtensionConfig` have a one-to-many relationship; each `Manifest` should be associated with a `DriverConfig` and a `PluginConfig`; no more, no less.\n   *\n   * This variable tracks the `Manifest`-to-`DriverConfig` portion.\n   *\n   * @type {WeakMap<Manifest,DriverConfig>}\n   * @private\n   */\n   static _instances = new WeakMap();\n\n   /**\n   * Call {@link DriverConfig.create} instead.\n   * @private\n   * @param {import('./manifest').Manifest} manifest - Manifest instance\n   * @param {DriverConfigOptions} [opts]\n   */\n   constructor (manifest, {logFn, extData} = {}) {\n     super(DRIVER_TYPE, manifest, logFn);\n\n     this.knownAutomationNames = new Set();\n\n     if (extData) {\n       this.validate(extData);\n     }\n   }\n\n   /**\n    * Creates a new {@link DriverConfig} instance for a {@link Manifest} instance.\n    *\n    * @param {Manifest} manifest\n    * @param {DriverConfigOptions} [opts]\n    * @throws If `manifest` already associated with a `DriverConfig`\n    * @returns {DriverConfig}\n    */\n   static create (manifest, {extData, logFn} = {}) {\n     const instance = new DriverConfig(manifest, {logFn, extData});\n     if (DriverConfig.getInstance(manifest)) {\n       throw new Error(`Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`);\n     }\n     DriverConfig._instances.set(manifest, instance);\n     return instance;\n   }\n\n   /**\n    * Returns a DriverConfig associated with a Manifest\n    * @param {Manifest} manifest\n    * @returns {DriverConfig|undefined}\n    */\n   static getInstance (manifest) {\n     return DriverConfig._instances.get(manifest);\n   }\n\n   /**\n   * Checks extensions for problems\n   * @param {ExtRecord<DriverType>} exts\n   */\n   validate (exts) {\n     this.knownAutomationNames.clear();\n     return super.validate(exts);\n   }\n\n   /**\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {import('./extension-config').Problem[]}\n   */\n   getConfigProblems (extData) {\n     const problems = [];\n     const {platformNames, automationName} = extData;\n\n     if (!_.isArray(platformNames)) {\n       problems.push({\n         err: 'Missing or incorrect supported platformNames list.',\n         val: platformNames\n       });\n     } else {\n       if (_.isEmpty(platformNames)) {\n         problems.push({\n           err: 'Empty platformNames list.',\n           val: platformNames\n         });\n       } else {\n         for (const pName of platformNames) {\n           if (!_.isString(pName)) {\n             problems.push({err: 'Incorrectly formatted platformName.', val: pName});\n           }\n         }\n       }\n     }\n\n     if (!_.isString(automationName)) {\n       problems.push({err: 'Missing or incorrect automationName', val: automationName});\n     }\n\n     if (this.knownAutomationNames.has(automationName)) {\n       problems.push({\n         err: 'Multiple drivers claim support for the same automationName',\n         val: automationName\n       });\n     }\n\n     // should we retain the name at the end of this function, once we've checked there are no problems?\n     this.knownAutomationNames.add(automationName);\n\n     return problems;\n   }\n\n   /**\n   * @param {ExtName<DriverType>} driverName\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {string}\n   */\n   extensionDesc (driverName, {version, automationName}) {\n     return `${driverName}@${version} (automationName '${automationName}')`;\n   }\n\n   /**\n   * Given capabilities, find a matching driver within the config. Load its class and return it along with version and driver name.\n   * @param {Capabilities} caps\n   * @returns {MatchedDriver}\n   */\n   findMatchingDriver ({automationName, platformName}) {\n     if (!_.isString(platformName)) {\n       throw new Error('You must include a platformName capability');\n     }\n\n     if (!_.isString(automationName)) {\n       throw new Error('You must include an automationName capability');\n     }\n\n     log.info(`Attempting to find matching driver for automationName ` +\n             `'${automationName}' and platformName '${platformName}'`);\n\n     try {\n       const {\n         driverName,\n         mainClass,\n         version,\n       } = this._getDriverBySupport(automationName, platformName);\n       log.info(`The '${driverName}' driver was installed and matched caps.`);\n       log.info(`Will require it at ${this.getInstallPath(driverName)}`);\n       const driver = this.require(driverName);\n       if (!driver) {\n         throw new Error(`Driver '${driverName}' did not export a class with name '${mainClass}'. Contact the author of the driver!`);\n       }\n       return {driver, version, driverName};\n     } catch (err) {\n       const msg = `Could not find a driver for automationName ` +\n                  `'${automationName}' and platformName ${platformName}'. ` +\n                  `Have you installed a driver that supports those ` +\n                  `capabilities? Run 'appium driver list --installed' to see. ` +\n                  `(Lower-level error: ${err.message})`;\n       throw new Error(msg);\n     }\n   }\n\n   /**\n   * Given an automation name and platform name, find a suitable driver and return its extension data.\n   * @param {string} matchAutomationName\n   * @param {string} matchPlatformName\n   * @returns {ExtMetadata<DriverType> & import('../../types/appium-manifest').InternalMetadata & import('../../types/external-manifest').CommonMetadata}\n   */\n   _getDriverBySupport (matchAutomationName, matchPlatformName) {\n     const drivers = this.installedExtensions;\n     for (const [driverName, driverData] of _.toPairs(drivers)) {\n       const {automationName, platformNames} = driverData;\n       const aNameMatches = automationName.toLowerCase() === matchAutomationName.toLowerCase();\n       const pNameMatches = _.includes(platformNames.map(_.toLower),\n                                      matchPlatformName.toLowerCase());\n\n       if (aNameMatches && pNameMatches) {\n         return {driverName, ...driverData};\n       }\n\n       if (aNameMatches) {\n         throw new Error(`Driver '${driverName}' supports automationName ` +\n                        `'${automationName}', but Appium could not find ` +\n                        `support for platformName '${matchPlatformName}'. Supported ` +\n                        `platformNames are: ` +\n                        JSON.stringify(platformNames));\n       }\n     }\n\n     throw new Error(`Could not find installed driver to support given caps`);\n   }\n}\n\n/**\n * @typedef DriverConfigOptions\n * @property {import('./extension-config').ExtensionLogFn} [logFn] - Optional logging function\n * @property {ManifestData['drivers']} [extData] - Extension data\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtMetadata<T>} ExtMetadata\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @typedef {import('../../types').ManifestData} ManifestData\n * @typedef {import('../../types').DriverType} DriverType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtName<T>} ExtName\n */\n\n\n/**\n * Return value of {@linkcode DriverConfig.findMatchingDriver}\n * @typedef MatchedDriver\n * @property {import('../../types/extension').DriverClass} driver\n * @property {string} version\n * @property {string} driverName\n */\n\n/**\n * @typedef {import('@appium/types').Capabilities} Capabilities\n */\n"]}

package/build/lib/extension/extension-config.d.ts

@@ -0,0 +1,170 @@
+/**
+ * This class is abstract. It should not be instantiated directly.
+ *
+ * Subclasses should provide the generic parameter to implement.
+ * @template {ExtensionType} ExtType
+ */
+export class ExtensionConfig<ExtType extends import("../../types").ExtensionType> {
+    /**
+     * Intended to be called by corresponding instance methods of subclass.
+     * @private
+     * @template {ExtensionType} ExtType
+     * @param {string} appiumHome
+     * @param {ExtType} extType
+     * @param {ExtName<ExtType>} extName - Extension name (unique to its type)
+     * @param {ExtManifestWithSchema<ExtType>} extData - Extension config
+     * @returns {import('ajv').SchemaObject|undefined}
+     */
+    private static _readExtensionSchema;
+    /**
+     * Returns `true` if a specific {@link ExtManifest} object has a `schema` prop.
+     * The {@link ExtManifest} object becomes a {@link ExtManifestWithSchema} object.
+     * @template {ExtensionType} ExtType
+     * @param {ExtManifest<ExtType>} extData
+     * @returns {extData is ExtManifestWithSchema<ExtType>}
+     */
+    static extDataHasSchema<ExtType_1 extends import("../../types").ExtensionType>(extData: ExtManifest<ExtType_1>): extData is ExtManifestWithSchema<ExtType_1>;
+    /**
+     * @protected
+     * @param {ExtType} extensionType - Type of extension
+     * @param {Manifest} manifest - `Manifest` instance
+     * @param {ExtensionLogFn} [logFn]
+     */
+    protected constructor();
+    /** @type {ExtType} */
+    extensionType: ExtType;
+    /** @type {`${ExtType}s`} */
+    configKey: `${ExtType}s`;
+    /** @type {ExtRecord<ExtType>} */
+    installedExtensions: ExtRecord<ExtType>;
+    /** @type {ExtensionLogFn} */
+    log: ExtensionLogFn;
+    /** @type {Manifest} */
+    manifest: Manifest;
+    get manifestPath(): string;
+    get appiumHome(): string;
+    /**
+     * Checks extensions for problems
+     * @param {ExtRecord<ExtType>} exts - Extension data
+     */
+    validate(exts: ExtRecord<ExtType>): ExtRecord<ExtType>;
+    /**
+     * @param {ExtManifest<ExtType>} extData
+     * @param {ExtName<ExtType>} extName
+     * @returns {Problem[]}
+     */
+    getSchemaProblems(extData: ExtManifest<ExtType>, extName: ExtName<ExtType>): Problem[];
+    /**
+     * @param {ExtManifest<ExtType>} extData
+     * @param {ExtName<ExtType>} extName
+     * @returns {Problem[]}
+     */
+    getGenericConfigProblems(extData: ExtManifest<ExtType>, extName: ExtName<ExtType>): Problem[];
+    /**
+     * @abstract
+     * @param {ExtManifest<ExtType>} extData
+     * @returns {Problem[]}
+     */
+    getConfigProblems(extData: ExtManifest<ExtType>): Problem[];
+    /**
+     * @param {string} extName
+     * @param {ExtManifest<ExtType>} extData
+     * @param {ExtensionConfigMutationOpts} [opts]
+     * @returns {Promise<void>}
+     */
+    addExtension(extName: string, extData: ExtManifest<ExtType>, { write }?: ExtensionConfigMutationOpts | undefined): Promise<void>;
+    /**
+     * @param {ExtName<ExtType>} extName
+     * @param {ExtManifest<ExtType>|import('../cli/extension-command').ExtensionFields<ExtType>} extData
+     * @param {ExtensionConfigMutationOpts} [opts]
+     * @returns {Promise<void>}
+     */
+    updateExtension(extName: ExtName<ExtType>, extData: ExtManifest<ExtType> | import('../cli/extension-command').ExtensionFields<ExtType>, { write }?: ExtensionConfigMutationOpts | undefined): Promise<void>;
+    /**
+     * @param {ExtName<ExtType>} extName
+     * @param {ExtensionConfigMutationOpts} [opts]
+     * @returns {Promise<void>}
+     */
+    removeExtension(extName: ExtName<ExtType>, { write }?: ExtensionConfigMutationOpts | undefined): Promise<void>;
+    /**
+     * @param {ExtName<ExtType>[]} [activeNames]
+     * @returns {void}
+     */
+    print(activeNames?: string[] | undefined): void;
+    /**
+     * Returns a string describing the extension. Subclasses must implement.
+     * @param {ExtName<ExtType>} extName - Extension name
+     * @param {ExtManifest<ExtType>} extData - Extension data
+     * @returns {string}
+     * @abstract
+     */
+    extensionDesc(extName: ExtName<ExtType>, extData: ExtManifest<ExtType>): string;
+    /**
+     * @param {string} extName
+     * @returns {string}
+     */
+    getInstallPath(extName: string): string;
+    /**
+     * Loads extension and returns its main class (constructor)
+     * @param {ExtName<ExtType>} extName
+     * @returns {ExtClass<ExtType>}
+     */
+    require(extName: ExtName<ExtType>): ExtClass<ExtType>;
+    /**
+     * @param {string} extName
+     * @returns {boolean}
+     */
+    isInstalled(extName: string): boolean;
+    /**
+     * If an extension provides a schema, this will load the schema and attempt to
+     * register it with the schema registrar.
+     * @param {ExtName<ExtType>} extName - Name of extension
+     * @param {ExtManifestWithSchema<ExtType>} extData - Extension data
+     * @returns {import('ajv').SchemaObject|undefined}
+     */
+    readExtensionSchema(extName: ExtName<ExtType>, extData: ExtManifestWithSchema<ExtType>): import('ajv').SchemaObject | undefined;
+}
+/**
+ * Config problem
+ */
+export type Problem = {
+    /**
+     * - Error message
+     */
+    err: string;
+    /**
+     * - Associated value
+     */
+    val: any;
+};
+/**
+ * An optional logging function provided to an {@link ExtensionConfig } subclass.
+ */
+export type ExtensionLogFn = (...args: any[]) => void;
+export type ExtensionType = import('../../types').ExtensionType;
+export type Manifest = import('./manifest').Manifest;
+export type ExtManifest<T> = import('../../types/appium-manifest').ExtManifest<T>;
+export type ExtManifestWithSchema<T> = import('../../types/appium-manifest').ExtManifestWithSchema<T>;
+export type ExtName<T> = import('../../types/appium-manifest').ExtName<T>;
+export type ExtClass<T> = import('../../types/extension').ExtClass<T>;
+export type ExtRecord<T> = import('../../types/appium-manifest').ExtRecord<T>;
+/**
+ * Options for various methods in {@link ExtensionConfig }
+ */
+export type ExtensionConfigMutationOpts = {
+    /**
+     * Whether or not to write the manifest to disk after a mutation operation
+     */
+    write?: boolean | undefined;
+};
+/**
+ * A valid install type
+ */
+export type InstallType = typeof INSTALL_TYPE_NPM | typeof INSTALL_TYPE_GIT | typeof INSTALL_TYPE_LOCAL | typeof INSTALL_TYPE_GITHUB;
+export const INSTALL_TYPE_NPM: "npm";
+export const INSTALL_TYPE_GIT: "git";
+export const INSTALL_TYPE_LOCAL: "local";
+export const INSTALL_TYPE_GITHUB: "github";
+/** @type {Set<InstallType>} */
+export const INSTALL_TYPES: Set<InstallType>;
+//# sourceMappingURL=extension-config.d.ts.map

package/build/lib/extension/extension-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-config.d.ts","sourceRoot":"","sources":["../../../lib/extension/extension-config.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH;IAkTE;;;;;;;;;OASG;IACH,oCAoBC;IAED;;;;;;OAMG;IACH,6JAEC;IA3UD;;;;;OAKG;IACH,wBAOC;IA5BD,sBAAsB;IACtB,eADW,OAAO,CACJ;IAEd,4BAA4B;IAC5B,WADW,GAAG,OAAO,GAAG,CACd;IAEV,iCAAiC;IACjC,qBADW,UAAU,OAAO,CAAC,CACT;IAEpB,6BAA6B;IAC7B,KADW,cAAc,CACrB;IAEJ,uBAAuB;IACvB,UADW,QAAQ,CACV;IAiBT,2BAEC;IAED,yBAEC;IAED;;;OAGG;IACH,eAFW,UAAU,OAAO,CAAC,sBAgD5B;IAED;;;;OAIG;IACH,2BAJW,YAAY,OAAO,CAAC,WACpB,QAAQ,OAAO,CAAC,GACd,OAAO,EAAE,CAyCrB;IAED;;;;OAIG;IAEH,kCALW,YAAY,OAAO,CAAC,WACpB,QAAQ,OAAO,CAAC,GACd,OAAO,EAAE,CAyCrB;IAED;;;;OAIG;IAEH,2BAJW,YAAY,OAAO,CAAC,GAClB,OAAO,EAAE,CAMrB;IAED;;;;;OAKG;IACH,sBALW,MAAM,WACN,YAAY,OAAO,CAAC,wDAElB,QAAQ,IAAI,CAAC,CAOzB;IAED;;;;;OAKG;IACH,yBALW,QAAQ,OAAO,CAAC,WAChB,YAAY,OAAO,CAAC,GAAC,OAAO,0BAA0B,EAAE,eAAe,CAAC,OAAO,CAAC,wDAE9E,QAAQ,IAAI,CAAC,CAUzB;IAED;;;;OAIG;IACH,yBAJW,QAAQ,OAAO,CAAC,wDAEd,QAAQ,IAAI,CAAC,CAOzB;IAED;;;OAGG;IAEH,2CAHa,IAAI,CAqBhB;IAED;;;;;;OAMG;IAEH,uBANW,QAAQ,OAAO,CAAC,WAChB,YAAY,OAAO,CAAC,GAClB,MAAM,CAMlB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAHW,QAAQ,OAAO,CAAC,GACd,SAAS,OAAO,CAAC,CAa7B;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IA6CD;;;;;;OAMG;IACH,6BAJW,QAAQ,OAAO,CAAC,WAChB,sBAAsB,OAAO,CAAC,GAC5B,OAAO,KAAK,EAAE,YAAY,GAAC,SAAS,CAShD;CACF;;;;;;;;SAaa,MAAM;;;;SACN,GAAG;;;;;uCAMH,GAAG,OACJ,IAAI;4BAIJ,OAAO,aAAa,EAAE,aAAa;uBACnC,OAAO,YAAY,EAAE,QAAQ;6BAK7B,OAAO,6BAA6B,EAAE,WAAW,CAAC,CAAC,CAAC;uCAKpD,OAAO,6BAA6B,EAAE,qBAAqB,CAAC,CAAC,CAAC;yBAK9D,OAAO,6BAA6B,EAAE,OAAO,CAAC,CAAC,CAAC;0BAKhD,OAAO,uBAAuB,EAAE,QAAQ,CAAC,CAAC,CAAC;2BAK3C,OAAO,6BAA6B,EAAE,SAAS,CAAC,CAAC,CAAC;;;;;;;;;;;;;0BAWlD,uBAAuB,GAAG,uBAAuB,GAAG,yBAAyB,GAAG,0BAA0B;AA7bvH,qCAA+B;AAG/B,qCAA+B;AAF/B,yCAAmC;AACnC,2CAAqC;AAGrC,+BAA+B;AAC/B,4BADW,IAAI,WAAW,CAAC,CAMxB"}