@searchspring/snap-url-manager 0.20.0

package/dist/cjs/Translators/Url/UrlTranslator.js

@@ -0,0 +1,466 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlTranslator = void 0;
+var deepmerge_1 = __importDefault(require("deepmerge"));
+var types_1 = require("../../types");
+var defaultConfig = {
+    urlRoot: '',
+    settings: {
+        corePrefix: '',
+        customType: types_1.ParamLocationType.HASH,
+        rootParams: true,
+    },
+    parameters: {
+        core: {
+            query: { name: 'q', type: types_1.ParamLocationType.QUERY },
+            oq: { name: 'oq', type: types_1.ParamLocationType.QUERY },
+            rq: { name: 'rq', type: types_1.ParamLocationType.QUERY },
+            tag: { name: 'tag', type: types_1.ParamLocationType.QUERY },
+            page: { name: 'page', type: types_1.ParamLocationType.QUERY },
+            pageSize: { name: 'pageSize', type: types_1.ParamLocationType.HASH },
+            sort: { name: 'sort', type: types_1.ParamLocationType.HASH },
+            filter: { name: 'filter', type: types_1.ParamLocationType.HASH },
+        },
+        custom: {},
+    },
+};
+var CORE_FIELDS = ['query', 'oq', 'rq', 'tag', 'page', 'pageSize', 'sort', 'filter'];
+var UrlTranslator = /** @class */ (function () {
+    function UrlTranslator(config) {
+        var _this = this;
+        if (config === void 0) { config = {}; }
+        this.reverseMapping = {};
+        this.config = (0, deepmerge_1.default)(defaultConfig, config);
+        Object.keys(this.config.parameters.core).forEach(function (param) {
+            var _a, _b, _c;
+            // param prefix
+            if (_this.config.settings.corePrefix) {
+                _this.config.parameters.core[param].name = _this.config.settings.corePrefix + _this.config.parameters.core[param].name;
+            }
+            // global type override
+            var paramType = _this.config.settings.coreType;
+            if (paramType && Object.values(types_1.ParamLocationType).includes(paramType)) {
+                _this.config.parameters.core[param].type = (((_a = config === null || config === void 0 ? void 0 : config.parameters) === null || _a === void 0 ? void 0 : _a.core) && ((_c = (_b = config === null || config === void 0 ? void 0 : config.parameters) === null || _b === void 0 ? void 0 : _b.core[param]) === null || _c === void 0 ? void 0 : _c.type)) || paramType;
+            }
+            // create reverse mapping for quick lookup later
+            _this.reverseMapping[_this.config.parameters.core[param].name] = param;
+        });
+        var implicit = this.config.settings.customType;
+        if (implicit && !Object.values(types_1.ParamLocationType).includes(implicit)) {
+            // invalid type specified - falling back to hash as implicit type
+            this.config.settings.customType = types_1.ParamLocationType.HASH;
+        }
+    }
+    UrlTranslator.prototype.bindExternalEvents = function (update) {
+        window.addEventListener('popstate', update);
+    };
+    UrlTranslator.prototype.getCurrentUrl = function () {
+        return window.location.search + window.location.hash;
+    };
+    UrlTranslator.prototype.getConfig = function () {
+        return (0, deepmerge_1.default)({}, this.config);
+    };
+    UrlTranslator.prototype.deserialize = function (url) {
+        var params = this.parseUrlParams(url);
+        return this.paramsToState(params);
+    };
+    UrlTranslator.prototype.parseUrlParams = function (url) {
+        var queryString = url.includes('?') ? (url.split('?').pop() || '').split('#').shift() || '' : '';
+        var hashString = url.includes('#') ? url.substring(url.indexOf('#') + 1) || '' : '';
+        return __spreadArray(__spreadArray([], this.parseHashString(hashString), true), this.parseQueryString(queryString), true);
+    };
+    UrlTranslator.prototype.parseQueryString = function (queryString) {
+        var _this = this;
+        var justQueryString = queryString.split('?').pop() || '';
+        return justQueryString
+            .split('&')
+            .filter(function (v) { return v; })
+            .map(function (kvPair) {
+            var _a = kvPair.split('=').map(function (v) { return decodeURIComponent(v.replace(/\+/g, ' ')); }), key = _a[0], value = _a[1];
+            return { key: key.split('.'), value: value, type: types_1.ParamLocationType.QUERY };
+        })
+            .filter(function (param) {
+            // remove core fields that do not contain a value
+            var isCoreField = _this.reverseMapping[param.key[0]];
+            return !isCoreField || (isCoreField && param.value);
+        });
+    };
+    UrlTranslator.prototype.parseHashString = function (hashString) {
+        var _this = this;
+        var params = [];
+        var justHashString = hashString.split('#').join('/') || '';
+        justHashString
+            .split('/')
+            .filter(function (v) { return v; })
+            .map(function (hashEntries) {
+            return hashEntries.split(':').map(function (v) { return decodeHashComponent(v); });
+        })
+            .filter(function (param) {
+            // remove core fields that do not contain a value
+            var key = param[0], value = param[1];
+            var isCoreField = _this.reverseMapping[key];
+            return !isCoreField || (isCoreField && value);
+        })
+            .forEach(function (decodedHashEntries) {
+            if (decodedHashEntries.length == 1) {
+                params.push({ key: [decodedHashEntries[0]], value: undefined, type: types_1.ParamLocationType.HASH });
+            }
+            else if (decodedHashEntries.length && decodedHashEntries.length <= 3) {
+                var _a = decodedHashEntries.reverse(), value = _a[0], keys = _a.slice(1);
+                params.push({ key: keys.reverse(), value: value, type: types_1.ParamLocationType.HASH });
+            }
+            else if (decodedHashEntries.length && decodedHashEntries.length == 4) {
+                // range filter
+                var path0 = decodedHashEntries[0], path1 = decodedHashEntries[1], low = decodedHashEntries[2], high = decodedHashEntries[3];
+                params.push({ key: [path0, path1, 'low'], value: low, type: types_1.ParamLocationType.HASH });
+                params.push({ key: [path0, path1, 'high'], value: high, type: types_1.ParamLocationType.HASH });
+            }
+        });
+        return params;
+    };
+    // parse params into state
+    UrlTranslator.prototype.paramsToState = function (params) {
+        var _this = this;
+        var coreOtherParams = [], coreFilterParams = [], coreSortParams = [], otherParams = [];
+        params === null || params === void 0 ? void 0 : params.forEach(function (param) {
+            var coreStateKey = _this.reverseMapping[param.key[0]];
+            var coreConfig = _this.config.parameters.core[coreStateKey];
+            var customStateKey = _this.config.parameters.custom[param.key[0]];
+            if (coreStateKey) {
+                // core state
+                switch (coreStateKey) {
+                    case 'filter': {
+                        if (coreConfig.type == param.type)
+                            coreFilterParams.push(param);
+                        break;
+                    }
+                    case 'sort': {
+                        if (coreConfig.type == param.type)
+                            coreSortParams.push(param);
+                        break;
+                    }
+                    default: {
+                        if (coreConfig.type == param.type)
+                            coreOtherParams.push(param);
+                        break;
+                    }
+                }
+            }
+            else if (!CORE_FIELDS.includes(param.key[0])) {
+                // custom state
+                if (!customStateKey) {
+                    // unrecognized state - store in custom config map (as implicit type)
+                    _this.config.parameters.custom[param.key[0]] = {
+                        type: param.type || _this.config.settings.customType,
+                    };
+                }
+                otherParams.push(param);
+            }
+        });
+        return __assign(__assign(__assign(__assign({}, this.parseCoreOther(coreOtherParams)), this.parseCoreFilter(coreFilterParams)), this.parseCoreSort(coreSortParams)), this.parseOther(otherParams));
+    };
+    UrlTranslator.prototype.parseCoreOther = function (otherParams) {
+        var _this = this;
+        var state = {};
+        var numberTypeParams = ['page', 'pageSize'];
+        if (!otherParams) {
+            return {};
+        }
+        otherParams.forEach(function (param) {
+            var coreKey = _this.reverseMapping[param.key[0]];
+            if (numberTypeParams.includes(coreKey)) {
+                var numValue = Number(param.value);
+                if (coreKey == 'page' && numValue > 1) {
+                    state[coreKey] = numValue;
+                }
+                else if (coreKey != 'page') {
+                    state[coreKey] = numValue;
+                }
+            }
+            else {
+                state[coreKey] = param.value;
+            }
+        });
+        return state;
+    };
+    UrlTranslator.prototype.parseCoreFilter = function (filterParams) {
+        var valueFilterParams = filterParams.filter(function (p) { return p.key.length == 2; });
+        var rangeFilterParams = filterParams.filter(function (p) { return p.key.length == 3; });
+        var valueFilters = valueFilterParams.reduce(function (state, param) {
+            var _a;
+            var currentValue = (state.filter || {})[param.key[1]] || [];
+            return {
+                filter: __assign(__assign({}, state.filter), (_a = {}, _a[param.key[1]] = __spreadArray(__spreadArray([], (Array.isArray(currentValue) ? currentValue : [currentValue]), true), [param.value], false), _a)),
+            };
+        }, {});
+        var rangeFilters = rangeFilterParams.reduce(function (state, param, index) {
+            // ranges should come in pairs!
+            // use index to build pairs, ignore non pairs
+            // build set as encountered - only return full sets (low + high)
+            var _a, _b;
+            var newState = state;
+            var nextRangeParam = rangeFilterParams[index + 1];
+            if (index % 2 == 0 &&
+                nextRangeParam &&
+                nextRangeParam.key[1] == param.key[1] &&
+                param.key[2] == types_1.RangeValueProperties.LOW &&
+                nextRangeParam.key[2] == types_1.RangeValueProperties.HIGH) {
+                var currentValue = (state.filter || {})[param.key[1]] || [];
+                newState = {
+                    filter: __assign(__assign({}, state.filter), (_a = {}, _a[param.key[1]] = __spreadArray(__spreadArray([], (Array.isArray(currentValue) ? currentValue : [currentValue]), true), [
+                        (_b = {},
+                            _b[types_1.RangeValueProperties.LOW] = isNaN(+param.value) ? null : +param.value,
+                            _b[types_1.RangeValueProperties.HIGH] = isNaN(+nextRangeParam.value) ? null : +nextRangeParam.value,
+                            _b),
+                    ], false), _a)),
+                };
+            }
+            return newState;
+        }, {});
+        return __assign({}, (valueFilters.filter || rangeFilters.filter
+            ? {
+                filter: __assign(__assign({}, valueFilters.filter), rangeFilters.filter),
+            }
+            : {}));
+    };
+    UrlTranslator.prototype.parseCoreSort = function (sortParams) {
+        if (!sortParams.length) {
+            return {};
+        }
+        return {
+            sort: sortParams.map(function (param) { return ({
+                field: param.key[1],
+                direction: param.value,
+            }); }),
+        };
+    };
+    UrlTranslator.prototype.parseOther = function (otherParams) {
+        var state = {};
+        otherParams.forEach(function (param) {
+            var node = state;
+            param.key.forEach(function (key, i) {
+                var isLast = i == param.key.length - 1;
+                if (isLast) {
+                    node[key] = node[key] || [];
+                    param.value && node[key].push(param.value);
+                }
+                else {
+                    node[key] = node[key] || {};
+                    node = node[key];
+                }
+            });
+        });
+        return state;
+    };
+    UrlTranslator.prototype.serialize = function (state) {
+        var root = this.config.urlRoot.includes('?')
+            ? this.config.urlRoot.split('?')[0]
+            : this.config.urlRoot.includes('#')
+                ? this.config.urlRoot.split('#')[0]
+                : this.config.urlRoot;
+        var rootUrlParams = this.config.settings.rootParams ? this.parseUrlParams(this.config.urlRoot) : [];
+        var stateParams = this.stateToParams(state);
+        var params = __spreadArray(__spreadArray([], rootUrlParams, true), stateParams, true);
+        var queryParams = params.filter(function (p) { return p.type == types_1.ParamLocationType.QUERY; });
+        var hashParams = params.filter(function (p) { return p.type == types_1.ParamLocationType.HASH; });
+        var paramString = (queryParams.length
+            ? '?' +
+                queryParams
+                    .map(function (param) {
+                    var keyString = encodeURIComponent(param.key.join('.'));
+                    var valueString = param.value ? '=' + encodeURIComponent(param.value) : '';
+                    return keyString + valueString;
+                })
+                    .join('&')
+            : this.config.urlRoot
+                ? ''
+                : window.location.pathname) +
+            (hashParams.length
+                ? '#/' +
+                    hashParams
+                        .map(function (param) {
+                        var keyString = param.key.map(function (k) { return encodeHashComponent(k); }).join(':');
+                        var valueString = param.value ? ':' + encodeHashComponent(param.value) : '';
+                        return keyString + valueString;
+                    })
+                        .join('/')
+                : '');
+        return "".concat(root).concat(paramString);
+    };
+    // encode state into params
+    UrlTranslator.prototype.stateToParams = function (state) {
+        return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], this.encodeCoreOther(state, ['filter', 'sort']), true), this.encodeCoreFilters(state), true), this.encodeCoreSorts(state), true), this.encodeOther(state), true);
+    };
+    UrlTranslator.prototype.encodeCoreFilters = function (state) {
+        var filterConfig = this.config.parameters.core.filter;
+        if (!state.filter || !filterConfig) {
+            return [];
+        }
+        return Object.keys(state.filter).flatMap(function (key) {
+            if (!state.filter || !state.filter[key]) {
+                return [];
+            }
+            var filter = state.filter[key];
+            return (filter instanceof Array ? filter : [filter]).flatMap(function (value) {
+                var _a, _b, _c, _d;
+                if (typeof value == 'string' || typeof value == 'number' || typeof value == 'boolean') {
+                    return [
+                        {
+                            key: [filterConfig.name, key],
+                            value: '' + value,
+                            type: filterConfig.type,
+                        },
+                    ];
+                }
+                else if (typeof value == 'object' &&
+                    typeof value[types_1.RangeValueProperties.LOW] != 'undefined' &&
+                    typeof value[types_1.RangeValueProperties.HIGH] != 'undefined') {
+                    if (filterConfig.type == types_1.ParamLocationType.QUERY) {
+                        return [
+                            {
+                                key: [filterConfig.name, key, types_1.RangeValueProperties.LOW],
+                                value: '' + ((_a = value[types_1.RangeValueProperties.LOW]) !== null && _a !== void 0 ? _a : '*'),
+                                type: filterConfig.type,
+                            },
+                            {
+                                key: [filterConfig.name, key, types_1.RangeValueProperties.HIGH],
+                                value: '' + ((_b = value[types_1.RangeValueProperties.HIGH]) !== null && _b !== void 0 ? _b : '*'),
+                                type: filterConfig.type,
+                            },
+                        ];
+                    }
+                    else if (filterConfig.type == types_1.ParamLocationType.HASH) {
+                        return [
+                            {
+                                key: [filterConfig.name, key, '' + ((_c = value[types_1.RangeValueProperties.LOW]) !== null && _c !== void 0 ? _c : '*')],
+                                value: '' + ((_d = value[types_1.RangeValueProperties.HIGH]) !== null && _d !== void 0 ? _d : '*'),
+                                type: filterConfig.type,
+                            },
+                        ];
+                    }
+                }
+                return [];
+            });
+        });
+    };
+    UrlTranslator.prototype.encodeCoreSorts = function (state) {
+        var sortConfig = this.config.parameters.core.sort;
+        if (!state.sort || !sortConfig) {
+            return [];
+        }
+        return (state.sort instanceof Array ? state.sort : [state.sort]).map(function (sort) {
+            return {
+                key: [sortConfig.name, sort.field],
+                value: sort.direction,
+                type: sortConfig.type,
+            };
+        });
+    };
+    UrlTranslator.prototype.encodeCoreOther = function (state, except) {
+        var _this = this;
+        var params = [];
+        Object.keys(state)
+            // sorting to determine order of params in URL
+            .sort(function (a, b) {
+            return CORE_FIELDS.indexOf(a) - CORE_FIELDS.indexOf(b);
+        })
+            .map(function (param) {
+            if (CORE_FIELDS.includes(param) && !except.includes(param)) {
+                var paramConfig = _this.config.parameters.core[param];
+                if (param == 'page' && state[param] == 1) {
+                    // do not include page 1
+                }
+                else {
+                    params.push({ key: [paramConfig.name], value: '' + state[param], type: paramConfig.type });
+                }
+            }
+        });
+        return params;
+    };
+    UrlTranslator.prototype.encodeOther = function (state) {
+        var _this = this;
+        var params = [];
+        var addRecursive = function (obj, currentPath) {
+            Object.keys(obj).forEach(function (key) {
+                if (currentPath.length == 0 && CORE_FIELDS.includes(key)) {
+                    return;
+                }
+                var value = obj[key];
+                if (value instanceof Array) {
+                    var customConfig = _this.config.parameters.custom[currentPath[0] || key];
+                    var type_1 = (customConfig === null || customConfig === void 0 ? void 0 : customConfig.type) || _this.config.settings.customType;
+                    if (value.length) {
+                        params = params.concat(value.map(function (v) {
+                            return { key: __spreadArray(__spreadArray([], currentPath, true), [key], false), value: v, type: type_1 };
+                        }));
+                    }
+                    else {
+                        params = params.concat({ key: __spreadArray(__spreadArray([], currentPath, true), [key], false), value: undefined, type: type_1 });
+                    }
+                }
+                else if (typeof value == 'object' && Object.keys(value).length) {
+                    addRecursive(value, __spreadArray(__spreadArray([], currentPath, true), [key], false));
+                }
+                else {
+                    var customConfig = _this.config.parameters.custom[currentPath[0] || key];
+                    var type = (customConfig === null || customConfig === void 0 ? void 0 : customConfig.type) || _this.config.settings.customType;
+                    var stringValue = (typeof value == 'object' ? undefined : value);
+                    params = params.concat([{ key: __spreadArray(__spreadArray([], currentPath, true), [key], false), value: stringValue, type: type }]);
+                }
+            });
+        };
+        addRecursive(state, []);
+        return params;
+    };
+    UrlTranslator.prototype.go = function (url, config) {
+        var currentUrl = this.getCurrentUrl();
+        if (url != currentUrl) {
+            if ((config === null || config === void 0 ? void 0 : config.history) == 'replace') {
+                history.replaceState(null, '', url);
+            }
+            else {
+                history.pushState(null, '', url);
+            }
+        }
+    };
+    return UrlTranslator;
+}());
+exports.UrlTranslator = UrlTranslator;
+function decodeHashComponent(string) {
+    if (typeof string == 'string') {
+        string = string.replace(/%2425/g, '$$25');
+        string = string.replace(/\$25/g, '%');
+        string = decodeURIComponent(string);
+    }
+    return string;
+}
+function encodeHashComponent(string) {
+    if (typeof string == 'string') {
+        string = encodeURIComponent(string);
+        string = string.replace(/%/g, '$$25');
+    }
+    return string;
+}

