@data-client/core
Version:
Async State Management without the Management. REST, GraphQL, SSE, Websockets, Fetch
418 lines (394 loc) • 64.2 kB
JavaScript
import { ExpiryStatus, MemoCache, denormalize, validateQueryKey } from '@data-client/normalizr';
import AbortOptimistic from './AbortOptimistic.js';
import { createUnsubscription, createSubscription } from './actions/createSubscription.js';
import { createExpireAll, createFetch, createInvalidate, createInvalidateAll, createReset, createSet, createSetResponse } from './actions/index.js';
import ensurePojo from './ensurePojo.js';
import { ImmortalGCPolicy } from '../state/GCPolicy.js';
import { initialState } from '../state/reducer/createReducer.js';
import selectMeta from '../state/selectMeta.js';
const unsetDispatch = action => {
throw new Error(`Dispatching while constructing your middleware is not allowed. ` + `Other middleware would not be applied to this dispatch.`);
};
const unsetState = () => {
// This is only the value until it is set by the DataProvider
/* istanbul ignore next */
return initialState;
};
/**
* Imperative control of Reactive Data Client store
* @see https://dataclient.io/docs/api/Controller
*/
export default class Controller {
/**
* Dispatches an action to Reactive Data Client reducer.
*
* @see https://dataclient.io/docs/api/Controller#dispatch
*/
/**
* Gets the latest state snapshot that is fully committed.
*
* This can be useful for imperative use-cases like event handlers.
* This should *not* be used to render; instead useSuspense() or useCache()
* @see https://dataclient.io/docs/api/Controller#getState
*/
/**
* Singleton to maintain referential equality between calls
*/
/**
* Handles garbage collection
*/
constructor({
dispatch = unsetDispatch,
getState = unsetState,
memo = new MemoCache(),
gcPolicy = new ImmortalGCPolicy()
} = {}) {
/*************** Action Dispatchers ***************/
/**
* Fetches the endpoint with given args, updating the Reactive Data Client cache with the response or error upon completion.
* @see https://dataclient.io/docs/api/Controller#fetch
*/
this.fetch = (endpoint, ...args) => {
const action = createFetch(endpoint, {
args
});
this.dispatch(action);
if (endpoint.schema) {
return action.meta.promise.then(input => denormalize(endpoint.schema, input, {}, args));
}
return action.meta.promise;
};
/**
* Fetches only if endpoint is considered 'stale'; otherwise returns undefined
* @see https://dataclient.io/docs/api/Controller#fetchIfStale
*/
this.fetchIfStale = (endpoint, ...args) => {
const {
data,
expiresAt,
expiryStatus
} = this.getResponseMeta(endpoint, ...args, this.getState());
if (expiryStatus !== ExpiryStatus.Invalid && Date.now() <= expiresAt) return data;
return this.fetch(endpoint, ...args);
};
/**
* Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
* @see https://dataclient.io/docs/api/Controller#invalidate
*/
this.invalidate = (endpoint, ...args) => args[0] !== null ? this.dispatch(createInvalidate(endpoint, {
args: args
})) : Promise.resolve();
/**
* Forces refetching and suspense on useSuspense on all matching endpoint result keys.
* @see https://dataclient.io/docs/api/Controller#invalidateAll
* @returns Promise that resolves when invalidation is commited.
*/
this.invalidateAll = options => this.dispatch(createInvalidateAll(key => options.testKey(key)));
/**
* Sets all matching endpoint result keys to be STALE.
* @see https://dataclient.io/docs/api/Controller#expireAll
* @returns Promise that resolves when expiry is commited. *NOT* fetch promise
*/
this.expireAll = options => this.dispatch(createExpireAll(key => options.testKey(key)));
/**
* Resets the entire Reactive Data Client cache. All inflight requests will not resolve.
* @see https://dataclient.io/docs/api/Controller#resetEntireStore
*/
this.resetEntireStore = () => this.dispatch(createReset());
/**
* Sets response for the Endpoint and args.
* @see https://dataclient.io/docs/api/Controller#setResponse
*/
this.setResponse = (endpoint, ...rest) => {
const response = rest[rest.length - 1];
const action = createSetResponse(endpoint, {
args: rest.slice(0, rest.length - 1),
response
});
return this.dispatch(action);
};
/**
* Sets an error response for the Endpoint and args.
* @see https://dataclient.io/docs/api/Controller#setError
*/
this.setError = (endpoint, ...rest) => {
const response = rest[rest.length - 1];
const action = createSetResponse(endpoint, {
args: rest.slice(0, rest.length - 1),
response,
error: true
});
return this.dispatch(action);
};
/**
* Resolves an inflight fetch.
* @see https://dataclient.io/docs/api/Controller#resolve
*/
this.resolve = (endpoint, meta) => {
return this.dispatch(createSetResponse(endpoint, meta));
};
/**
* Marks a new subscription to a given Endpoint.
* @see https://dataclient.io/docs/api/Controller#subscribe
*/
this.subscribe = (endpoint, ...args) => args[0] !== null ? this.dispatch(createSubscription(endpoint, {
args: args
})) : Promise.resolve();
/**
* Marks completion of subscription to a given Endpoint.
* @see https://dataclient.io/docs/api/Controller#unsubscribe
*/
this.unsubscribe = (endpoint, ...args) => args[0] !== null ? this.dispatch(createUnsubscription(endpoint, {
args: args
})) : Promise.resolve();
/*************** More ***************/
/* TODO:
abort = <E extends EndpointInterface>(
endpoint: E,
...args: readonly [...Parameters<E>]
): Promise<void>
*/
/**
* Gets a snapshot (https://dataclient.io/docs/api/Snapshot)
* @see https://dataclient.io/docs/api/Controller#snapshot
*/
this.snapshot = (state, fetchedAt) => {
return new Snapshot(this, state, fetchedAt);
};
this._dispatch = dispatch;
this.getState = getState;
this.memo = memo;
this.gcPolicy = gcPolicy;
}
// TODO: drop when drop support for destructuring (0.14 and below)
set dispatch(dispatch) {
/* istanbul ignore next */
this._dispatch = dispatch;
}
// TODO: drop when drop support for destructuring (0.14 and below)
get dispatch() {
return this._dispatch;
}
bindMiddleware({
dispatch,
getState
}) {
this._dispatch = dispatch;
this.getState = getState;
}
/**
* Sets value for the Queryable and args.
* @see https://dataclient.io/docs/api/Controller#set
*/
set(schema, ...rest) {
const value = rest[rest.length - 1];
const action = createSet(schema, {
args: rest.slice(0, rest.length - 1),
value
});
// TODO: reject with error if this fails in reducer
return this.dispatch(action);
}
/**
* Gets the error, if any, for a given endpoint. Returns undefined for no errors.
* @see https://dataclient.io/docs/api/Controller#getError
*/
getError(endpoint, ...rest) {
if (rest[0] === null) return;
const state = rest[rest.length - 1];
// this is typescript generics breaking
const args = rest.slice(0, rest.length - 1);
const key = endpoint.key(...args);
const meta = selectMeta(state, key);
const error = state.endpoints[key];
if (error !== undefined && (meta == null ? void 0 : meta.errorPolicy) === 'soft') return;
return meta == null ? void 0 : meta.error;
}
/**
* Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
* @see https://dataclient.io/docs/api/Controller#getResponse
*/
getResponse(endpoint, ...rest) {
// TODO: breaking: only return data
return this.getResponseMeta(endpoint, ...rest);
}
/**
* Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
* @see https://dataclient.io/docs/api/Controller#getResponseMeta
*/
getResponseMeta(endpoint, ...rest) {
const [state, args] = extractStateAndArgs(rest);
const isActive = args.length !== 1 || args[0] !== null;
const key = isActive ? endpoint.key(...args) : '';
const cacheEndpoints = isActive ? state.endpoints[key] : undefined;
const schema = endpoint.schema;
const meta = selectMeta(state, key);
let expiresAt = meta == null ? void 0 : meta.expiresAt;
// if we have no endpoint entry, and our endpoint has a schema - try querying the store
const shouldQuery = cacheEndpoints === undefined && schema !== undefined;
const input = shouldQuery ?
// nothing in endpoints cache, so try querying if we have a schema to do so
this.memo.buildQueryKey(schema, args, state, key) : cacheEndpoints;
if (!isActive) {
// when not active simply return the query input without denormalizing
return {
data: input,
expiryStatus: ExpiryStatus.Valid,
expiresAt: Infinity,
countRef: () => () => undefined
};
}
let isInvalid = false;
if (shouldQuery) {
isInvalid = !validateQueryKey(input);
// endpoint without entities
} else if (!schema || !requiresDenormalize(schema)) {
return {
data: cacheEndpoints,
expiryStatus: this.getExpiryStatus(cacheEndpoints === undefined, !!endpoint.invalidIfStale, meta),
expiresAt: expiresAt || 0,
countRef: this.gcPolicy.createCountRef({
key
})
};
}
const {
data,
paths
} = this.memo.denormalize(schema, input, state.entities, args);
if (!expiresAt) {
// note: isInvalid can only be true if shouldQuery is true
if (isInvalid) expiresAt = 1;
// fallback to entity expiry time
else expiresAt = entityExpiresAt(paths, state.entitiesMeta);
}
return {
data,
expiryStatus: this.getExpiryStatus(typeof data === 'symbol', !!endpoint.invalidIfStale || isInvalid, meta),
expiresAt,
countRef: this.gcPolicy.createCountRef({
key,
paths
})
};
}
/**
* Queries the store for a Querable schema
* @see https://dataclient.io/docs/api/Controller#get
*/
get(schema, ...rest) {
const [state, args] = extractStateAndArgs(rest);
const {
data
} = this.memo.query(schema, args, state);
return typeof data === 'symbol' ? undefined : data;
}
/**
* Queries the store for a Querable schema; providing related metadata
* @see https://dataclient.io/docs/api/Controller#getQueryMeta
*/
getQueryMeta(schema, ...rest) {
const [state, args] = extractStateAndArgs(rest);
const {
data,
paths
} = this.memo.query(schema, args, state);
return {
data: typeof data === 'symbol' ? undefined : data,
countRef: this.gcPolicy.createCountRef({
paths
})
};
}
getExpiryStatus(invalidData, invalidIfStale, meta = {}) {
// https://dataclient.io/docs/concepts/expiry-policy#expiry-status
// we don't track the difference between stale or fresh because that is tied to triggering
// conditions
return meta.invalidated || invalidData && !meta.error ? ExpiryStatus.Invalid : invalidData || invalidIfStale ? ExpiryStatus.InvalidIfStale : ExpiryStatus.Valid;
}
}
// benchmark: https://www.measurethat.net/Benchmarks/Show/24691/0/min-reducer-vs-imperative-with-paths
// earliest expiry dictates age
function entityExpiresAt(paths, entitiesMeta) {
let expiresAt = Infinity;
for (const {
key,
pk
} of paths) {
var _entitiesMeta$key;
const entityExpiry = (_entitiesMeta$key = entitiesMeta[key]) == null || (_entitiesMeta$key = _entitiesMeta$key[pk]) == null ? void 0 : _entitiesMeta$key.expiresAt;
// expiresAt will always resolve to false with any comparison
if (entityExpiry < expiresAt) expiresAt = entityExpiry;
}
return expiresAt;
}
/** Whether `denormalize()` must run to reconstruct the response.
*
* True iff some node in the schema tree defines `normalize` — meaning it
* transforms the response when written (entity write, polymorphic hoist,
* lazy delegation, etc.), so the cached value differs from the response.
* Mirrors the dispatch in `getVisit.ts`: schema classes are detected here
* by the same hook the visit walker uses, so we never need to walk their
* instance fields.
*/
function requiresDenormalize(schema) {
if (!schema) return false;
if (Array.isArray(schema)) return schema.length !== 0 && requiresDenormalize(schema[0]);
// Must reject primitives before probing `.normalize` — `String.prototype.normalize` exists.
const t = typeof schema;
if (t !== 'object' && t !== 'function') return false;
if (typeof schema.normalize === 'function') return true;
// Plain-object schema map (e.g. `{ data: [Tacos], page: { ... } }`).
return Object.values(schema).some(x => requiresDenormalize(x));
}
class Snapshot {
constructor(controller, state, fetchedAt = 0) {
this.state = void 0;
this.controller = void 0;
this.fetchedAt = void 0;
this.abort = Snapshot.abort;
this.state = state;
this.controller = controller;
this.fetchedAt = fetchedAt;
}
/*************** Data Access ***************/
/** @see https://dataclient.io/docs/api/Snapshot#getResponse */
getResponse(endpoint, ...args) {
return this.controller.getResponse(endpoint, ...args, this.state);
}
/** @see https://dataclient.io/docs/api/Snapshot#getResponseMeta */
getResponseMeta(endpoint, ...args) {
return this.controller.getResponseMeta(endpoint, ...args, this.state);
}
/** @see https://dataclient.io/docs/api/Snapshot#getError */
getError(endpoint, ...args) {
return this.controller.getError(endpoint, ...args, this.state);
}
/**
* Retrieved memoized value for any Querable schema
* @see https://dataclient.io/docs/api/Snapshot#get
*/
get(schema, ...args) {
return this.controller.get(schema, ...args, this.state);
}
/**
* Queries the store for a Querable schema; providing related metadata
* @see https://dataclient.io/docs/api/Snapshot#getQueryMeta
*/
getQueryMeta(schema, ...args) {
return this.controller.getQueryMeta(schema, ...args, this.state);
}
}
/** Extract state and args from rest params, applying ensurePojo to args */
Snapshot.abort = new AbortOptimistic();
function extractStateAndArgs(rest) {
const l = rest.length;
const args = new Array(l - 1);
for (let i = 0; i < l - 1; i++) {
// handle FormData
args[i] = ensurePojo(rest[i]);
}
// this is typescript generics breaking
return [rest[l - 1], args];
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJFeHBpcnlTdGF0dXMiLCJNZW1vQ2FjaGUiLCJkZW5vcm1hbGl6ZSIsInZhbGlkYXRlUXVlcnlLZXkiLCJBYm9ydE9wdGltaXN0aWMiLCJjcmVhdGVVbnN1YnNjcmlwdGlvbiIsImNyZWF0ZVN1YnNjcmlwdGlvbiIsImNyZWF0ZUV4cGlyZUFsbCIsImNyZWF0ZUZldGNoIiwiY3JlYXRlSW52YWxpZGF0ZSIsImNyZWF0ZUludmFsaWRhdGVBbGwiLCJjcmVhdGVSZXNldCIsImNyZWF0ZVNldCIsImNyZWF0ZVNldFJlc3BvbnNlIiwiZW5zdXJlUG9qbyIsIkltbW9ydGFsR0NQb2xpY3kiLCJpbml0aWFsU3RhdGUiLCJzZWxlY3RNZXRhIiwidW5zZXREaXNwYXRjaCIsImFjdGlvbiIsIkVycm9yIiwidW5zZXRTdGF0ZSIsIkNvbnRyb2xsZXIiLCJjb25zdHJ1Y3RvciIsImRpc3BhdGNoIiwiZ2V0U3RhdGUiLCJtZW1vIiwiZ2NQb2xpY3kiLCJmZXRjaCIsImVuZHBvaW50IiwiYXJncyIsInNjaGVtYSIsIm1ldGEiLCJwcm9taXNlIiwidGhlbiIsImlucHV0IiwiZmV0Y2hJZlN0YWxlIiwiZGF0YSIsImV4cGlyZXNBdCIsImV4cGlyeVN0YXR1cyIsImdldFJlc3BvbnNlTWV0YSIsIkludmFsaWQiLCJEYXRlIiwibm93IiwiaW52YWxpZGF0ZSIsIlByb21pc2UiLCJyZXNvbHZlIiwiaW52YWxpZGF0ZUFsbCIsIm9wdGlvbnMiLCJrZXkiLCJ0ZXN0S2V5IiwiZXhwaXJlQWxsIiwicmVzZXRFbnRpcmVTdG9yZSIsInNldFJlc3BvbnNlIiwicmVzdCIsInJlc3BvbnNlIiwibGVuZ3RoIiwic2xpY2UiLCJzZXRFcnJvciIsImVycm9yIiwic3Vic2NyaWJlIiwidW5zdWJzY3JpYmUiLCJzbmFwc2hvdCIsInN0YXRlIiwiZmV0Y2hlZEF0IiwiU25hcHNob3QiLCJfZGlzcGF0Y2giLCJiaW5kTWlkZGxld2FyZSIsInNldCIsInZhbHVlIiwiZ2V0RXJyb3IiLCJlbmRwb2ludHMiLCJ1bmRlZmluZWQiLCJlcnJvclBvbGljeSIsImdldFJlc3BvbnNlIiwiZXh0cmFjdFN0YXRlQW5kQXJncyIsImlzQWN0aXZlIiwiY2FjaGVFbmRwb2ludHMiLCJzaG91bGRRdWVyeSIsImJ1aWxkUXVlcnlLZXkiLCJWYWxpZCIsIkluZmluaXR5IiwiY291bnRSZWYiLCJpc0ludmFsaWQiLCJyZXF1aXJlc0Rlbm9ybWFsaXplIiwiZ2V0RXhwaXJ5U3RhdHVzIiwiaW52YWxpZElmU3RhbGUiLCJjcmVhdGVDb3VudFJlZiIsInBhdGhzIiwiZW50aXRpZXMiLCJlbnRpdHlFeHBpcmVzQXQiLCJlbnRpdGllc01ldGEiLCJnZXQiLCJxdWVyeSIsImdldFF1ZXJ5TWV0YSIsImludmFsaWREYXRhIiwiaW52YWxpZGF0ZWQiLCJJbnZhbGlkSWZTdGFsZSIsInBrIiwiX2VudGl0aWVzTWV0YSRrZXkiLCJlbnRpdHlFeHBpcnkiLCJBcnJheSIsImlzQXJyYXkiLCJ0Iiwibm9ybWFsaXplIiwiT2JqZWN0IiwidmFsdWVzIiwic29tZSIsIngiLCJjb250cm9sbGVyIiwiYWJvcnQiLCJsIiwiaSJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb250cm9sbGVyL0NvbnRyb2xsZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUge1xuICBFcnJvclR5cGVzLFxuICBTbmFwc2hvdEludGVyZmFjZSxcbiAgU2NoZW1hLFxuICBEZW5vcm1hbGl6ZSxcbiAgUXVlcnlhYmxlLFxuICBTY2hlbWFBcmdzLFxufSBmcm9tICdAZGF0YS1jbGllbnQvbm9ybWFsaXpyJztcbmltcG9ydCB7XG4gIEV4cGlyeVN0YXR1cyxcbiAgRW5kcG9pbnRJbnRlcmZhY2UsXG4gIEZldGNoRnVuY3Rpb24sXG4gIFJlc29sdmVUeXBlLFxuICBEZW5vcm1hbGl6ZU51bGxhYmxlLFxuICBFbnRpdHlQYXRoLFxuICBNZW1vQ2FjaGUsXG4gIGRlbm9ybWFsaXplLFxuICB2YWxpZGF0ZVF1ZXJ5S2V5LFxufSBmcm9tICdAZGF0YS1jbGllbnQvbm9ybWFsaXpyJztcblxuaW1wb3J0IEFib3J0T3B0aW1pc3RpYyBmcm9tICcuL0Fib3J0T3B0aW1pc3RpYy5qcyc7XG5pbXBvcnQge1xuICBjcmVhdGVVbnN1YnNjcmlwdGlvbixcbiAgY3JlYXRlU3Vic2NyaXB0aW9uLFxufSBmcm9tICcuL2FjdGlvbnMvY3JlYXRlU3Vic2NyaXB0aW9uLmpzJztcbmltcG9ydCB7XG4gIGNyZWF0ZUV4cGlyZUFsbCxcbiAgY3JlYXRlRmV0Y2gsXG4gIGNyZWF0ZUludmFsaWRhdGUsXG4gIGNyZWF0ZUludmFsaWRhdGVBbGwsXG4gIGNyZWF0ZVJlc2V0LFxuICBjcmVhdGVTZXQsXG4gIGNyZWF0ZVNldFJlc3BvbnNlLFxufSBmcm9tICcuL2FjdGlvbnMvaW5kZXguanMnO1xuaW1wb3J0IGVuc3VyZVBvam8gZnJvbSAnLi9lbnN1cmVQb2pvLmpzJztcbmltcG9ydCB0eXBlIHsgRW5kcG9pbnRVcGRhdGVGdW5jdGlvbiB9IGZyb20gJy4vdHlwZXMuanMnO1xuaW1wb3J0IHsgUmVkdXhNaWRkbGV3YXJlQVBJIH0gZnJvbSAnLi4vbWFuYWdlci9hcHBseU1hbmFnZXIuanMnO1xuaW1wb3J0IHR5cGUgeyBHQ0ludGVyZmFjZSB9IGZyb20gJy4uL3N0YXRlL0dDUG9saWN5LmpzJztcbmltcG9ydCB7IEltbW9ydGFsR0NQb2xpY3kgfSBmcm9tICcuLi9zdGF0ZS9HQ1BvbGljeS5qcyc7XG5pbXBvcnQgeyBpbml0aWFsU3RhdGUgfSBmcm9tICcuLi9zdGF0ZS9yZWR1Y2VyL2NyZWF0ZVJlZHVjZXIuanMnO1xuaW1wb3J0IHNlbGVjdE1ldGEgZnJvbSAnLi4vc3RhdGUvc2VsZWN0TWV0YS5qcyc7XG5pbXBvcnQgdHlwZSB7IEFjdGlvblR5cGVzLCBTdGF0ZSB9IGZyb20gJy4uL3R5cGVzLmpzJztcblxuZXhwb3J0IHR5cGUgR2VuZXJpY0Rpc3BhdGNoID0gKHZhbHVlOiBhbnkpID0+IFByb21pc2U8dm9pZD47XG5leHBvcnQgdHlwZSBEYXRhQ2xpZW50RGlzcGF0Y2ggPSAodmFsdWU6IEFjdGlvblR5cGVzKSA9PiBQcm9taXNlPHZvaWQ+O1xuXG5leHBvcnQgaW50ZXJmYWNlIENvbnRyb2xsZXJDb25zdHJ1Y3RvclByb3BzPFxuICBEIGV4dGVuZHMgR2VuZXJpY0Rpc3BhdGNoID0gRGF0YUNsaWVudERpc3BhdGNoLFxuPiB7XG4gIGRpc3BhdGNoPzogRDtcbiAgZ2V0U3RhdGU/OiAoKSA9PiBTdGF0ZTx1bmtub3duPjtcbiAgbWVtbz86IFBpY2s8TWVtb0NhY2hlLCAnZGVub3JtYWxpemUnIHwgJ3F1ZXJ5JyB8ICdidWlsZFF1ZXJ5S2V5Jz47XG4gIGdjUG9saWN5PzogR0NJbnRlcmZhY2U7XG59XG5cbmNvbnN0IHVuc2V0RGlzcGF0Y2ggPSAoYWN0aW9uOiB1bmtub3duKTogUHJvbWlzZTx2b2lkPiA9PiB7XG4gIHRocm93IG5ldyBFcnJvcihcbiAgICBgRGlzcGF0Y2hpbmcgd2hpbGUgY29uc3RydWN0aW5nIHlvdXIgbWlkZGxld2FyZSBpcyBub3QgYWxsb3dlZC4gYCArXG4gICAgICBgT3RoZXIgbWlkZGxld2FyZSB3b3VsZCBub3QgYmUgYXBwbGllZCB0byB0aGlzIGRpc3BhdGNoLmAsXG4gICk7XG59O1xuY29uc3QgdW5zZXRTdGF0ZSA9ICgpOiBTdGF0ZTx1bmtub3duPiA9PiB7XG4gIC8vIFRoaXMgaXMgb25seSB0aGUgdmFsdWUgdW50aWwgaXQgaXMgc2V0IGJ5IHRoZSBEYXRhUHJvdmlkZXJcbiAgLyogaXN0YW5idWwgaWdub3JlIG5leHQgKi9cbiAgcmV0dXJuIGluaXRpYWxTdGF0ZTtcbn07XG5cbi8qKlxuICogSW1wZXJhdGl2ZSBjb250cm9sIG9mIFJlYWN0aXZlIERhdGEgQ2xpZW50IHN0b3JlXG4gKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIENvbnRyb2xsZXI8XG4gIC8vIE5PVEU6IFdlIHRlbXBsYXRlIG9uIGVudGlyZSBkaXNwYXRjaCwgc28gd2UgY2FuIGJlIGNvbnRyYXZhcmlhbnQgb24gQWN0aW9uVHlwZXNcbiAgRCBleHRlbmRzIEdlbmVyaWNEaXNwYXRjaCA9IERhdGFDbGllbnREaXNwYXRjaCxcbj4ge1xuICAvKipcbiAgICogRGlzcGF0Y2hlcyBhbiBhY3Rpb24gdG8gUmVhY3RpdmUgRGF0YSBDbGllbnQgcmVkdWNlci5cbiAgICpcbiAgICogQHNlZSBodHRwczovL2RhdGFjbGllbnQuaW8vZG9jcy9hcGkvQ29udHJvbGxlciNkaXNwYXRjaFxuICAgKi9cbiAgZGVjbGFyZSBwcm90ZWN0ZWQgX2Rpc3BhdGNoOiBEO1xuICAvKipcbiAgICogR2V0cyB0aGUgbGF0ZXN0IHN0YXRlIHNuYXBzaG90IHRoYXQgaXMgZnVsbHkgY29tbWl0dGVkLlxuICAgKlxuICAgKiBUaGlzIGNhbiBiZSB1c2VmdWwgZm9yIGltcGVyYXRpdmUgdXNlLWNhc2VzIGxpa2UgZXZlbnQgaGFuZGxlcnMuXG4gICAqIFRoaXMgc2hvdWxkICpub3QqIGJlIHVzZWQgdG8gcmVuZGVyOyBpbnN0ZWFkIHVzZVN1c3BlbnNlKCkgb3IgdXNlQ2FjaGUoKVxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI2dldFN0YXRlXG4gICAqL1xuICBkZWNsYXJlIGdldFN0YXRlOiAoKSA9PiBTdGF0ZTx1bmtub3duPjtcbiAgLyoqXG4gICAqIFNpbmdsZXRvbiB0byBtYWludGFpbiByZWZlcmVudGlhbCBlcXVhbGl0eSBiZXR3ZWVuIGNhbGxzXG4gICAqL1xuICBkZWNsYXJlIHJlYWRvbmx5IG1lbW86IFBpY2s8XG4gICAgTWVtb0NhY2hlLFxuICAgICdkZW5vcm1hbGl6ZScgfCAncXVlcnknIHwgJ2J1aWxkUXVlcnlLZXknXG4gID47XG5cbiAgLyoqXG4gICAqIEhhbmRsZXMgZ2FyYmFnZSBjb2xsZWN0aW9uXG4gICAqL1xuICBkZWNsYXJlIHJlYWRvbmx5IGdjUG9saWN5OiBHQ0ludGVyZmFjZTtcblxuICBjb25zdHJ1Y3Rvcih7XG4gICAgZGlzcGF0Y2ggPSB1bnNldERpc3BhdGNoIGFzIGFueSxcbiAgICBnZXRTdGF0ZSA9IHVuc2V0U3RhdGUsXG4gICAgbWVtbyA9IG5ldyBNZW1vQ2FjaGUoKSxcbiAgICBnY1BvbGljeSA9IG5ldyBJbW1vcnRhbEdDUG9saWN5KCksXG4gIH06IENvbnRyb2xsZXJDb25zdHJ1Y3RvclByb3BzPEQ+ID0ge30pIHtcbiAgICB0aGlzLl9kaXNwYXRjaCA9IGRpc3BhdGNoO1xuICAgIHRoaXMuZ2V0U3RhdGUgPSBnZXRTdGF0ZTtcbiAgICB0aGlzLm1lbW8gPSBtZW1vO1xuICAgIHRoaXMuZ2NQb2xpY3kgPSBnY1BvbGljeTtcbiAgfVxuXG4gIC8vIFRPRE86IGRyb3Agd2hlbiBkcm9wIHN1cHBvcnQgZm9yIGRlc3RydWN0dXJpbmcgKDAuMTQgYW5kIGJlbG93KVxuICBzZXQgZGlzcGF0Y2goZGlzcGF0Y2g6IEQpIHtcbiAgICAvKiBpc3RhbmJ1bCBpZ25vcmUgbmV4dCAqL1xuICAgIHRoaXMuX2Rpc3BhdGNoID0gZGlzcGF0Y2g7XG4gIH1cblxuICAvLyBUT0RPOiBkcm9wIHdoZW4gZHJvcCBzdXBwb3J0IGZvciBkZXN0cnVjdHVyaW5nICgwLjE0IGFuZCBiZWxvdylcbiAgZ2V0IGRpc3BhdGNoKCk6IEQge1xuICAgIHJldHVybiB0aGlzLl9kaXNwYXRjaDtcbiAgfVxuXG4gIGJpbmRNaWRkbGV3YXJlKHtcbiAgICBkaXNwYXRjaCxcbiAgICBnZXRTdGF0ZSxcbiAgfToge1xuICAgIGRpc3BhdGNoOiBEO1xuICAgIGdldFN0YXRlOiBSZWR1eE1pZGRsZXdhcmVBUElbJ2dldFN0YXRlJ107XG4gIH0pIHtcbiAgICB0aGlzLl9kaXNwYXRjaCA9IGRpc3BhdGNoO1xuICAgIHRoaXMuZ2V0U3RhdGUgPSBnZXRTdGF0ZTtcbiAgfVxuXG4gIC8qKioqKioqKioqKioqKiogQWN0aW9uIERpc3BhdGNoZXJzICoqKioqKioqKioqKioqKi9cblxuICAvKipcbiAgICogRmV0Y2hlcyB0aGUgZW5kcG9pbnQgd2l0aCBnaXZlbiBhcmdzLCB1cGRhdGluZyB0aGUgUmVhY3RpdmUgRGF0YSBDbGllbnQgY2FjaGUgd2l0aCB0aGUgcmVzcG9uc2Ugb3IgZXJyb3IgdXBvbiBjb21wbGV0aW9uLlxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI2ZldGNoXG4gICAqL1xuICBmZXRjaCA9IDxcbiAgICBFIGV4dGVuZHMgRW5kcG9pbnRJbnRlcmZhY2UgJiB7IHVwZGF0ZT86IEVuZHBvaW50VXBkYXRlRnVuY3Rpb248RT4gfSxcbiAgPihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5hcmdzOiByZWFkb25seSBbLi4uUGFyYW1ldGVyczxFPl1cbiAgKTogRVsnc2NoZW1hJ10gZXh0ZW5kcyB1bmRlZmluZWQgfCBudWxsID8gUmV0dXJuVHlwZTxFPlxuICA6IFByb21pc2U8RGVub3JtYWxpemU8RVsnc2NoZW1hJ10+PiA9PiB7XG4gICAgY29uc3QgYWN0aW9uID0gY3JlYXRlRmV0Y2goZW5kcG9pbnQsIHtcbiAgICAgIGFyZ3MsXG4gICAgfSk7XG4gICAgdGhpcy5kaXNwYXRjaChhY3Rpb24pO1xuXG4gICAgaWYgKGVuZHBvaW50LnNjaGVtYSkge1xuICAgICAgcmV0dXJuIGFjdGlvbi5tZXRhLnByb21pc2UudGhlbihpbnB1dCA9PlxuICAgICAgICBkZW5vcm1hbGl6ZShlbmRwb2ludC5zY2hlbWEsIGlucHV0LCB7fSwgYXJncyksXG4gICAgICApIGFzIGFueTtcbiAgICB9XG4gICAgcmV0dXJuIGFjdGlvbi5tZXRhLnByb21pc2UgYXMgYW55O1xuICB9O1xuXG4gIC8qKlxuICAgKiBGZXRjaGVzIG9ubHkgaWYgZW5kcG9pbnQgaXMgY29uc2lkZXJlZCAnc3RhbGUnOyBvdGhlcndpc2UgcmV0dXJucyB1bmRlZmluZWRcbiAgICogQHNlZSBodHRwczovL2RhdGFjbGllbnQuaW8vZG9jcy9hcGkvQ29udHJvbGxlciNmZXRjaElmU3RhbGVcbiAgICovXG4gIGZldGNoSWZTdGFsZSA9IDxcbiAgICBFIGV4dGVuZHMgRW5kcG9pbnRJbnRlcmZhY2UgJiB7IHVwZGF0ZT86IEVuZHBvaW50VXBkYXRlRnVuY3Rpb248RT4gfSxcbiAgPihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5hcmdzOiByZWFkb25seSBbLi4uUGFyYW1ldGVyczxFPl1cbiAgKTogRVsnc2NoZW1hJ10gZXh0ZW5kcyB1bmRlZmluZWQgfCBudWxsID8gUmV0dXJuVHlwZTxFPiB8IFJlc29sdmVUeXBlPEU+XG4gIDogUHJvbWlzZTxEZW5vcm1hbGl6ZTxFWydzY2hlbWEnXT4+IHwgRGVub3JtYWxpemU8RVsnc2NoZW1hJ10+ID0+IHtcbiAgICBjb25zdCB7IGRhdGEsIGV4cGlyZXNBdCwgZXhwaXJ5U3RhdHVzIH0gPSB0aGlzLmdldFJlc3BvbnNlTWV0YShcbiAgICAgIGVuZHBvaW50LFxuICAgICAgLi4uYXJncyxcbiAgICAgIHRoaXMuZ2V0U3RhdGUoKSxcbiAgICApO1xuICAgIGlmIChleHBpcnlTdGF0dXMgIT09IEV4cGlyeVN0YXR1cy5JbnZhbGlkICYmIERhdGUubm93KCkgPD0gZXhwaXJlc0F0KVxuICAgICAgcmV0dXJuIGRhdGEgYXMgYW55O1xuICAgIHJldHVybiB0aGlzLmZldGNoKGVuZHBvaW50LCAuLi5hcmdzKTtcbiAgfTtcblxuICAvKipcbiAgICogRm9yY2VzIHJlZmV0Y2hpbmcgYW5kIHN1c3BlbnNlIG9uIHVzZVN1c3BlbnNlIHdpdGggdGhlIHNhbWUgRW5kcG9pbnQgYW5kIHBhcmFtZXRlcnMuXG4gICAqIEBzZWUgaHR0cHM6Ly9kYXRhY2xpZW50LmlvL2RvY3MvYXBpL0NvbnRyb2xsZXIjaW52YWxpZGF0ZVxuICAgKi9cbiAgaW52YWxpZGF0ZSA9IDxFIGV4dGVuZHMgRW5kcG9pbnRJbnRlcmZhY2U+KFxuICAgIGVuZHBvaW50OiBFLFxuICAgIC4uLmFyZ3M6IHJlYWRvbmx5IFsuLi5QYXJhbWV0ZXJzPEU+XSB8IHJlYWRvbmx5IFtudWxsXVxuICApOiBQcm9taXNlPHZvaWQ+ID0+XG4gICAgYXJnc1swXSAhPT0gbnVsbCA/XG4gICAgICB0aGlzLmRpc3BhdGNoKFxuICAgICAgICBjcmVhdGVJbnZhbGlkYXRlKGVuZHBvaW50LCB7XG4gICAgICAgICAgYXJnczogYXJncyBhcyBQYXJhbWV0ZXJzPEU+LFxuICAgICAgICB9KSxcbiAgICAgIClcbiAgICA6IFByb21pc2UucmVzb2x2ZSgpO1xuXG4gIC8qKlxuICAgKiBGb3JjZXMgcmVmZXRjaGluZyBhbmQgc3VzcGVuc2Ugb24gdXNlU3VzcGVuc2Ugb24gYWxsIG1hdGNoaW5nIGVuZHBvaW50IHJlc3VsdCBrZXlzLlxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI2ludmFsaWRhdGVBbGxcbiAgICogQHJldHVybnMgUHJvbWlzZSB0aGF0IHJlc29sdmVzIHdoZW4gaW52YWxpZGF0aW9uIGlzIGNvbW1pdGVkLlxuICAgKi9cbiAgaW52YWxpZGF0ZUFsbCA9IChvcHRpb25zOiB7IHRlc3RLZXk6IChrZXk6IHN0cmluZykgPT4gYm9vbGVhbiB9KSA9PlxuICAgIHRoaXMuZGlzcGF0Y2goY3JlYXRlSW52YWxpZGF0ZUFsbCgoa2V5OiBzdHJpbmcpID0+IG9wdGlvbnMudGVzdEtleShrZXkpKSk7XG5cbiAgLyoqXG4gICAqIFNldHMgYWxsIG1hdGNoaW5nIGVuZHBvaW50IHJlc3VsdCBrZXlzIHRvIGJlIFNUQUxFLlxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI2V4cGlyZUFsbFxuICAgKiBAcmV0dXJucyBQcm9taXNlIHRoYXQgcmVzb2x2ZXMgd2hlbiBleHBpcnkgaXMgY29tbWl0ZWQuICpOT1QqIGZldGNoIHByb21pc2VcbiAgICovXG4gIGV4cGlyZUFsbCA9IChvcHRpb25zOiB7IHRlc3RLZXk6IChrZXk6IHN0cmluZykgPT4gYm9vbGVhbiB9KSA9PlxuICAgIHRoaXMuZGlzcGF0Y2goY3JlYXRlRXhwaXJlQWxsKChrZXk6IHN0cmluZykgPT4gb3B0aW9ucy50ZXN0S2V5KGtleSkpKTtcblxuICAvKipcbiAgICogUmVzZXRzIHRoZSBlbnRpcmUgUmVhY3RpdmUgRGF0YSBDbGllbnQgY2FjaGUuIEFsbCBpbmZsaWdodCByZXF1ZXN0cyB3aWxsIG5vdCByZXNvbHZlLlxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI3Jlc2V0RW50aXJlU3RvcmVcbiAgICovXG4gIHJlc2V0RW50aXJlU3RvcmUgPSAoKTogUHJvbWlzZTx2b2lkPiA9PiB0aGlzLmRpc3BhdGNoKGNyZWF0ZVJlc2V0KCkpO1xuXG4gIC8qKlxuICAgKiBTZXRzIHZhbHVlIGZvciB0aGUgUXVlcnlhYmxlIGFuZCBhcmdzLlxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI3NldFxuICAgKi9cbiAgc2V0PFMgZXh0ZW5kcyBRdWVyeWFibGU+KFxuICAgIHNjaGVtYTogUyxcbiAgICAuLi5yZXN0OiByZWFkb25seSBbLi4uU2NoZW1hQXJnczxTPiwgKHByZXZpb3VzVmFsdWU6IERlbm9ybWFsaXplPFM+KSA9PiB7fV1cbiAgKTogUHJvbWlzZTx2b2lkPjtcblxuICBzZXQ8UyBleHRlbmRzIFF1ZXJ5YWJsZT4oXG4gICAgc2NoZW1hOiBTLFxuICAgIC4uLnJlc3Q6IHJlYWRvbmx5IFsuLi5TY2hlbWFBcmdzPFM+LCB7fV1cbiAgKTogUHJvbWlzZTx2b2lkPjtcblxuICBzZXQ8UyBleHRlbmRzIFF1ZXJ5YWJsZT4oXG4gICAgc2NoZW1hOiBTLFxuICAgIC4uLnJlc3Q6IHJlYWRvbmx5IFsuLi5TY2hlbWFBcmdzPFM+LCBhbnldXG4gICk6IFByb21pc2U8dm9pZD4ge1xuICAgIGNvbnN0IHZhbHVlID0gcmVzdFtyZXN0Lmxlbmd0aCAtIDFdO1xuICAgIGNvbnN0IGFjdGlvbiA9IGNyZWF0ZVNldChzY2hlbWEsIHtcbiAgICAgIGFyZ3M6IHJlc3Quc2xpY2UoMCwgcmVzdC5sZW5ndGggLSAxKSBhcyBTY2hlbWFBcmdzPFM+LFxuICAgICAgdmFsdWUsXG4gICAgfSk7XG4gICAgLy8gVE9ETzogcmVqZWN0IHdpdGggZXJyb3IgaWYgdGhpcyBmYWlscyBpbiByZWR1Y2VyXG4gICAgcmV0dXJuIHRoaXMuZGlzcGF0Y2goYWN0aW9uKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBTZXRzIHJlc3BvbnNlIGZvciB0aGUgRW5kcG9pbnQgYW5kIGFyZ3MuXG4gICAqIEBzZWUgaHR0cHM6Ly9kYXRhY2xpZW50LmlvL2RvY3MvYXBpL0NvbnRyb2xsZXIjc2V0UmVzcG9uc2VcbiAgICovXG4gIHNldFJlc3BvbnNlID0gPFxuICAgIEUgZXh0ZW5kcyBFbmRwb2ludEludGVyZmFjZSAmIHtcbiAgICAgIHVwZGF0ZT86IEVuZHBvaW50VXBkYXRlRnVuY3Rpb248RT47XG4gICAgfSxcbiAgPihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5yZXN0OiByZWFkb25seSBbLi4uUGFyYW1ldGVyczxFPiwgYW55XVxuICApOiBQcm9taXNlPHZvaWQ+ID0+IHtcbiAgICBjb25zdCByZXNwb25zZTogUmVzb2x2ZVR5cGU8RT4gPSByZXN0W3Jlc3QubGVuZ3RoIC0gMV07XG4gICAgY29uc3QgYWN0aW9uID0gY3JlYXRlU2V0UmVzcG9uc2UoZW5kcG9pbnQsIHtcbiAgICAgIGFyZ3M6IHJlc3Quc2xpY2UoMCwgcmVzdC5sZW5ndGggLSAxKSBhcyBQYXJhbWV0ZXJzPEU+LFxuICAgICAgcmVzcG9uc2UsXG4gICAgfSk7XG4gICAgcmV0dXJuIHRoaXMuZGlzcGF0Y2goYWN0aW9uKTtcbiAgfTtcblxuICAvKipcbiAgICogU2V0cyBhbiBlcnJvciByZXNwb25zZSBmb3IgdGhlIEVuZHBvaW50IGFuZCBhcmdzLlxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI3NldEVycm9yXG4gICAqL1xuICBzZXRFcnJvciA9IDxcbiAgICBFIGV4dGVuZHMgRW5kcG9pbnRJbnRlcmZhY2UgJiB7XG4gICAgICB1cGRhdGU/OiBFbmRwb2ludFVwZGF0ZUZ1bmN0aW9uPEU+O1xuICAgIH0sXG4gID4oXG4gICAgZW5kcG9pbnQ6IEUsXG4gICAgLi4ucmVzdDogcmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RT4sIEVycm9yXVxuICApOiBQcm9taXNlPHZvaWQ+ID0+IHtcbiAgICBjb25zdCByZXNwb25zZTogRXJyb3IgPSByZXN0W3Jlc3QubGVuZ3RoIC0gMV07XG4gICAgY29uc3QgYWN0aW9uID0gY3JlYXRlU2V0UmVzcG9uc2UoZW5kcG9pbnQsIHtcbiAgICAgIGFyZ3M6IHJlc3Quc2xpY2UoMCwgcmVzdC5sZW5ndGggLSAxKSBhcyBQYXJhbWV0ZXJzPEU+LFxuICAgICAgcmVzcG9uc2UsXG4gICAgICBlcnJvcjogdHJ1ZSxcbiAgICB9KTtcbiAgICByZXR1cm4gdGhpcy5kaXNwYXRjaChhY3Rpb24pO1xuICB9O1xuXG4gIC8qKlxuICAgKiBSZXNvbHZlcyBhbiBpbmZsaWdodCBmZXRjaC5cbiAgICogQHNlZSBodHRwczovL2RhdGFjbGllbnQuaW8vZG9jcy9hcGkvQ29udHJvbGxlciNyZXNvbHZlXG4gICAqL1xuICByZXNvbHZlID0gPFxuICAgIEUgZXh0ZW5kcyBFbmRwb2ludEludGVyZmFjZSAmIHtcbiAgICAgIHVwZGF0ZT86IEVuZHBvaW50VXBkYXRlRnVuY3Rpb248RT47XG4gICAgfSxcbiAgPihcbiAgICBlbmRwb2ludDogRSxcbiAgICBtZXRhOlxuICAgICAgfCB7XG4gICAgICAgICAgYXJnczogcmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RT5dO1xuICAgICAgICAgIHJlc3BvbnNlOiBFcnJvcjtcbiAgICAgICAgICBmZXRjaGVkQXQ6IG51bWJlcjtcbiAgICAgICAgICBlcnJvcjogdHJ1ZTtcbiAgICAgICAgfVxuICAgICAgfCB7XG4gICAgICAgICAgYXJnczogcmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RT5dO1xuICAgICAgICAgIHJlc3BvbnNlOiBhbnk7XG4gICAgICAgICAgZmV0Y2hlZEF0OiBudW1iZXI7XG4gICAgICAgICAgZXJyb3I/OiBmYWxzZSB8IHVuZGVmaW5lZDtcbiAgICAgICAgfSxcbiAgKTogUHJvbWlzZTx2b2lkPiA9PiB7XG4gICAgcmV0dXJuIHRoaXMuZGlzcGF0Y2goY3JlYXRlU2V0UmVzcG9uc2UoZW5kcG9pbnQsIG1ldGEgYXMgYW55KSk7XG4gIH07XG5cbiAgLyoqXG4gICAqIE1hcmtzIGEgbmV3IHN1YnNjcmlwdGlvbiB0byBhIGdpdmVuIEVuZHBvaW50LlxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI3N1YnNjcmliZVxuICAgKi9cbiAgc3Vic2NyaWJlID0gPFxuICAgIEUgZXh0ZW5kcyBFbmRwb2ludEludGVyZmFjZTxcbiAgICAgIEZldGNoRnVuY3Rpb24sXG4gICAgICBTY2hlbWEgfCB1bmRlZmluZWQsXG4gICAgICB1bmRlZmluZWQgfCBmYWxzZVxuICAgID4sXG4gID4oXG4gICAgZW5kcG9pbnQ6IEUsXG4gICAgLi4uYXJnczogcmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RT5dIHwgcmVhZG9ubHkgW251bGxdXG4gICk6IFByb21pc2U8dm9pZD4gPT5cbiAgICBhcmdzWzBdICE9PSBudWxsID9cbiAgICAgIHRoaXMuZGlzcGF0Y2goXG4gICAgICAgIGNyZWF0ZVN1YnNjcmlwdGlvbihlbmRwb2ludCwge1xuICAgICAgICAgIGFyZ3M6IGFyZ3MgYXMgUGFyYW1ldGVyczxFPixcbiAgICAgICAgfSksXG4gICAgICApXG4gICAgOiBQcm9taXNlLnJlc29sdmUoKTtcblxuICAvKipcbiAgICogTWFya3MgY29tcGxldGlvbiBvZiBzdWJzY3JpcHRpb24gdG8gYSBnaXZlbiBFbmRwb2ludC5cbiAgICogQHNlZSBodHRwczovL2RhdGFjbGllbnQuaW8vZG9jcy9hcGkvQ29udHJvbGxlciN1bnN1YnNjcmliZVxuICAgKi9cbiAgdW5zdWJzY3JpYmUgPSA8XG4gICAgRSBleHRlbmRzIEVuZHBvaW50SW50ZXJmYWNlPFxuICAgICAgRmV0Y2hGdW5jdGlvbixcbiAgICAgIFNjaGVtYSB8IHVuZGVmaW5lZCxcbiAgICAgIHVuZGVmaW5lZCB8IGZhbHNlXG4gICAgPixcbiAgPihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5hcmdzOiByZWFkb25seSBbLi4uUGFyYW1ldGVyczxFPl0gfCByZWFkb25seSBbbnVsbF1cbiAgKTogUHJvbWlzZTx2b2lkPiA9PlxuICAgIGFyZ3NbMF0gIT09IG51bGwgP1xuICAgICAgdGhpcy5kaXNwYXRjaChcbiAgICAgICAgY3JlYXRlVW5zdWJzY3JpcHRpb24oZW5kcG9pbnQsIHtcbiAgICAgICAgICBhcmdzOiBhcmdzIGFzIFBhcmFtZXRlcnM8RT4sXG4gICAgICAgIH0pLFxuICAgICAgKVxuICAgIDogUHJvbWlzZS5yZXNvbHZlKCk7XG5cbiAgLyoqKioqKioqKioqKioqKiBNb3JlICoqKioqKioqKioqKioqKi9cblxuICAvKiBUT0RPOlxuICBhYm9ydCA9IDxFIGV4dGVuZHMgRW5kcG9pbnRJbnRlcmZhY2U+KFxuICAgIGVuZHBvaW50OiBFLFxuICAgIC4uLmFyZ3M6IHJlYWRvbmx5IFsuLi5QYXJhbWV0ZXJzPEU+XVxuICApOiBQcm9taXNlPHZvaWQ+XG4gICovXG5cbiAgLyoqXG4gICAqIEdldHMgYSBzbmFwc2hvdCAoaHR0cHM6Ly9kYXRhY2xpZW50LmlvL2RvY3MvYXBpL1NuYXBzaG90KVxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI3NuYXBzaG90XG4gICAqL1xuICBzbmFwc2hvdCA9IChzdGF0ZTogU3RhdGU8dW5rbm93bj4sIGZldGNoZWRBdD86IG51bWJlcik6IFNuYXBzaG90PHVua25vd24+ID0+IHtcbiAgICByZXR1cm4gbmV3IFNuYXBzaG90KHRoaXMsIHN0YXRlLCBmZXRjaGVkQXQpO1xuICB9O1xuXG4gIC8qKlxuICAgKiBHZXRzIHRoZSBlcnJvciwgaWYgYW55LCBmb3IgYSBnaXZlbiBlbmRwb2ludC4gUmV0dXJucyB1bmRlZmluZWQgZm9yIG5vIGVycm9ycy5cbiAgICogQHNlZSBodHRwczovL2RhdGFjbGllbnQuaW8vZG9jcy9hcGkvQ29udHJvbGxlciNnZXRFcnJvclxuICAgKi9cbiAgZ2V0RXJyb3I8RSBleHRlbmRzIEVuZHBvaW50SW50ZXJmYWNlPihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5yZXN0OlxuICAgICAgfCByZWFkb25seSBbbnVsbCwgU3RhdGU8dW5rbm93bj5dXG4gICAgICB8IHJlYWRvbmx5IFsuLi5QYXJhbWV0ZXJzPEU+LCBTdGF0ZTx1bmtub3duPl1cbiAgKTogRXJyb3JUeXBlcyB8IHVuZGVmaW5lZDtcblxuICBnZXRFcnJvcjxFIGV4dGVuZHMgUGljazxFbmRwb2ludEludGVyZmFjZSwgJ2tleSc+PihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5yZXN0OlxuICAgICAgfCByZWFkb25seSBbbnVsbCwgU3RhdGU8dW5rbm93bj5dXG4gICAgICB8IHJlYWRvbmx5IFsuLi5QYXJhbWV0ZXJzPEVbJ2tleSddPiwgU3RhdGU8dW5rbm93bj5dXG4gICk6IEVycm9yVHlwZXMgfCB1bmRlZmluZWQ7XG5cbiAgZ2V0RXJyb3IoXG4gICAgZW5kcG9pbnQ6IEVuZHBvaW50SW50ZXJmYWNlLFxuICAgIC4uLnJlc3Q6IHJlYWRvbmx5IFsuLi51bmtub3duW10sIFN0YXRlPHVua25vd24+XVxuICApOiBFcnJvclR5cGVzIHwgdW5kZWZpbmVkIHtcbiAgICBpZiAocmVzdFswXSA9PT0gbnVsbCkgcmV0dXJuO1xuICAgIGNvbnN0IHN0YXRlID0gcmVzdFtyZXN0Lmxlbmd0aCAtIDFdIGFzIFN0YXRlPHVua25vd24+O1xuICAgIC8vIHRoaXMgaXMgdHlwZXNjcmlwdCBnZW5lcmljcyBicmVha2luZ1xuICAgIGNvbnN0IGFyZ3M6IGFueSA9IHJlc3Quc2xpY2UoMCwgcmVzdC5sZW5ndGggLSAxKTtcbiAgICBjb25zdCBrZXkgPSBlbmRwb2ludC5rZXkoLi4uYXJncyk7XG5cbiAgICBjb25zdCBtZXRhID0gc2VsZWN0TWV0YShzdGF0ZSwga2V5KTtcbiAgICBjb25zdCBlcnJvciA9IHN0YXRlLmVuZHBvaW50c1trZXldO1xuXG4gICAgaWYgKGVycm9yICE9PSB1bmRlZmluZWQgJiYgbWV0YT8uZXJyb3JQb2xpY3kgPT09ICdzb2Z0JykgcmV0dXJuO1xuXG4gICAgcmV0dXJuIG1ldGE/LmVycm9yIGFzIGFueTtcbiAgfVxuXG4gIC8qKlxuICAgKiBHZXRzIHRoZSAoZ2xvYmFsbHkgcmVmZXJlbnRpYWxseSBzdGFibGUpIHJlc3BvbnNlIGZvciBhIGdpdmVuIGVuZHBvaW50L2FyZ3MgcGFpciBmcm9tIHN0YXRlIGdpdmVuLlxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI2dldFJlc3BvbnNlXG4gICAqL1xuICBnZXRSZXNwb25zZTxFIGV4dGVuZHMgRW5kcG9pbnRJbnRlcmZhY2U+KFxuICAgIGVuZHBvaW50OiBFLFxuICAgIC4uLnJlc3Q6XG4gICAgICB8IHJlYWRvbmx5IFtudWxsLCBTdGF0ZTx1bmtub3duPl1cbiAgICAgIHwgcmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RT4sIFN0YXRlPHVua25vd24+XVxuICApOiB7XG4gICAgZGF0YTogRGVub3JtYWxpemVOdWxsYWJsZTxFWydzY2hlbWEnXT47XG4gICAgZXhwaXJ5U3RhdHVzOiBFeHBpcnlTdGF0dXM7XG4gICAgZXhwaXJlc0F0OiBudW1iZXI7XG4gICAgY291bnRSZWY6ICgpID0+ICgpID0+IHZvaWQ7XG4gIH07XG5cbiAgZ2V0UmVzcG9uc2U8XG4gICAgRSBleHRlbmRzIFBpY2s8RW5kcG9pbnRJbnRlcmZhY2UsICdrZXknIHwgJ3NjaGVtYScgfCAnaW52YWxpZElmU3RhbGUnPixcbiAgPihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5yZXN0OiByZWFkb25seSBbXG4gICAgICAuLi4ocmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RVsna2V5J10+XSB8IHJlYWRvbmx5IFtudWxsXSksXG4gICAgICBTdGF0ZTx1bmtub3duPixcbiAgICBdXG4gICk6IHtcbiAgICBkYXRhOiBEZW5vcm1hbGl6ZU51bGxhYmxlPEVbJ3NjaGVtYSddPjtcbiAgICBleHBpcnlTdGF0dXM6IEV4cGlyeVN0YXR1cztcbiAgICBleHBpcmVzQXQ6IG51bWJlcjtcbiAgICBjb3VudFJlZjogKCkgPT4gKCkgPT4gdm9pZDtcbiAgfTtcblxuICBnZXRSZXNwb25zZShcbiAgICBlbmRwb2ludDogRW5kcG9pbnRJbnRlcmZhY2UsXG4gICAgLi4ucmVzdDogcmVhZG9ubHkgWy4uLnVua25vd25bXSwgU3RhdGU8dW5rbm93bj5dXG4gICk6IHtcbiAgICBkYXRhOiB1bmtub3duO1xuICAgIGV4cGlyeVN0YXR1czogRXhwaXJ5U3RhdHVzO1xuICAgIGV4cGlyZXNBdDogbnVtYmVyO1xuICAgIGNvdW50UmVmOiAoKSA9PiAoKSA9PiB2b2lkO1xuICB9IHtcbiAgICAvLyBUT0RPOiBicmVha2luZzogb25seSByZXR1cm4gZGF0YVxuICAgIHJldHVybiB0aGlzLmdldFJlc3BvbnNlTWV0YShlbmRwb2ludCwgLi4ucmVzdCk7XG4gIH1cblxuICAvKipcbiAgICogR2V0cyB0aGUgKGdsb2JhbGx5IHJlZmVyZW50aWFsbHkgc3RhYmxlKSByZXNwb25zZSBmb3IgYSBnaXZlbiBlbmRwb2ludC9hcmdzIHBhaXIgZnJvbSBzdGF0ZSBnaXZlbi5cbiAgICogQHNlZSBodHRwczovL2RhdGFjbGllbnQuaW8vZG9jcy9hcGkvQ29udHJvbGxlciNnZXRSZXNwb25zZU1ldGFcbiAgICovXG4gIGdldFJlc3BvbnNlTWV0YTxFIGV4dGVuZHMgRW5kcG9pbnRJbnRlcmZhY2U+KFxuICAgIGVuZHBvaW50OiBFLFxuICAgIC4uLnJlc3Q6XG4gICAgICB8IHJlYWRvbmx5IFtudWxsLCBTdGF0ZTx1bmtub3duPl1cbiAgICAgIHwgcmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RT4sIFN0YXRlPHVua25vd24+XVxuICApOiB7XG4gICAgZGF0YTogRGVub3JtYWxpemVOdWxsYWJsZTxFWydzY2hlbWEnXT47XG4gICAgZXhwaXJ5U3RhdHVzOiBFeHBpcnlTdGF0dXM7XG4gICAgZXhwaXJlc0F0OiBudW1iZXI7XG4gICAgY291bnRSZWY6ICgpID0+ICgpID0+IHZvaWQ7XG4gIH07XG5cbiAgZ2V0UmVzcG9uc2VNZXRhPFxuICAgIEUgZXh0ZW5kcyBQaWNrPEVuZHBvaW50SW50ZXJmYWNlLCAna2V5JyB8ICdzY2hlbWEnIHwgJ2ludmFsaWRJZlN0YWxlJz4sXG4gID4oXG4gICAgZW5kcG9pbnQ6IEUsXG4gICAgLi4ucmVzdDogcmVhZG9ubHkgW1xuICAgICAgLi4uKHJlYWRvbmx5IFsuLi5QYXJhbWV0ZXJzPEVbJ2tleSddPl0gfCByZWFkb25seSBbbnVsbF0pLFxuICAgICAgU3RhdGU8dW5rbm93bj4sXG4gICAgXVxuICApOiB7XG4gICAgZGF0YTogRGVub3JtYWxpemVOdWxsYWJsZTxFWydzY2hlbWEnXT47XG4gICAgZXhwaXJ5U3RhdHVzOiBFeHBpcnlTdGF0dXM7XG4gICAgZXhwaXJlc0F0OiBudW1iZXI7XG4gICAgY291bnRSZWY6ICgpID0+ICgpID0+IHZvaWQ7XG4gIH07XG5cbiAgZ2V0UmVzcG9uc2VNZXRhKFxuICAgIGVuZHBvaW50OiBFbmRwb2ludEludGVyZmFjZSxcbiAgICAuLi5yZXN0OiByZWFkb25seSBbLi4udW5rbm93bltdLCBTdGF0ZTx1bmtub3duPl1cbiAgKToge1xuICAgIGRhdGE6IHVua25vd247XG4gICAgZXhwaXJ5U3RhdHVzOiBFeHBpcnlTdGF0dXM7XG4gICAgZXhwaXJlc0F0OiBudW1iZXI7XG4gICAgY291bnRSZWY6ICgpID0+ICgpID0+IHZvaWQ7XG4gIH0ge1xuICAgIGNvbnN0IFtzdGF0ZSwgYXJnc10gPSBleHRyYWN0U3RhdGVBbmRBcmdzKHJlc3QpO1xuICAgIGNvbnN0IGlzQWN0aXZlID0gYXJncy5sZW5ndGggIT09IDEgfHwgYXJnc1swXSAhPT0gbnVsbDtcbiAgICBjb25zdCBrZXkgPSBpc0FjdGl2ZSA/IGVuZHBvaW50LmtleSguLi5hcmdzKSA6ICcnO1xuICAgIGNvbnN0IGNhY2hlRW5kcG9pbnRzID0gaXNBY3RpdmUgPyBzdGF0ZS5lbmRwb2ludHNba2V5XSA6IHVuZGVmaW5lZDtcbiAgICBjb25zdCBzY2hlbWEgPSBlbmRwb2ludC5zY2hlbWE7XG4gICAgY29uc3QgbWV0YSA9IHNlbGVjdE1ldGEoc3RhdGUsIGtleSk7XG4gICAgbGV0IGV4cGlyZXNBdCA9IG1ldGE/LmV4cGlyZXNBdDtcbiAgICAvLyBpZiB3ZSBoYXZlIG5vIGVuZHBvaW50IGVudHJ5LCBhbmQgb3VyIGVuZHBvaW50IGhhcyBhIHNjaGVtYSAtIHRyeSBxdWVyeWluZyB0aGUgc3RvcmVcbiAgICBjb25zdCBzaG91bGRRdWVyeSA9IGNhY2hlRW5kcG9pbnRzID09PSB1bmRlZmluZWQgJiYgc2NoZW1hICE9PSB1bmRlZmluZWQ7XG5cbiAgICBjb25zdCBpbnB1dCA9XG4gICAgICBzaG91bGRRdWVyeSA/XG4gICAgICAgIC8vIG5vdGhpbmcgaW4gZW5kcG9pbnRzIGNhY2hlLCBzbyB0cnkgcXVlcnlpbmcgaWYgd2UgaGF2ZSBhIHNjaGVtYSB0byBkbyBzb1xuICAgICAgICB0aGlzLm1lbW8uYnVpbGRRdWVyeUtleShzY2hlbWEsIGFyZ3MsIHN0YXRlLCBrZXkpXG4gICAgICA6IGNhY2hlRW5kcG9pbnRzO1xuXG4gICAgaWYgKCFpc0FjdGl2ZSkge1xuICAgICAgLy8gd2hlbiBub3QgYWN0aXZlIHNpbXBseSByZXR1cm4gdGhlIHF1ZXJ5IGlucHV0IHdpdGhvdXQgZGVub3JtYWxpemluZ1xuICAgICAgcmV0dXJuIHtcbiAgICAgICAgZGF0YTogaW5wdXQgYXMgYW55LFxuICAgICAgICBleHBpcnlTdGF0dXM6IEV4cGlyeVN0YXR1cy5WYWxpZCxcbiAgICAgICAgZXhwaXJlc0F0OiBJbmZpbml0eSxcbiAgICAgICAgY291bnRSZWY6ICgpID0+ICgpID0+IHVuZGVmaW5lZCxcbiAgICAgIH07XG4gICAgfVxuXG4gICAgbGV0IGlzSW52YWxpZCA9IGZhbHNlO1xuICAgIGlmIChzaG91bGRRdWVyeSkge1xuICAgICAgaXNJbnZhbGlkID0gIXZhbGlkYXRlUXVlcnlLZXkoaW5wdXQpO1xuICAgICAgLy8gZW5kcG9pbnQgd2l0aG91dCBlbnRpdGllc1xuICAgIH0gZWxzZSBpZiAoIXNjaGVtYSB8fCAhcmVxdWlyZXNEZW5vcm1hbGl6ZShzY2hlbWEpKSB7XG4gICAgICByZXR1cm4ge1xuICAgICAgICBkYXRhOiBjYWNoZUVuZHBvaW50cyxcbiAgICAgICAgZXhwaXJ5U3RhdHVzOiB0aGlzLmdldEV4cGlyeVN0YXR1cyhcbiAgICAgICAgICBjYWNoZUVuZHBvaW50cyA9PT0gdW5kZWZpbmVkLFxuICAgICAgICAgICEhZW5kcG9pbnQuaW52YWxpZElmU3RhbGUsXG4gICAgICAgICAgbWV0YSxcbiAgICAgICAgKSxcbiAgICAgICAgZXhwaXJlc0F0OiBleHBpcmVzQXQgfHwgMCxcbiAgICAgICAgY291bnRSZWY6IHRoaXMuZ2NQb2xpY3kuY3JlYXRlQ291bnRSZWYoeyBrZXkgfSksXG4gICAgICB9O1xuICAgIH1cblxuICAgIGNvbnN0IHsgZGF0YSwgcGF0aHMgfSA9IHRoaXMubWVtby5kZW5vcm1hbGl6ZShcbiAgICAgIHNjaGVtYSxcbiAgICAgIGlucHV0LFxuICAgICAgc3RhdGUuZW50aXRpZXMsXG4gICAgICBhcmdzLFxuICAgICkgYXMgeyBkYXRhOiBhbnk7IHBhdGhzOiBFbnRpdHlQYXRoW10gfTtcblxuICAgIGlmICghZXhwaXJlc0F0KSB7XG4gICAgICAvLyBub3RlOiBpc0ludmFsaWQgY2FuIG9ubHkgYmUgdHJ1ZSBpZiBzaG91bGRRdWVyeSBpcyB0cnVlXG4gICAgICBpZiAoaXNJbnZhbGlkKSBleHBpcmVzQXQgPSAxO1xuICAgICAgLy8gZmFsbGJhY2sgdG8gZW50aXR5IGV4cGlyeSB0aW1lXG4gICAgICBlbHNlIGV4cGlyZXNBdCA9IGVudGl0eUV4cGlyZXNBdChwYXRocywgc3RhdGUuZW50aXRpZXNNZXRhKTtcbiAgICB9XG5cbiAgICByZXR1cm4ge1xuICAgICAgZGF0YSxcbiAgICAgIGV4cGlyeVN0YXR1czogdGhpcy5nZXRFeHBpcnlTdGF0dXMoXG4gICAgICAgIHR5cGVvZiBkYXRhID09PSAnc3ltYm9sJyxcbiAgICAgICAgISFlbmRwb2ludC5pbnZhbGlkSWZTdGFsZSB8fCBpc0ludmFsaWQsXG4gICAgICAgIG1ldGEsXG4gICAgICApLFxuICAgICAgZXhwaXJlc0F0LFxuICAgICAgY291bnRSZWY6IHRoaXMuZ2NQb2xpY3kuY3JlYXRlQ291bnRSZWYoeyBrZXksIHBhdGhzIH0pLFxuICAgIH07XG4gIH1cblxuICAvKipcbiAgICogUXVlcmllcyB0aGUgc3RvcmUgZm9yIGEgUXVlcmFibGUgc2NoZW1hXG4gICAqIEBzZWUgaHR0cHM6Ly9kYXRhY2xpZW50LmlvL2RvY3MvYXBpL0NvbnRyb2xsZXIjZ2V0XG4gICAqL1xuICBnZXQ8UyBleHRlbmRzIFF1ZXJ5YWJsZT4oXG4gICAgc2NoZW1hOiBTLFxuICAgIC4uLnJlc3Q6IHJlYWRvbmx5IFtcbiAgICAgIC4uLlNjaGVtYUFyZ3M8Uz4sXG4gICAgICBQaWNrPFN0YXRlPHVua25vd24+LCAnZW50aXRpZXMnIHwgJ2luZGV4ZXMnPixcbiAgICBdXG4gICk6IERlbm9ybWFsaXplTnVsbGFibGU8Uz4gfCB1bmRlZmluZWQge1xuICAgIGNvbnN0IFtzdGF0ZSwgYXJnc10gPSBleHRyYWN0U3RhdGVBbmRBcmdzKHJlc3QpO1xuXG4gICAgY29uc3QgeyBkYXRhIH0gPSB0aGlzLm1lbW8ucXVlcnkoc2NoZW1hLCBhcmdzLCBzdGF0ZSk7XG4gICAgcmV0dXJuIHR5cGVvZiBkYXRhID09PSAnc3ltYm9sJyA/IHVuZGVmaW5lZCA6IGRhdGE7XG4gIH1cblxuICAvKipcbiAgICogUXVlcmllcyB0aGUgc3RvcmUgZm9yIGEgUXVlcmFibGUgc2NoZW1hOyBwcm92aWRpbmcgcmVsYXRlZCBtZXRhZGF0YVxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9Db250cm9sbGVyI2dldFF1ZXJ5TWV0YVxuICAgKi9cbiAgZ2V0UXVlcnlNZXRhPFMgZXh0ZW5kcyBRdWVyeWFibGU+KFxuICAgIHNjaGVtYTogUyxcbiAgICAuLi5yZXN0OiByZWFkb25seSBbXG4gICAgICAuLi5TY2hlbWFBcmdzPFM+LFxuICAgICAgUGljazxTdGF0ZTx1bmtub3duPiwgJ2VudGl0aWVzJyB8ICdpbmRleGVzJz4sXG4gICAgXVxuICApOiB7XG4gICAgZGF0YTogRGVub3JtYWxpemVOdWxsYWJsZTxTPiB8IHVuZGVmaW5lZDtcbiAgICBjb3VudFJlZjogKCkgPT4gKCkgPT4gdm9pZDtcbiAgfSB7XG4gICAgY29uc3QgW3N0YXRlLCBhcmdzXSA9IGV4dHJhY3RTdGF0ZUFuZEFyZ3MocmVzdCk7XG5cbiAgICBjb25zdCB7IGRhdGEsIHBhdGhzIH0gPSB0aGlzLm1lbW8ucXVlcnkoc2NoZW1hLCBhcmdzLCBzdGF0ZSk7XG5cbiAgICByZXR1cm4ge1xuICAgICAgZGF0YTogdHlwZW9mIGRhdGEgPT09ICdzeW1ib2wnID8gdW5kZWZpbmVkIDogZGF0YSxcbiAgICAgIGNvdW50UmVmOiB0aGlzLmdjUG9saWN5LmNyZWF0ZUNvdW50UmVmKHsgcGF0aHMgfSksXG4gICAgfTtcbiAgfVxuXG4gIHByaXZhdGUgZ2V0RXhwaXJ5U3RhdHVzKFxuICAgIGludmFsaWREYXRhOiBib29sZWFuLFxuICAgIGludmFsaWRJZlN0YWxlOiBib29sZWFuLFxuICAgIG1ldGE6IHsgZXJyb3I/OiB1bmtub3duOyBpbnZhbGlkYXRlZD86IHVua25vd24gfSA9IHt9LFxuICApIHtcbiAgICAvLyBodHRwczovL2RhdGFjbGllbnQuaW8vZG9jcy9jb25jZXB0cy9leHBpcnktcG9saWN5I2V4cGlyeS1zdGF0dXNcbiAgICAvLyB3ZSBkb24ndCB0cmFjayB0aGUgZGlmZmVyZW5jZSBiZXR3ZWVuIHN0YWxlIG9yIGZyZXNoIGJlY2F1c2UgdGhhdCBpcyB0aWVkIHRvIHRyaWdnZXJpbmdcbiAgICAvLyBjb25kaXRpb25zXG4gICAgcmV0dXJuIChcbiAgICAgIG1ldGEuaW52YWxpZGF0ZWQgfHwgKGludmFsaWREYXRhICYmICFtZXRhLmVycm9yKSA/IEV4cGlyeVN0YXR1cy5JbnZhbGlkXG4gICAgICA6IGludmFsaWREYXRhIHx8IGludmFsaWRJZlN0YWxlID8gRXhwaXJ5U3RhdHVzLkludmFsaWRJZlN0YWxlXG4gICAgICA6IEV4cGlyeVN0YXR1cy5WYWxpZFxuICAgICk7XG4gIH1cbn1cblxuLy8gYmVuY2htYXJrOiBodHRwczovL3d3dy5tZWFzdXJldGhhdC5uZXQvQmVuY2htYXJrcy9TaG93LzI0NjkxLzAvbWluLXJlZHVjZXItdnMtaW1wZXJhdGl2ZS13aXRoLXBhdGhzXG4vLyBlYXJsaWVzdCBleHBpcnkgZGljdGF0ZXMgYWdlXG5mdW5jdGlvbiBlbnRpdHlFeHBpcmVzQXQoXG4gIHBhdGhzOiBFbnRpdHlQYXRoW10sXG4gIGVudGl0aWVzTWV0YToge1xuICAgIHJlYWRvbmx5IFtlbnRpdHlLZXk6IHN0cmluZ106IHtcbiAgICAgIHJlYWRvbmx5IFtwazogc3RyaW5nXToge1xuICAgICAgICByZWFkb25seSBkYXRlOiBudW1iZXI7XG4gICAgICAgIHJlYWRvbmx5IGV4cGlyZXNBdDogbnVtYmVyO1xuICAgICAgICByZWFkb25seSBmZXRjaGVkQXQ6IG51bWJlcjsgLy8gVGhpcyBpcyBvbmx5IHRoZSB2YWx1ZSB1bnRpbCBpdCBpcyBzZXQgYnkgdGhlIERhdGFQcm92aWRlclxuICAgICAgfTtcbiAgICB9O1xuICB9LFxuKSB7XG4gIGxldCBleHBpcmVzQXQgPSBJbmZpbml0eTtcbiAgZm9yIChjb25zdCB7IGtleSwgcGsgfSBvZiBwYXRocykge1xuICAgIGNvbnN0IGVudGl0eUV4cGlyeSA9IGVudGl0aWVzTWV0YVtrZXldPy5bcGtdPy5leHBpcmVzQXQ7XG4gICAgLy8gZXhwaXJlc0F0IHdpbGwgYWx3YXlzIHJlc29sdmUgdG8gZmFsc2Ugd2l0aCBhbnkgY29tcGFyaXNvblxuICAgIGlmIChlbnRpdHlFeHBpcnkgPCBleHBpcmVzQXQpIGV4cGlyZXNBdCA9IGVudGl0eUV4cGlyeTtcbiAgfVxuICByZXR1cm4gZXhwaXJlc0F0O1xufVxuXG4vKiogV2hldGhlciBgZGVub3JtYWxpemUoKWAgbXVzdCBydW4gdG8gcmVjb25zdHJ1Y3QgdGhlIHJlc3BvbnNlLlxuICpcbiAqIFRydWUgaWZmIHNvbWUgbm9kZSBpbiB0aGUgc2NoZW1hIHRyZWUgZGVmaW5lcyBgbm9ybWFsaXplYCDigJQgbWVhbmluZyBpdFxuICogdHJhbnNmb3JtcyB0aGUgcmVzcG9uc2Ugd2hlbiB3cml0dGVuIChlbnRpdHkgd3JpdGUsIHBvbHltb3JwaGljIGhvaXN0LFxuICogbGF6eSBkZWxlZ2F0aW9uLCBldGMuKSwgc28gdGhlIGNhY2hlZCB2YWx1ZSBkaWZmZXJzIGZyb20gdGhlIHJlc3BvbnNlLlxuICogTWlycm9ycyB0aGUgZGlzcGF0Y2ggaW4gYGdldFZpc2l0LnRzYDogc2NoZW1hIGNsYXNzZXMgYXJlIGRldGVjdGVkIGhlcmVcbiAqIGJ5IHRoZSBzYW1lIGhvb2sgdGhlIHZpc2l0IHdhbGtlciB1c2VzLCBzbyB3ZSBuZXZlciBuZWVkIHRvIHdhbGsgdGhlaXJcbiAqIGluc3RhbmNlIGZpZWxkcy5cbiAqL1xuZnVuY3Rpb24gcmVxdWlyZXNEZW5vcm1hbGl6ZShzY2hlbWE6IFNjaGVtYSk6IGJvb2xlYW4ge1xuICBpZiAoIXNjaGVtYSkgcmV0dXJuIGZhbHNlO1xuICBpZiAoQXJyYXkuaXNBcnJheShzY2hlbWEpKVxuICAgIHJldHVybiBzY2hlbWEubGVuZ3RoICE9PSAwICYmIHJlcXVpcmVzRGVub3JtYWxpemUoc2NoZW1hWzBdKTtcbiAgLy8gTXVzdCByZWplY3QgcHJpbWl0aXZlcyBiZWZvcmUgcHJvYmluZyBgLm5vcm1hbGl6ZWAg4oCUIGBTdHJpbmcucHJvdG90eXBlLm5vcm1hbGl6ZWAgZXhpc3RzLlxuICBjb25zdCB0ID0gdHlwZW9mIHNjaGVtYTtcbiAgaWYgKHQgIT09ICdvYmplY3QnICYmIHQgIT09ICdmdW5jdGlvbicpIHJldHVybiBmYWxzZTtcbiAgaWYgKHR5cGVvZiAoc2NoZW1hIGFzIGFueSkubm9ybWFsaXplID09PSAnZnVuY3Rpb24nKSByZXR1cm4gdHJ1ZTtcbiAgLy8gUGxhaW4tb2JqZWN0IHNjaGVtYSBtYXAgKGUuZy4gYHsgZGF0YTogW1RhY29zXSwgcGFnZTogeyAuLi4gfSB9YCkuXG4gIHJldHVybiBPYmplY3QudmFsdWVzKHNjaGVtYSBhcyBvYmplY3QpLnNvbWUoeCA9PiByZXF1aXJlc0Rlbm9ybWFsaXplKHgpKTtcbn1cblxuZXhwb3J0IHR5cGUgeyBFcnJvclR5cGVzIH07XG5cbmNsYXNzIFNuYXBzaG90PFQgPSB1bmtub3duPiBpbXBsZW1lbnRzIFNuYXBzaG90SW50ZXJmYWNlIHtcbiAgc3RhdGljIHJlYWRvbmx5IGFib3J0ID0gbmV3IEFib3J0T3B0aW1pc3RpYygpO1xuXG4gIHByaXZhdGUgc3RhdGU6IFN0YXRlPFQ+O1xuICBwcml2YXRlIGNvbnRyb2xsZXI6IENvbnRyb2xsZXI7XG4gIHJlYWRvbmx5IGZldGNoZWRBdDogbnVtYmVyO1xuICByZWFkb25seSBhYm9ydCA9IFNuYXBzaG90LmFib3J0O1xuXG4gIGNvbnN0cnVjdG9yKGNvbnRyb2xsZXI6IENvbnRyb2xsZXIsIHN0YXRlOiBTdGF0ZTxUPiwgZmV0Y2hlZEF0ID0gMCkge1xuICAgIHRoaXMuc3RhdGUgPSBzdGF0ZTtcbiAgICB0aGlzLmNvbnRyb2xsZXIgPSBjb250cm9sbGVyO1xuICAgIHRoaXMuZmV0Y2hlZEF0ID0gZmV0Y2hlZEF0O1xuICB9XG5cbiAgLyoqKioqKioqKioqKioqKiBEYXRhIEFjY2VzcyAqKioqKioqKioqKioqKiovXG4gIC8qKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9TbmFwc2hvdCNnZXRSZXNwb25zZSAqL1xuICBnZXRSZXNwb25zZTxFIGV4dGVuZHMgRW5kcG9pbnRJbnRlcmZhY2U+KFxuICAgIGVuZHBvaW50OiBFLFxuICAgIC4uLmFyZ3M6IHJlYWRvbmx5IFtudWxsXVxuICApOiB7XG4gICAgZGF0YTogRGVub3JtYWxpemVOdWxsYWJsZTxFWydzY2hlbWEnXT47XG4gICAgZXhwaXJ5U3RhdHVzOiBFeHBpcnlTdGF0dXM7XG4gICAgZXhwaXJlc0F0OiBudW1iZXI7XG4gIH07XG5cbiAgZ2V0UmVzcG9uc2U8RSBleHRlbmRzIEVuZHBvaW50SW50ZXJmYWNlPihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5hcmdzOiByZWFkb25seSBbLi4uUGFyYW1ldGVyczxFPl1cbiAgKToge1xuICAgIGRhdGE6IERlbm9ybWFsaXplTnVsbGFibGU8RVsnc2NoZW1hJ10+O1xuICAgIGV4cGlyeVN0YXR1czogRXhwaXJ5U3RhdHVzO1xuICAgIGV4cGlyZXNBdDogbnVtYmVyO1xuICB9O1xuXG4gIGdldFJlc3BvbnNlPFxuICAgIEUgZXh0ZW5kcyBQaWNrPEVuZHBvaW50SW50ZXJmYWNlLCAna2V5JyB8ICdzY2hlbWEnIHwgJ2ludmFsaWRJZlN0YWxlJz4sXG4gID4oXG4gICAgZW5kcG9pbnQ6IEUsXG4gICAgLi4uYXJnczogcmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RVsna2V5J10+XSB8IHJlYWRvbmx5IFtudWxsXVxuICApOiB7XG4gICAgZGF0YTogRGVub3JtYWxpemVOdWxsYWJsZTxFWydzY2hlbWEnXT47XG4gICAgZXhwaXJ5U3RhdHVzOiBFeHBpcnlTdGF0dXM7XG4gICAgZXhwaXJlc0F0OiBudW1iZXI7XG4gIH07XG5cbiAgZ2V0UmVzcG9uc2U8XG4gICAgRSBleHRlbmRzIFBpY2s8RW5kcG9pbnRJbnRlcmZhY2UsICdrZXknIHwgJ3NjaGVtYScgfCAnaW52YWxpZElmU3RhbGUnPixcbiAgPihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5hcmdzOiByZWFkb25seSBbLi4uUGFyYW1ldGVyczxFWydrZXknXT5dIHwgcmVhZG9ubHkgW251bGxdXG4gICk6IHtcbiAgICBkYXRhOiBEZW5vcm1hbGl6ZU51bGxhYmxlPEVbJ3NjaGVtYSddPjtcbiAgICBleHBpcnlTdGF0dXM6IEV4cGlyeVN0YXR1cztcbiAgICBleHBpcmVzQXQ6IG51bWJlcjtcbiAgfSB7XG4gICAgcmV0dXJuIHRoaXMuY29udHJvbGxlci5nZXRSZXNwb25zZShlbmRwb2ludCwgLi4uYXJncywgdGhpcy5zdGF0ZSk7XG4gIH1cblxuICAvKiogQHNlZSBodHRwczovL2RhdGFjbGllbnQuaW8vZG9jcy9hcGkvU25hcHNob3QjZ2V0UmVzcG9uc2VNZXRhICovXG4gIGdldFJlc3BvbnNlTWV0YTxFIGV4dGVuZHMgRW5kcG9pbnRJbnRlcmZhY2U+KFxuICAgIGVuZHBvaW50OiBFLFxuICAgIC4uLmFyZ3M6IHJlYWRvbmx5IFtudWxsXVxuICApOiB7XG4gICAgZGF0YTogRGVub3JtYWxpemVOdWxsYWJsZTxFWydzY2hlbWEnXT47XG4gICAgZXhwaXJ5U3RhdHVzOiBFeHBpcnlTdGF0dXM7XG4gICAgZXhwaXJlc0F0OiBudW1iZXI7XG4gIH07XG5cbiAgZ2V0UmVzcG9uc2VNZXRhPEUgZXh0ZW5kcyBFbmRwb2ludEludGVyZmFjZT4oXG4gICAgZW5kcG9pbnQ6IEUsXG4gICAgLi4uYXJnczogcmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RT5dXG4gICk6IHtcbiAgICBkYXRhOiBEZW5vcm1hbGl6ZU51bGxhYmxlPEVbJ3NjaGVtYSddPjtcbiAgICBleHBpcnlTdGF0dXM6IEV4cGlyeVN0YXR1cztcbiAgICBleHBpcmVzQXQ6IG51bWJlcjtcbiAgfTtcblxuICBnZXRSZXNwb25zZU1ldGE8XG4gICAgRSBleHRlbmRzIFBpY2s8RW5kcG9pbnRJbnRlcmZhY2UsICdrZXknIHwgJ3NjaGVtYScgfCAnaW52YWxpZElmU3RhbGUnPixcbiAgPihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5hcmdzOiByZWFkb25seSBbLi4uUGFyYW1ldGVyczxFWydrZXknXT5dIHwgcmVhZG9ubHkgW251bGxdXG4gICk6IHtcbiAgICBkYXRhOiBEZW5vcm1hbGl6ZU51bGxhYmxlPEVbJ3NjaGVtYSddPjtcbiAgICBleHBpcnlTdGF0dXM6IEV4cGlyeVN0YXR1cztcbiAgICBleHBpcmVzQXQ6IG51bWJlcjtcbiAgfTtcblxuICBnZXRSZXNwb25zZU1ldGE8XG4gICAgRSBleHRlbmRzIFBpY2s8RW5kcG9pbnRJbnRlcmZhY2UsICdrZXknIHwgJ3NjaGVtYScgfCAnaW52YWxpZElmU3RhbGUnPixcbiAgPihcbiAgICBlbmRwb2ludDogRSxcbiAgICAuLi5hcmdzOiByZWFkb25seSBbLi4uUGFyYW1ldGVyczxFWydrZXknXT5dIHwgcmVhZG9ubHkgW251bGxdXG4gICk6IHtcbiAgICBkYXRhOiBEZW5vcm1hbGl6ZU51bGxhYmxlPEVbJ3NjaGVtYSddPjtcbiAgICBleHBpcnlTdGF0dXM6IEV4cGlyeVN0YXR1cztcbiAgICBleHBpcmVzQXQ6IG51bWJlcjtcbiAgfSB7XG4gICAgcmV0dXJuIHRoaXMuY29udHJvbGxlci5nZXRSZXNwb25zZU1ldGEoZW5kcG9pbnQsIC4uLmFyZ3MsIHRoaXMuc3RhdGUpO1xuICB9XG5cbiAgLyoqIEBzZWUgaHR0cHM6Ly9kYXRhY2xpZW50LmlvL2RvY3MvYXBpL1NuYXBzaG90I2dldEVycm9yICovXG4gIGdldEVycm9yPEUgZXh0ZW5kcyBFbmRwb2ludEludGVyZmFjZT4oXG4gICAgZW5kcG9pbnQ6IEUsXG4gICAgLi4uYXJnczogcmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RT5dIHwgcmVhZG9ubHkgW251bGxdXG4gICk6IEVycm9yVHlwZXMgfCB1bmRlZmluZWQ7XG5cbiAgZ2V0RXJyb3I8RSBleHRlbmRzIFBpY2s8RW5kcG9pbnRJbnRlcmZhY2UsICdrZXknPj4oXG4gICAgZW5kcG9pbnQ6IEUsXG4gICAgLi4uYXJnczogcmVhZG9ubHkgWy4uLlBhcmFtZXRlcnM8RVsna2V5J10+XSB8IHJlYWRvbmx5IFtudWxsXVxuICApOiBFcnJvclR5cGVzIHwgdW5kZWZpbmVkO1xuXG4gIGdldEVycm9yPEUgZXh0ZW5kcyBQaWNrPEVuZHBvaW50SW50ZXJmYWNlLCAna2V5Jz4+KFxuICAgIGVuZHBvaW50OiBFLFxuICAgIC4uLmFyZ3M6IHJlYWRvbmx5IFsuLi5QYXJhbWV0ZXJzPEVbJ2tleSddPl0gfCByZWFkb25seSBbbnVsbF1cbiAgKTogRXJyb3JUeXBlcyB8IHVuZGVmaW5lZCB7XG4gICAgcmV0dXJuIHRoaXMuY29udHJvbGxlci5nZXRFcnJvcihlbmRwb2ludCwgLi4uYXJncywgdGhpcy5zdGF0ZSk7XG4gIH1cblxuICAvKipcbiAgICogUmV0cmlldmVkIG1lbW9pemVkIHZhbHVlIGZvciBhbnkgUXVlcmFibGUgc2NoZW1hXG4gICAqIEBzZWUgaHR0cHM6Ly9kYXRhY2xpZW50LmlvL2RvY3MvYXBpL1NuYXBzaG90I2dldFxuICAgKi9cbiAgZ2V0PFMgZXh0ZW5kcyBRdWVyeWFibGU+KFxuICAgIHNjaGVtYTogUyxcbiAgICAuLi5hcmdzOiBTY2hlbWFBcmdzPFM+XG4gICk6IERlbm9ybWFsaXplTnVsbGFibGU8Uz4gfCB1bmRlZmluZWQge1xuICAgIHJldHVybiB0aGlzLmNvbnRyb2xsZXIuZ2V0KHNjaGVtYSwgLi4uYXJncywgdGhpcy5zdGF0ZSk7XG4gIH1cblxuICAvKipcbiAgICogUXVlcmllcyB0aGUgc3RvcmUgZm9yIGEgUXVlcmFibGUgc2NoZW1hOyBwcm92aWRpbmcgcmVsYXRlZCBtZXRhZGF0YVxuICAgKiBAc2VlIGh0dHBzOi8vZGF0YWNsaWVudC5pby9kb2NzL2FwaS9TbmFwc2hvdCNnZXRRdWVyeU1ldGFcbiAgICovXG4gIGdldFF1ZXJ5TWV0YTxTIGV4dGVuZHMgUXVlcnlhYmxlPihcbiAgICBzY2hlbWE6IFMsXG4gICAgLi4uYXJnczogU2NoZW1hQXJnczxTPlxuICApOiB7XG4gICAgZGF0YTogRGVub3JtYWxpemVOdWxsYWJsZTxTPiB8IHVuZGVmaW5lZDtcbiAgICBjb3VudFJlZjogKCkgPT4gKCkgPT4gdm9pZDtcbiAgfSB7XG4gICAgcmV0dXJuIHRoaXMuY29udHJvbGxlci5nZXRRdWVyeU1ldGEoc2NoZW1hLCAuLi5hcmdzLCB0aGlzLnN0YXRlKTtcbiAgfVxufVxuXG4vKiogRXh0cmFjdCBzdGF0ZSBhbmQgYXJncyBmcm9tIHJlc3QgcGFyYW1zLCBhcHBseWluZyBlbnN1cmVQb2pvIHRvIGFyZ3MgKi9cbmZ1bmN0aW9uIGV4dHJhY3RTdGF0ZUFuZEFyZ3MocmVzdDogcmVhZG9ubHkgdW5rbm93bltdKTogW1N0YXRlPGFueT4sIGFueVtdXSB7XG4gIGNvbnN0IGwgPSByZXN0Lmxlbmd0aDtcbiAgY29uc3QgYXJnczogYW55ID0gbmV3IEFycmF5KGwgLSAxKTtcbiAgZm9yIChsZXQgaSA9IDA7IGkgPCBsIC0gMTsgaSsrKSB7XG4gICAgLy8gaGFuZGxlIEZvcm1EYXRhXG4gICAgYXJnc1tpXSA9IGVuc3VyZVBvam8ocmVzdFtpXSk7XG4gIH1cbiAgLy8gdGhpcyBpcyB0eXBlc2NyaXB0IGdlbmVyaWNzIGJyZWF