appium-mac2-driver 4.4.0 → 4.5.1

package/node_modules/async-lock/README.md

@@ -1,177 +0,0 @@
-# async-lock
-
-Lock on asynchronous code
-
-[![Build Status](https://travis-ci.org/rogierschouten/async-lock.svg?branch=master)](https://travis-ci.org/rogierschouten/async-lock)
-
-* ES6 promise supported
-* Multiple keys lock supported
-* Timeout supported
-* Occupation time limit supported
-* Execution time limit supported
-* Pending task limit supported
-* Domain reentrant supported
-* 100% code coverage
-
-## Disclaimer
-
-I did not create this package, and I will not add any features to it myself. I was granted the ownership because it was no longer being
-maintained, and I volunteered to fix a bug.
-
-If you have a new feature you would like to have incorporated, please send me a PR and I will be happy to work with you and get it merged.
-For any bugs, PRs are most welcome but when possible I will try to get them resolved as soon as possible.
-
-## Why do you need locking on single threaded nodejs?
-
-Nodejs is single threaded, and the code execution never gets interrupted inside an event loop, so locking is unnecessary? This is true ONLY IF your critical section can be executed inside a single event loop.
-However, if you have any async code inside your critical section (it can be simply triggered by any I/O operation, or timer), your critical logic will across multiple event loops, therefore it's not concurrency safe!
-
-Consider the following code
-```js
-redis.get('key', function(err, value) {
-	redis.set('key', value * 2);
-});
-```
-The above code simply multiply a redis key by 2.
-However, if two users run concurrently, the execution order may like this
-```
-user1: redis.get('key') -> 1
-user2: redis.get('key') -> 1
-user1: redis.set('key', 1 x 2) -> 2
-user2: redis.set('key', 1 x 2) -> 2
-```
-Obviously it's not what you expected
-
-
-With asyncLock, you can easily write your async critical section
-```js
-lock.acquire('key', function(cb) {
-	// Concurrency safe
-	redis.get('key', function(err, value) {
-		redis.set('key', value * 2, cb);
-	});
-}, function(err, ret) {
-});
-```
-
-## Get Started
-
-```js
-var AsyncLock = require('async-lock');
-var lock = new AsyncLock();
-
-/**
- * @param {String|Array} key 	resource key or keys to lock
- * @param {function} fn 	execute function
- * @param {function} cb 	(optional) callback function, otherwise will return a promise
- * @param {Object} opts 	(optional) options
- */
-lock.acquire(key, function(done) {
-	// async work
-	done(err, ret);
-}, function(err, ret) {
-	// lock released
-}, opts);
-
-// Promise mode
-lock.acquire(key, function() {
-	// return value or promise
-}, opts).then(function() {
-	// lock released
-});
-```
-
-## Error Handling
-
-```js
-// Callback mode
-lock.acquire(key, function(done) {
-	done(new Error('error'));
-}, function(err, ret) {
-	console.log(err.message) // output: error
-});
-
-// Promise mode
-lock.acquire(key, function() {
-	throw new Error('error');
-}).catch(function(err) {
-	console.log(err.message) // output: error
-});
-```
-
-## Acquire multiple keys
-
-```js
-lock.acquire([key1, key2], fn, cb);
-```
-
-## Domain reentrant lock
-
-Lock is reentrant in the same domain
-
-```js
-var domain = require('domain');
-var lock = new AsyncLock({domainReentrant : true});
-
-var d = domain.create();
-d.run(function() {
-	lock.acquire('key', function() {
-		//Enter lock
-		return lock.acquire('key', function() {
-			//Enter same lock twice
-		});
-	});
-});
-```
-
-## Options
-
-```js
-// Specify timeout - max amount of time an item can remain in the queue before acquiring the lock
-var lock = new AsyncLock({timeout: 5000});
-lock.acquire(key, fn, function(err, ret) {
-	// timed out error will be returned here if lock not acquired in given time
-});
-
-// Specify max occupation time - max amount of time allowed between entering the queue and completing execution
-var lock = new AsyncLock({maxOccupationTime: 3000});
-lock.acquire(key, fn, function(err, ret) {
-	// occupation time exceeded error will be returned here if job not completed in given time
-});
-
-// Specify max execution time - max amount of time allowed between acquiring the lock and completing execution
-var lock = new AsyncLock({maxExecutionTime: 3000});
-lock.acquire(key, fn, function(err, ret) {
-	// execution time exceeded error will be returned here if job not completed in given time
-});
-
-// Set max pending tasks - max number of tasks allowed in the queue at a time
-var lock = new AsyncLock({maxPending: 1000});
-lock.acquire(key, fn, function(err, ret) {
-	// Handle too much pending error
-})
-
-// Whether there is any running or pending async function
-lock.isBusy();
-
-// Use your own promise library instead of the global Promise variable
-var lock = new AsyncLock({Promise: require('bluebird')}); // Bluebird
-var lock = new AsyncLock({Promise: require('q')}); // Q
-
-// Add a task to the front of the queue waiting for a given lock
-lock.acquire(key, fn1, cb); // runs immediately
-lock.acquire(key, fn2, cb); // added to queue
-lock.acquire(key, priorityFn, cb, {skipQueue: true}); // jumps queue and runs before fn2
-```
-
-## Changelog
-
-See [Changelog](./History.md)
-
-## Issues
-
-See [issue tracker](https://github.com/rogierschouten/async-lock/issues).
-
-## License
-
-MIT, see [LICENSE](./LICENSE)

package/node_modules/async-lock/index.js

@@ -1,2 +0,0 @@
-'use strict';
-module.exports = require('./lib');

package/node_modules/async-lock/lib/index.js

@@ -1,312 +0,0 @@
-'use strict';
-
-var AsyncLock = function (opts) {
-	opts = opts || {};
-
-	this.Promise = opts.Promise || Promise;
-
-	// format: {key : [fn, fn]}
-	// queues[key] = null indicates no job running for key
-	this.queues = Object.create(null);
-
-	// lock is reentrant for same domain
-	this.domainReentrant = opts.domainReentrant || false;
-	if (this.domainReentrant) {
-		if (typeof process === 'undefined' || typeof process.domain === 'undefined') {
-			throw new Error(
-				'Domain-reentrant locks require `process.domain` to exist. Please flip `opts.domainReentrant = false`, ' +
-				'use a NodeJS version that still implements Domain, or install a browser polyfill.');
-		}
-		// domain of current running func {key : fn}
-		this.domains = Object.create(null);
-	}
-
-	this.timeout = opts.timeout || AsyncLock.DEFAULT_TIMEOUT;
-	this.maxOccupationTime = opts.maxOccupationTime || AsyncLock.DEFAULT_MAX_OCCUPATION_TIME;
-	this.maxExecutionTime = opts.maxExecutionTime || AsyncLock.DEFAULT_MAX_EXECUTION_TIME;
-	if (opts.maxPending === Infinity || (Number.isInteger(opts.maxPending) && opts.maxPending >= 0)) {
-		this.maxPending = opts.maxPending;
-	} else {
-		this.maxPending = AsyncLock.DEFAULT_MAX_PENDING;
-	}
-};
-
-AsyncLock.DEFAULT_TIMEOUT = 0; //Never
-AsyncLock.DEFAULT_MAX_OCCUPATION_TIME = 0; //Never
-AsyncLock.DEFAULT_MAX_EXECUTION_TIME = 0; //Never
-AsyncLock.DEFAULT_MAX_PENDING = 1000;
-
-/**
- * Acquire Locks
- *
- * @param {String|Array} key 	resource key or keys to lock
- * @param {function} fn 	async function
- * @param {function} cb 	callback function, otherwise will return a promise
- * @param {Object} opts 	options
- */
-AsyncLock.prototype.acquire = function (key, fn, cb, opts) {
-	if (Array.isArray(key)) {
-		return this._acquireBatch(key, fn, cb, opts);
-	}
-
-	if (typeof (fn) !== 'function') {
-		throw new Error('You must pass a function to execute');
-	}
-
-	// faux-deferred promise using new Promise() (as Promise.defer is deprecated)
-	var deferredResolve = null;
-	var deferredReject = null;
-	var deferred = null;
-
-	if (typeof (cb) !== 'function') {
-		opts = cb;
-		cb = null;
-
-		// will return a promise
-		deferred = new this.Promise(function(resolve, reject) {
-			deferredResolve = resolve;
-			deferredReject = reject;
-		});
-	}
-
-	opts = opts || {};
-
-	var resolved = false;
-	var timer = null;
-	var occupationTimer = null;
-	var executionTimer = null;
-	var self = this;
-
-	var done = function (locked, err, ret) {
-
-		if (occupationTimer) {
-			clearTimeout(occupationTimer);
-			occupationTimer = null;
-		}
-
-		if (executionTimer) {
-			clearTimeout(executionTimer);
-			executionTimer = null;
-		}
-
-		if (locked) {
-			if (!!self.queues[key] && self.queues[key].length === 0) {
-				delete self.queues[key];
-			}
-			if (self.domainReentrant) {
-				delete self.domains[key];
-			}
-		}
-
-		if (!resolved) {
-			if (!deferred) {
-				if (typeof (cb) === 'function') {
-					cb(err, ret);
-				}
-			}
-			else {
-				//promise mode
-				if (err) {
-					deferredReject(err);
-				}
-				else {
-					deferredResolve(ret);
-				}
-			}
-			resolved = true;
-		}
-
-		if (locked) {
-			//run next func
-			if (!!self.queues[key] && self.queues[key].length > 0) {
-				self.queues[key].shift()();
-			}
-		}
-	};
-
-	var exec = function (locked) {
-		if (resolved) { // may due to timed out
-			return done(locked);
-		}
-
-		if (timer) {
-			clearTimeout(timer);
-			timer = null;
-		}
-
-		if (self.domainReentrant && locked) {
-			self.domains[key] = process.domain;
-		}
-
-		var maxExecutionTime = opts.maxExecutionTime || self.maxExecutionTime;
-		if (maxExecutionTime) {
-			executionTimer = setTimeout(function () {
-				if (!!self.queues[key]) {
-					done(locked, new Error('Maximum execution time is exceeded ' + key));
-				}
-			}, maxExecutionTime);
-		}
-
-		// Callback mode
-		if (fn.length === 1) {
-			var called = false;
-			try {
-				fn(function (err, ret) {
-					if (!called) {
-						called = true;
-						done(locked, err, ret);
-					}
-				});
-			} catch (err) {
-				// catching error thrown in user function fn
-				if (!called) {
-					called = true;
-					done(locked, err);
-				}
-			}
-		}
-		else {
-			// Promise mode
-			self._promiseTry(function () {
-				return fn();
-			})
-			.then(function(ret){
-				done(locked, undefined, ret);
-			}, function(error){
-				done(locked, error);
-			});
-		}
-	};
-
-	if (self.domainReentrant && !!process.domain) {
-		exec = process.domain.bind(exec);
-	}
-
-	var maxPending = opts.maxPending || self.maxPending;
-
-	if (!self.queues[key]) {
-		self.queues[key] = [];
-		exec(true);
-	}
-	else if (self.domainReentrant && !!process.domain && process.domain === self.domains[key]) {
-		// If code is in the same domain of current running task, run it directly
-		// Since lock is re-enterable
-		exec(false);
-	}
-	else if (self.queues[key].length >= maxPending) {
-		done(false, new Error('Too many pending tasks in queue ' + key));
-	}
-	else {
-		var taskFn = function () {
-			exec(true);
-		};
-		if (opts.skipQueue) {
-			self.queues[key].unshift(taskFn);
-		} else {
-			self.queues[key].push(taskFn);
-		}
-
-		var timeout = opts.timeout || self.timeout;
-		if (timeout) {
-			timer = setTimeout(function () {
-				timer = null;
-				done(false, new Error('async-lock timed out in queue ' + key));
-			}, timeout);
-		}
-	}
-
-	var maxOccupationTime = opts.maxOccupationTime || self.maxOccupationTime;
-		if (maxOccupationTime) {
-			occupationTimer = setTimeout(function () {
-				if (!!self.queues[key]) {
-					done(false, new Error('Maximum occupation time is exceeded in queue ' + key));
-				}
-			}, maxOccupationTime);
-		}
-
-	if (deferred) {
-		return deferred;
-	}
-};
-
-/*
- * Below is how this function works:
- *
- * Equivalent code:
- * self.acquire(key1, function(cb){
- *     self.acquire(key2, function(cb){
- *         self.acquire(key3, fn, cb);
- *     }, cb);
- * }, cb);
- *
- * Equivalent code:
- * var fn3 = getFn(key3, fn);
- * var fn2 = getFn(key2, fn3);
- * var fn1 = getFn(key1, fn2);
- * fn1(cb);
- */
-AsyncLock.prototype._acquireBatch = function (keys, fn, cb, opts) {
-	if (typeof (cb) !== 'function') {
-		opts = cb;
-		cb = null;
-	}
-
-	var self = this;
-	var getFn = function (key, fn) {
-		return function (cb) {
-			self.acquire(key, fn, cb, opts);
-		};
-	};
-
-	var fnx = keys.reduceRight(function (prev, key) {
-		return getFn(key, prev);
-	}, fn);
-
-	if (typeof (cb) === 'function') {
-		fnx(cb);
-	}
-	else {
-		return new this.Promise(function (resolve, reject) {
-			// check for promise mode in case keys is empty array
-			if (fnx.length === 1) {
-				fnx(function (err, ret) {
-					if (err) {
-						reject(err);
-					}
-					else {
-						resolve(ret);
-					}
-				});
-			} else {
-				resolve(fnx());
-			}
-		});
-	}
-};
-
-/*
- *	Whether there is any running or pending asyncFunc
- *
- *	@param {String} key
- */
-AsyncLock.prototype.isBusy = function (key) {
-	if (!key) {
-		return Object.keys(this.queues).length > 0;
-	}
-	else {
-		return !!this.queues[key];
-	}
-};
-
-/**
- * Promise.try() implementation to become independent of Q-specific methods
- */
-AsyncLock.prototype._promiseTry = function(fn) {
-	try {
-		return this.Promise.resolve(fn());
-	} catch (e) {
-		return this.Promise.reject(e);
-	}
-};
-
-module.exports = AsyncLock;

package/node_modules/async-lock/package.json

@@ -1,48 +0,0 @@
-{
-  "name": "async-lock",
-  "description": "Lock on asynchronous code",
-  "version": "1.4.1",
-  "author": {
-    "name": "Rogier Schouten",
-    "url": "https://github.com/rogierschouten/",
-    "email": "github@workingcode.ninja"
-  },
-  "private": false,
-  "homepage": "https://github.com/rogierschouten/async-lock",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/rogierschouten/async-lock.git"
-  },
-  "bugs": {
-    "url": "https://github.com/rogierschouten/async-lock/issues"
-  },
-  "license": "MIT",
-  "keywords": [
-    "lock",
-    "async",
-    "concurrency",
-    "critical",
-    "section",
-    "mutex"
-  ],
-  "engines": {},
-  "scripts": {
-    "start": "grunt",
-    "test": "grunt test"
-  },
-  "devDependencies": {
-    "bluebird": "^3.5.1",
-    "grunt": "^1.0.4",
-    "grunt-cli": "^1.2.0",
-    "grunt-contrib-clean": "^1.1.0",
-    "grunt-contrib-jshint": "^3.2.0",
-    "grunt-contrib-watch": "^1.1.0",
-    "grunt-env": "^1.0.1",
-    "grunt-mocha-test": "^0.13.3",
-    "load-grunt-tasks": "^4.0.0",
-    "lodash": "^4.17.20",
-    "mocha": "^10.2.0",
-    "q": "^1.5.1",
-    "should": "^13.2.1"
-  }
-}

package/node_modules/asyncbox/build/cjs/lib/asyncbox.d.ts

@@ -1,103 +0,0 @@
-import type { CancellablePromise, LongSleepOptions, MapFilterOptions, SleepOptions, WaitForConditionOptions } from './types.js';
-/** Error thrown by {@link withTimeout} when the deadline is exceeded. */
-export declare class TimeoutError extends Error {
-    constructor(message?: string);
-}
-/** Thrown when a promise is cancelled via `cancel`. */
-export declare class PromiseCancellationError extends Error {
-    constructor(message?: string);
-}
-/**
- * An async/await version of `setTimeout`. The returned promise has a `cancel()` method that clears
- * the timer and usually rejects with {@link PromiseCancellationError} unless you use the object form with
- * `cancelError: null` to resolve on cancel.
- *
- * @param ms - Milliseconds to wait
- * @returns A thenable you can `await`; call `.cancel()` to abort early.
- */
-export declare function sleep(ms: number): CancellablePromise<void>;
-/**
- * Object form: `ms` plus optional `cancelError` (non-empty string or `Error`, `null` to resolve on
- * cancel, or omitted / `undefined` / `''` for default {@link PromiseCancellationError}). Any non-array
- * object with a finite `ms` is accepted at runtime (including class instances), matching structural typing.
- *
- * @param options - Duration and optional cancellation behavior
- * @returns A thenable you can `await`; call `.cancel()` to abort early.
- */
-export declare function sleep(options: SleepOptions): CancellablePromise<void>;
-/**
- * Resolves with `promise` or rejects if it does not settle before `timeoutMs`.
- *
- * If the deadline passes first: with no third argument (or a falsy non-error value), rejects
- * with {@link TimeoutError} whose message includes `timeoutMs`; with a non-empty string,
- * rejects with {@link TimeoutError} using that message; with an `Error` instance, rejects
- * with that same instance.
- *
- * @param promise - Promise to race against the timeout.
- * @param timeoutMs - Maximum time in milliseconds before rejecting if `promise` has not settled.
- * @param messageOrError - Optional override for the timeout rejection: custom {@link TimeoutError}
- * message when the string is non-empty, or an existing `Error` to reject with verbatim.
- * Omitted, `undefined`, or other falsy non-error values use the default timeout message (includes `timeoutMs`).
- */
-export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, messageOrError?: string | Error): Promise<T>;
-/**
- * Sometimes `Promise.delay` or `setTimeout` are inaccurate for large wait
- * times. To safely wait for these long times (e.g. in the 5+ minute range), you
- * can use `longSleep`.
- *
- * You can also pass a `progressCb` option which is a callback function that
- * receives an object with the properties `elapsedMs`, `timeLeft`, and
- * `progress`. This will be called on every wait interval so you can do your
- * wait logging or whatever.
- * @param ms - The number of milliseconds to wait
- * @param options - Options for controlling the long sleep behavior
- */
-export declare function longSleep(ms: number, { thresholdMs, intervalMs, progressCb }?: LongSleepOptions): Promise<void>;
-/**
- * An async/await way of running a method until it doesn't throw an error
- * @param times - The maximum number of times to retry the function
- * @param fn - The async function to retry
- * @param args - Arguments to pass to the function
- */
-export declare function retry<T = any>(times: number, fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T | null>;
-/**
- * You can also use `retryInterval` to add a sleep in between retries. This can
- * be useful if you want to throttle how fast we retry.
- * @param times - The maximum number of times to retry the function
- * @param sleepMs - The number of milliseconds to wait between retries
- * @param fn - The async function to retry
- * @param args - Arguments to pass to the function
- */
-export declare function retryInterval<T = any>(times: number, sleepMs: number, fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T | null>;
-/**
- * Similar to `Array.prototype.map`; runs in parallel, serial, or with custom concurrency pool
- * @param coll - The collection to map over
- * @param mapper - The function to apply to each element
- * @param options - Options for controlling parallelism (default: true - fully parallel)
- */
-export declare function asyncmap<T, R>(coll: T[], mapper: (value: T) => R | Promise<R>, options?: MapFilterOptions): Promise<R[]>;
-/**
- * Similar to `Array.prototype.filter`; runs in parallel, serial, or with custom concurrency pool
- * @param coll - The collection to filter
- * @param filter - The function to test each element
- * @param options - Options for controlling parallelism (default: true - fully parallel)
- */
-export declare function asyncfilter<T>(coll: T[], filter: (value: T) => boolean | Promise<boolean>, options?: MapFilterOptions): Promise<T[]>;
-/**
- * Takes a condition (a function returning a boolean or boolean promise), and
- * waits until the condition is true.
- *
- * Throws a `/Condition unmet/` error if the condition has not been satisfied
- * within the allocated time, unless an error is provided in the options, as the
- * `error` property, which is either thrown itself, or used as the message.
- *
- * The condition result is returned if it is not falsy. If the condition throws an
- * error then this exception will be immediately passed through.
- *
- * The default options are: `{ waitMs: 5000, intervalMs: 500 }`
- * @param condFn - The condition function to evaluate
- * @param options - Options for controlling the wait behavior
- */
-export declare function waitForCondition<T>(condFn: () => Promise<T> | T, options?: WaitForConditionOptions): Promise<T>;
-export type { CancellablePromise, Progress, ProgressCallback, LongSleepOptions, SleepArg, SleepOptions, WaitForConditionOptions, } from './types.js';
-//# sourceMappingURL=asyncbox.d.ts.map

package/node_modules/asyncbox/build/cjs/lib/asyncbox.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asyncbox.d.ts","sourceRoot":"","sources":["../../../lib/asyncbox.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAEhB,YAAY,EACZ,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAepB,yEAAyE;AACzE,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;CAI7B;AAED,uDAAuD;AACvD,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,OAAO,GAAE,MAA4B;CAIlD;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;AAC5D;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;AAsCvE;;;;;;;;;;;;;GAaG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,cAAc,CAAC,EAAE,MAAM,GAAG,KAAK,GAC9B,OAAO,CAAC,CAAC,CAAC,CAsBZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,SAAS,CAC7B,EAAE,EAAE,MAAM,EACV,EAAC,WAAkC,EAAE,UAAiB,EAAE,UAAiB,EAAC,GAAE,gBAAqB,GAChG,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED;;;;;GAKG;AACH,wBAAsB,KAAK,CAAC,CAAC,GAAG,GAAG,EACjC,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,GAAG,IAAI,EAAE,GAAG,EAAE,GACb,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAgBnB;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,CAAC,GAAG,GAAG,EACzC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,GAAG,IAAI,EAAE,GAAG,EAAE,GACb,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAiBnB;AAED;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,IAAI,EAAE,CAAC,EAAE,EACT,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACpC,OAAO,GAAE,gBAAuB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAed;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,IAAI,EAAE,CAAC,EAAE,EACT,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EAChD,OAAO,GAAE,gBAAuB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAwBd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAC5B,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,CAAC,CAAC,CA8BZ;AAGD,YAAY,EACV,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,YAAY,EACZ,uBAAuB,GACxB,MAAM,YAAY,CAAC"}