package/dist/cjs/Translators/index.d.ts

@@ -0,0 +1,4 @@
+export * from './QueryString/QueryStringTranslator';
+export * from './Url/UrlTranslator';
+export * from './Noop/NoopTranslator';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/Translators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Translators/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC"}

package/dist/cjs/Translators/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./QueryString/QueryStringTranslator"), exports);
+__exportStar(require("./Url/UrlTranslator"), exports);
+__exportStar(require("./Noop/NoopTranslator"), exports);

package/dist/cjs/UrlManager/UrlManager.d.ts

@@ -0,0 +1,50 @@
+import { Translator, UrlState } from '../types';
+import type { ImmutableObject } from 'seamless-immutable';
+declare type omission = {
+    path: Array<string>;
+    values?: Array<any>;
+};
+declare class WatcherPool {
+    private callbacks;
+    constructor();
+    subscribe(cb: () => void): () => (() => void)[];
+    notify(): void;
+}
+export declare class UrlManager {
+    linker?: (urlManager: UrlManager) => Record<string, unknown>;
+    private omissions;
+    detached?: {
+        url: string;
+    };
+    private translator;
+    private urlState;
+    private globalState;
+    private localState;
+    private mergedState;
+    private prevState?;
+    private watcherPool;
+    constructor(translator: Translator, linker?: (urlManager: UrlManager) => Record<string, unknown>, globalState?: UrlState | ImmutableObject<UrlState>, localState?: UrlState | ImmutableObject<UrlState>, watcherPool?: WatcherPool, omissions?: Array<omission>, detached?: {
+        url: string;
+    });
+    private without;
+    private getTranslatorUrl;
+    refresh(): void;
+    get state(): ImmutableObject<UrlState>;
+    private unpackPathAndState;
+    set(...args: Array<unknown>): UrlManager;
+    merge(...args: Array<unknown>): UrlManager;
+    remove(_path: Array<string> | string, values?: Array<any> | any): UrlManager;
+    reset(): UrlManager;
+    withConfig(config: Record<string, unknown> | ((config: Record<string, unknown>) => Record<string, unknown>)): UrlManager;
+    withGlobals(globals: UrlState | ImmutableObject<UrlState>): UrlManager;
+    getTranslatorConfig(): Record<string, unknown>;
+    get href(): string;
+    go(config?: {
+        [any: string]: unknown;
+    }): void;
+    detach(reset?: boolean): UrlManager;
+    get link(): Record<string, any>;
+    subscribe(cb: (prev: ImmutableObject<UrlState>, next?: ImmutableObject<UrlState>) => void): () => void;
+}
+export {};
+//# sourceMappingURL=UrlManager.d.ts.map

package/dist/cjs/UrlManager/UrlManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UrlManager.d.ts","sourceRoot":"","sources":["../../../src/UrlManager/UrlManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGhD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,aAAK,QAAQ,GAAG;IACf,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACpB,MAAM,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACpB,CAAC;AAEF,cAAM,WAAW;IAChB,OAAO,CAAC,SAAS,CAAyB;;IAM1C,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI;IAMxB,MAAM;CAGN;AAED,qBAAa,UAAU;IAcd,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAInE,OAAO,CAAC,SAAS;IACV,QAAQ,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE;IAlBlC,OAAO,CAAC,UAAU,CAAa;IAE/B,OAAO,CAAC,QAAQ,CAAyE;IACzF,OAAO,CAAC,WAAW,CAAyE;IAC5F,OAAO,CAAC,UAAU,CAAyE;IAC3F,OAAO,CAAC,WAAW,CAAyE;IAE5F,OAAO,CAAC,SAAS,CAAC,CAA4B;IAE9C,OAAO,CAAC,WAAW,CAAc;gBAGhC,UAAU,EAAE,UAAU,EACf,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnE,WAAW,CAAC,EAAE,QAAQ,GAAG,eAAe,CAAC,QAAQ,CAAC,EAClD,UAAU,CAAC,EAAE,QAAQ,GAAG,eAAe,CAAC,QAAQ,CAAC,EACjD,WAAW,CAAC,EAAE,WAAW,EACjB,SAAS,GAAE,KAAK,CAAC,QAAQ,CAAM,EAChC,QAAQ,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE;IAwBlC,OAAO,CAAC,OAAO;IAkDf,OAAO,CAAC,gBAAgB;IAQxB,OAAO,IAAI,IAAI;IAiBf,IAAI,KAAK,IAAI,eAAe,CAAC,QAAQ,CAAC,CAErC;IAED,OAAO,CAAC,kBAAkB;IAQ1B,GAAG,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,UAAU;IAWxC,KAAK,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,UAAU;IAgC1C,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,UAAU;IAU5E,KAAK,IAAI,UAAU;IAYnB,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,UAAU;IAgBxH,WAAW,CAAC,OAAO,EAAE,QAAQ,GAAG,eAAe,CAAC,QAAQ,CAAC,GAAG,UAAU;IAItE,mBAAmB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAI9C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,EAAE,CAAC,MAAM,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI;IAU7C,MAAM,CAAC,KAAK,UAAQ,GAAG,UAAU;IAMjC,IAAI,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAM9B;IAED,SAAS,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,eAAe,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,CAAC,QAAQ,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;CAQtG"}