@firestitch/report 18.9.0 → 18.10.1

package/esm2022/app/reports/report-view-config.mjs

@@ -0,0 +1,587 @@
+import { GRANULARITY_OPTIONS, } from './interfaces/report.interface';
+import { dateBoundString, dateFromBound } from './report-filter-items';
+// The version this viewer writes and reads.
+export const REPORT_VIEW_CONFIG_VERSION = 1;
+// The caps of a view document, the server's.
+export const VIEW_CONFIG_MAX_BYTES = 32 * 1024;
+export const VIEW_CONFIG_MAX_GROUPS = 100;
+export const VIEW_CONFIG_MAX_TILES = 200;
+export const GROUP_VALUE_MAX_PICKS = 500;
+export const DRILL_MAX_DEPTH = 5;
+// Every relative range name the server knows, in its enum's order. A record
+// rather than a list, so the build fails when ReportRelativeRange gains a
+// name this misses.
+const RELATIVE_RANGES = {
+    thisWeek: true,
+    lastWeek: true,
+    last7Days: true,
+    last30Days: true,
+    last3Months: true,
+    last6Months: true,
+    last12Months: true,
+    thisMonth: true,
+    thisQuarter: true,
+    thisYear: true,
+    yearToDate: true,
+};
+// The same names as a list, in the server enum's order (the record's key
+// order): the order the date picker offers them in.
+export const RELATIVE_RANGE_NAMES = Object.keys(RELATIVE_RANGES);
+// The keys a group value may hold, by its group's type.
+const GROUP_VALUE_KEYS = {
+    dateRange: ['relative', 'start', 'end'],
+    select: ['values', 'excludeValues'],
+    keyword: ['value'],
+    numberRange: ['min', 'max'],
+};
+// The keys of a view document and of a tile state this viewer reads. Any
+// other key is kept as it was.
+const VIEW_CONFIG_KEYS = ['v', 'pageId', 'groupBy', 'match', 'groups', 'tiles'];
+const TILE_STATE_KEYS = ['sort', 'search', 'hidden', 'drill'];
+const DAY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+// A number as text: what a masked input sends.
+const NUMBER_PATTERN = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+const ID_KEY_PATTERN = /^[1-9]\d*$/;
+// Whether a name is a relative range the server resolves.
+export function isRelativeRange(name) {
+    return typeof name === 'string' && Object.prototype.hasOwnProperty.call(RELATIVE_RANGES, name);
+}
+export function isChartGranularity(value) {
+    return GRANULARITY_OPTIONS.some((option) => option.value === value);
+}
+// Whether text is a real calendar day written 'yyyy-MM-dd' (no 2026-02-30).
+export function isCalendarDay(text) {
+    const parts = DAY_PATTERN.exec(text);
+    if (!parts) {
+        return false;
+    }
+    const [year, month, day] = parts.slice(1).map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+// A number written as text (a masked input's value), or null when the text
+// is not one finite number.
+export function numberFromText(text) {
+    const number = NUMBER_PATTERN.test(text) ? Number(text) : NaN;
+    return Number.isFinite(number) ? number : null;
+}
+// A group value read for a group of `type`, on its way to being stored: only
+// the parts that hold something. Throws, naming what is wrong, when a key
+// does not belong to the type or a part breaks its type's rule.
+export function groupValueFromArray(value, type) {
+    requireGroupKeys(value, type);
+    switch (type) {
+        case 'dateRange':
+            return dateRangeValue(value);
+        case 'select':
+            return selectValue(value);
+        case 'numberRange':
+            return numberRangeValue(value);
+        default:
+            return keywordValue(value);
+    }
+}
+// A group value read back (a saved view) for a group of `type`: what
+// groupValueFromArray gives, or null when it would refuse it.
+export function groupValueFromStored(value, type) {
+    if (!isPlainObject(value)) {
+        return null;
+    }
+    try {
+        return groupValueFromArray(value, type);
+    }
+    catch {
+        return null;
+    }
+}
+// A view document read for storing or applying. Throws when it is not a
+// version 1 document, breaks a cap or holds a malformed known key.
+export function viewConfigFromArray(input) {
+    const doc = requireObject(input, 'A view config must be an object.');
+    requireSize(doc);
+    requireVersion(doc.v);
+    const config = { v: REPORT_VIEW_CONFIG_VERSION, ...otherKeys(doc, VIEW_CONFIG_KEYS) };
+    const pageId = optionalId(doc.pageId, 'pageId must be a page id.');
+    if (pageId !== null) {
+        config.pageId = pageId;
+    }
+    if (isSet(doc.groupBy)) {
+        config.groupBy = requireGranularity(doc.groupBy, 'groupBy must be a time grain.');
+    }
+    if (isSet(doc.match)) {
+        config.match = requireMatch(doc.match);
+    }
+    if (isSet(doc.groups)) {
+        config.groups = viewGroups(doc.groups);
+    }
+    if (isSet(doc.tiles)) {
+        config.tiles = viewTiles(doc.tiles);
+    }
+    return config;
+}
+// A group's value as a view stores it, read for the keys its
+// group's type owns, or null when it holds nothing. A date range that still
+// carries its relative preset is stored as that preset whatever today is: the
+// viewer did not edit it, so a view saved after midnight with the page still
+// open keeps rolling.
+export function toStoredGroupValue(type, value) {
+    if (!value) {
+        return null;
+    }
+    switch (type) {
+        case 'dateRange':
+            return isRelativeRange(value.preset)
+                ? { relative: value.preset }
+                : storedOrNull({ start: dateBoundString(value.start), end: dateBoundString(value.end) });
+        case 'select': {
+            const excludeValues = keptPicks(value.excludeValues);
+            return storedOrNull(excludeValues ? { excludeValues } : { values: keptPicks(value.values) });
+        }
+        case 'numberRange':
+            return storedOrNull({ min: finiteNumber(value.min), max: finiteNumber(value.max) });
+        default:
+            return storedOrNull({ value: value.value?.trim() || undefined });
+    }
+}
+// A group value in its stored shape as the value the bars and the requests
+// read: a relative preset as today's days in the report's zone, carrying its
+// name; fixed days as dates; any other value as it is. Null when it holds
+// nothing, or names a preset `resolveRelative` does not know.
+export function toLiveGroupValue(type, stored, resolveRelative) {
+    if (!stored || holdsNothing(stored)) {
+        return null;
+    }
+    if (type !== 'dateRange') {
+        return { ...stored };
+    }
+    if (stored.relative) {
+        const range = resolveRelative(stored.relative);
+        return range ? { start: range.start, end: range.end, preset: stored.relative } : null;
+    }
+    return { start: dateFromBound(stored.start), end: dateFromBound(stored.end) };
+}
+// Whether the screen's state differs from the view it opened on. `current`
+// is a snapshot, so it holds every group the report has; a group only `base`
+// holds is one the report no longer has, and is not compared. A group `base`
+// does not hold was added after the view was saved: it is compared with its
+// value in `authored` (the report's defaults), so leaving it at its default
+// changes nothing. The page is not compared (moving to another page does not
+// edit a view), and neither are keys this viewer does not know. Picks are
+// compared in any order.
+export function viewDiffers(base, current, authored = null) {
+    return (base.match ?? 'all') !== (current.match ?? 'all')
+        || (base.groupBy ?? null) !== (current.groupBy ?? null)
+        || groupsDiffer(base, current, authored)
+        || tilesDiffer(base.tiles ?? {}, current.tiles ?? {});
+}
+// Whether two stored group values are the same filter, as viewDiffers reads
+// a group: picks in any order, text trimmed, an empty value read as none.
+export function sameStoredGroupValue(a, b) {
+    return storedValueKey(a) === storedValueKey(b);
+}
+// A drill path kept to what a tile can carry: its steps up to the first that
+// is not a time level with a plain value (the steps before it are kept), at
+// most DRILL_MAX_DEPTH of them.
+export function cleanDrillPath(path) {
+    const kept = [];
+    for (const step of path ?? []) {
+        if (!isPlainObject(step) || !isChartGranularity(step.level) || !isDrillValue(step.value)
+            || kept.length === DRILL_MAX_DEPTH) {
+            break;
+        }
+        kept.push({ level: step.level, value: step.value });
+    }
+    return kept;
+}
+// Whether two drill paths are the same steps. A value is compared as text,
+// so 2026 and '2026' are the same step.
+export function sameDrillPath(a, b) {
+    return drillKey(a) === drillKey(b);
+}
+// A view's config to save: the screen (`screen`, a snapshot), with the keys
+// this viewer does not know kept from the stored document (`stored`), at the
+// top and in each tile. They are never read here, and saving must not lose
+// them.
+export function withStoredKeys(stored, screen) {
+    if (!stored) {
+        return screen;
+    }
+    const tiles = { ...screen.tiles };
+    Object.entries(stored.tiles ?? {}).forEach(([componentId, tile]) => {
+        const kept = isPlainObject(tile) ? otherKeys(tile, TILE_STATE_KEYS) : {};
+        if (Object.keys(kept).length) {
+            tiles[Number(componentId)] = { ...kept, ...tiles[Number(componentId)] };
+        }
+    });
+    const config = { ...otherKeys(stored, VIEW_CONFIG_KEYS), ...screen };
+    delete config.tiles;
+    return Object.keys(tiles).length ? { ...config, tiles } : config;
+}
+// How many settings of a saved view no longer apply because the report
+// changed: what the server left out when it read the view (`dropped`), and
+// what the viewer could not apply (`applied` is the view as it applied, the
+// state service's base): a group value that no longer fits its group, and a
+// list sort, search or hidden columns, or a chart's drill path, its tile can
+// no longer take (a list column gone, a chart turned into a list).
+export function viewDroppedCount(view, applied) {
+    const dropped = view.dropped;
+    const groups = Object.entries(view.config?.groups ?? {})
+        .filter(([groupId, value]) => value !== null && !Object.prototype.hasOwnProperty.call(applied.groups ?? {}, groupId))
+        .length;
+    const tiles = Object.entries(view.config?.tiles ?? {})
+        .reduce((count, [componentId, tile]) => count + tileKeysLost(tile, applied.tiles?.[Number(componentId)]), 0);
+    return (dropped?.groups?.length ?? 0) + (dropped?.tiles?.length ?? 0) + (dropped?.page ? 1 : 0) + groups + tiles;
+}
+// The note a view opens with when some of its settings no longer apply, or
+// null when every setting applies. Only a viewer who may change the view
+// (`canChange`) is told to save it.
+export function viewDroppedMessage(count, canChange = true) {
+    if (count < 1) {
+        return null;
+    }
+    const note = count === 1
+        ? '1 setting in this view no longer applies, because the report changed.'
+        : `${count} settings in this view no longer apply, because the report changed.`;
+    return canChange ? `${note} Save changes to update the view.` : note;
+}
+// The open view as a chat turn names it: its id, and whether the screen
+// differs from it. Both are left out while no view is open.
+export function chatViewFields(openView, viewChanged) {
+    return openView ? { viewId: openView.id, viewChanged } : {};
+}
+function groupsDiffer(base, current, authored) {
+    return Object.entries(current.groups ?? {}).some(([groupId, value]) => {
+        const kept = base.groups && Object.prototype.hasOwnProperty.call(base.groups, groupId)
+            ? base.groups[Number(groupId)]
+            : authored?.groups?.[Number(groupId)];
+        return storedValueKey(kept) !== storedValueKey(value);
+    });
+}
+function tilesDiffer(base, current) {
+    const ids = new Set([...Object.keys(base), ...Object.keys(current)].map(Number));
+    return [...ids].some((componentId) => tileStateKey(base[componentId]) !== tileStateKey(current[componentId]));
+}
+// How many keys of a stored tile state the tile, as it applied, lost: a
+// sort, a search or a drill path it no longer has, and hidden columns it
+// kept fewer of.
+function tileKeysLost(stored, applied) {
+    if (!stored) {
+        return 0;
+    }
+    return [
+        !!stored.sort?.column && !applied?.sort?.column,
+        !!stored.search && !applied?.search,
+        (stored.hidden?.length ?? 0) > (applied?.hidden?.length ?? 0),
+        (stored.drill?.length ?? 0) > 0 && !applied?.drill?.length,
+    ].filter(Boolean).length;
+}
+// One text for a stored group value, the same for every way of writing the
+// same filter: picks in any order, text trimmed, and an empty value read as
+// none.
+function storedValueKey(value) {
+    const stored = value ?? {};
+    const picks = (list) => [...(keptPicks(list) ?? [])].map(String).sort();
+    return JSON.stringify([
+        stored.relative ?? null,
+        stored.start?.slice(0, 10) ?? null,
+        stored.end?.slice(0, 10) ?? null,
+        picks(stored.values),
+        picks(stored.excludeValues),
+        (stored.value ?? '').trim(),
+        finiteNumber(stored.min) ?? null,
+        finiteNumber(stored.max) ?? null,
+    ]);
+}
+// One text for a tile's state, over the keys this viewer reads. No direction
+// reads as ascending, the way a list applies it.
+function tileStateKey(tile) {
+    return JSON.stringify([
+        tile?.sort?.column ? [tile.sort.column, tile.sort.direction ?? 'asc'] : null,
+        tile?.search ?? '',
+        [...(tile?.hidden ?? [])].sort(),
+        drillKey(tile?.drill),
+    ]);
+}
+function drillKey(path) {
+    return JSON.stringify((path ?? [])
+        .map((step) => [step.level, step.value === null || step.value === undefined ? null : String(step.value)]));
+}
+// The picks of a list with blanks (null, '') left out, or undefined when none
+// is left.
+function keptPicks(list) {
+    const kept = (list ?? []).filter((pick) => isSet(pick) && pick !== '');
+    return kept.length ? kept : undefined;
+}
+// A range end as a number. A masked input sends its number as text, so
+// numeric text is read as its number, as boundPart reads it.
+export function finiteNumber(value) {
+    const number = typeof value === 'string' ? numberFromText(value.trim()) : value;
+    return typeof number === 'number' && Number.isFinite(number) ? number : undefined;
+}
+// Whether a stored value reads the same as no value at all.
+function holdsNothing(stored) {
+    return storedValueKey(stored) === storedValueKey(null);
+}
+// Only the parts that hold something, or null when none does.
+function storedOrNull(value) {
+    const stored = compact(value);
+    return Object.keys(stored).length ? stored : null;
+}
+function requireGroupKeys(value, type) {
+    const allowed = GROUP_VALUE_KEYS[type] ?? GROUP_VALUE_KEYS.keyword;
+    const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
+    if (unknown.length) {
+        throw new Error(`A ${type} default takes ${allowed.join(', ')} — not ${unknown.join(', ')}.`);
+    }
+}
+// A relative range, or fixed days; never both.
+function dateRangeValue(value) {
+    const relative = textPart(value, 'relative');
+    const start = dayPart(value, 'start');
+    const end = dayPart(value, 'end');
+    if (relative === '') {
+        return compact({ start, end });
+    }
+    if (start !== null || end !== null) {
+        throw new Error('A dateRange default is either a relative preset or a fixed start/end, not both.');
+    }
+    if (!isRelativeRange(relative)) {
+        throw new Error(`relative must be one of: ${Object.keys(RELATIVE_RANGES).join(', ')}.`);
+    }
+    return { relative };
+}
+// The values to keep or the values to leave out; never both.
+function selectValue(value) {
+    const values = pickList(value, 'values');
+    const excludeValues = pickList(value, 'excludeValues');
+    if (values !== null && excludeValues !== null) {
+        throw new Error('A select default either keeps values or leaves out exclude_values, not both.');
+    }
+    return compact({ values, excludeValues });
+}
+function keywordValue(value) {
+    const text = textPart(value, 'value');
+    return text !== '' ? { value: text } : {};
+}
+// Either end may be open; 0 is an end like any other.
+function numberRangeValue(value) {
+    const min = boundPart(value, 'min');
+    const max = boundPart(value, 'max');
+    if (min !== null && max !== null && min > max) {
+        throw new Error(`min (${min}) is above max (${max}).`);
+    }
+    return compact({ min, max });
+}
+// The text `key` holds, trimmed, or '' when absent. A number is read as its
+// text; any other kind is refused.
+function textPart(value, key) {
+    const text = value[key];
+    if (text === undefined || text === null) {
+        return '';
+    }
+    if (typeof text !== 'string' && typeof text !== 'number') {
+        throw new Error(`${key} must be text.`);
+    }
+    return String(text).trim();
+}
+// A calendar-day bound: its first ten characters must be a real day.
+function dayPart(value, key) {
+    const text = textPart(value, key);
+    if (text === '') {
+        return null;
+    }
+    const day = text.slice(0, 10);
+    if (!isCalendarDay(day)) {
+        throw new Error(`${key} must be a yyyy-MM-dd day.`);
+    }
+    return day;
+}
+// The picks of `key` with blanks (null, '') dropped, or null when none is
+// left. A lone pick is a list of one; a pick that is a list or an object is
+// refused.
+function pickList(value, key) {
+    const raw = value[key] ?? [];
+    const picks = Array.isArray(raw) ? raw : [raw];
+    if (picks.some((pick) => isSet(pick) && !isScalar(pick))) {
+        throw new Error(`Each pick in ${key} must be a plain value, not a list.`);
+    }
+    const kept = picks.filter((pick) => isSet(pick) && pick !== '');
+    return kept.length ? kept : null;
+}
+// One end of a number range: null when absent or blank, else a finite number
+// (numeric text is read as its number).
+function boundPart(value, key) {
+    const raw = typeof value[key] === 'string' ? value[key].trim() : value[key];
+    if (!isSet(raw) || raw === '') {
+        return null;
+    }
+    const bound = typeof raw === 'string' ? numberFromText(raw) : raw;
+    if (typeof bound !== 'number' || !Number.isFinite(bound)) {
+        throw new Error(`${key} must be a finite number.`);
+    }
+    return bound;
+}
+function requireSize(doc) {
+    if (new TextEncoder().encode(JSON.stringify(doc)).length > VIEW_CONFIG_MAX_BYTES) {
+        throw new Error('A view config is over 32 KB.');
+    }
+}
+function requireVersion(version) {
+    if (!isSet(version)) {
+        throw new Error('A view config needs its version (v).');
+    }
+    if (version !== REPORT_VIEW_CONFIG_VERSION) {
+        throw new Error(`This viewer reads view config version ${REPORT_VIEW_CONFIG_VERSION} only.`);
+    }
+}
+function requireMatch(match) {
+    if (match !== 'all' && match !== 'any') {
+        throw new Error('match must be all or any.');
+    }
+    return match;
+}
+// Group id -> value. A value no group type could hold is dropped whole.
+function viewGroups(raw) {
+    const entries = Object.entries(requireObject(raw, 'groups must map group ids to values.'));
+    if (entries.length > VIEW_CONFIG_MAX_GROUPS) {
+        throw new Error(`A view holds at most ${VIEW_CONFIG_MAX_GROUPS} groups.`);
+    }
+    const groups = {};
+    entries.forEach(([key, value]) => {
+        const id = requireIdKey(key, 'groups');
+        requirePickCount(value);
+        const kept = value === null ? null : storedGroupValue(value);
+        if (kept !== undefined) {
+            groups[id] = kept;
+        }
+    });
+    return groups;
+}
+// A stored group value, read for the one type its keys belong to (an empty
+// value fits every type), or undefined when it fits none.
+function storedGroupValue(value) {
+    if (!isPlainObject(value)) {
+        return undefined;
+    }
+    const keys = Object.keys(value);
+    const type = Object.keys(GROUP_VALUE_KEYS)
+        .find((candidate) => keys.every((key) => GROUP_VALUE_KEYS[candidate].includes(key)));
+    return type ? (groupValueFromStored(value, type) ?? undefined) : undefined;
+}
+function requirePickCount(value) {
+    const lists = isPlainObject(value) ? [value.values, value.excludeValues] : [];
+    if (lists.some((list) => Array.isArray(list) && list.length > GROUP_VALUE_MAX_PICKS)) {
+        throw new Error(`A group value holds at most ${GROUP_VALUE_MAX_PICKS} values.`);
+    }
+}
+// Component id -> tile state.
+function viewTiles(raw) {
+    const entries = Object.entries(requireObject(raw, 'tiles must map component ids to tile states.'));
+    if (entries.length > VIEW_CONFIG_MAX_TILES) {
+        throw new Error(`A view holds at most ${VIEW_CONFIG_MAX_TILES} tiles.`);
+    }
+    const tiles = {};
+    entries.forEach(([key, value]) => {
+        tiles[requireIdKey(key, 'tiles')] = viewTile(value);
+    });
+    return tiles;
+}
+function viewTile(raw) {
+    const tile = requireObject(raw, 'A tile state must be an object.');
+    const state = otherKeys(tile, TILE_STATE_KEYS);
+    if (isSet(tile.sort)) {
+        state.sort = viewSort(tile.sort);
+    }
+    if (isSet(tile.search)) {
+        state.search = requireString(tile.search, 'search must be text.');
+    }
+    if (isSet(tile.hidden)) {
+        state.hidden = viewHidden(tile.hidden);
+    }
+    if (isSet(tile.drill)) {
+        state.drill = viewDrill(tile.drill);
+    }
+    return state;
+}
+function viewSort(raw) {
+    const sort = requireObject(raw, 'sort must be a column and a direction.');
+    const column = requireString(sort.column, 'sort must name a column.');
+    if (column === '' || (isSet(sort.direction) && sort.direction !== 'asc' && sort.direction !== 'desc')) {
+        throw new Error('sort must be a column and a direction.');
+    }
+    return sort.direction ? { column, direction: sort.direction } : { column };
+}
+function viewHidden(raw) {
+    if (!Array.isArray(raw) || raw.some((name) => typeof name !== 'string')) {
+        throw new Error('hidden must list column names.');
+    }
+    return [...raw];
+}
+function viewDrill(raw) {
+    if (!Array.isArray(raw)) {
+        throw new Error('drill must list steps.');
+    }
+    if (raw.length > DRILL_MAX_DEPTH) {
+        throw new Error(`A drill path holds at most ${DRILL_MAX_DEPTH} steps.`);
+    }
+    return raw.map((step) => {
+        if (!isPlainObject(step) || !isChartGranularity(step.level) || !isDrillValue(step.value)) {
+            throw new Error('A drill step needs a time level and a value.');
+        }
+        return { level: step.level, value: step.value };
+    });
+}
+function isDrillValue(value) {
+    return value === null || typeof value === 'string' || typeof value === 'number';
+}
+// The keys of `source` that are not in `known`, as they were.
+function otherKeys(source, known) {
+    return Object.fromEntries(Object.entries(source).filter(([key]) => !known.includes(key)));
+}
+function optionalId(raw, refusal) {
+    if (!isSet(raw)) {
+        return null;
+    }
+    if (!Number.isInteger(raw) || raw < 1) {
+        throw new Error(refusal);
+    }
+    return raw;
+}
+function requireIdKey(key, where) {
+    if (!ID_KEY_PATTERN.test(key)) {
+        throw new Error(`${where} are keyed by id, not by '${key}'.`);
+    }
+    return Number(key);
+}
+function requireGranularity(raw, refusal) {
+    if (!isChartGranularity(raw)) {
+        throw new Error(refusal);
+    }
+    return raw;
+}
+function requireString(raw, refusal) {
+    if (typeof raw !== 'string') {
+        throw new Error(refusal);
+    }
+    return raw;
+}
+function requireObject(raw, refusal) {
+    if (!isPlainObject(raw)) {
+        throw new Error(refusal);
+    }
+    return raw;
+}
+function isSet(value) {
+    return value !== undefined && value !== null;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isScalar(value) {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+// Only the parts that hold something.
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, part]) => isSet(part)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-view-config.js","sourceRoot":"","sources":["../../../../src/app/reports/report-view-config.ts"],"names":[],"mappings":"AA0BA,OAAO,EAIL,mBAAmB,GAIpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAGvE,4CAA4C;AAC5C,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC;AAE5C,6CAA6C;AAC7C,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,GAAG,IAAI,CAAC;AAC/C,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAC;AAC1C,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AACzC,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AACzC,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC;AAEjC,4EAA4E;AAC5E,0EAA0E;AAC1E,oBAAoB;AACpB,MAAM,eAAe,GAAsC;IACzD,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,IAAI;IACd,SAAS,EAAE,IAAI;IACf,UAAU,EAAE,IAAI;IAChB,WAAW,EAAE,IAAI;IACjB,WAAW,EAAE,IAAI;IACjB,YAAY,EAAE,IAAI;IAClB,SAAS,EAAE,IAAI;IACf,WAAW,EAAE,IAAI;IACjB,QAAQ,EAAE,IAAI;IACd,UAAU,EAAE,IAAI;CACjB,CAAC;AAEF,yEAAyE;AACzE,oDAAoD;AACpD,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,IAAI,CAAC,eAAe,CAA0B,CAAC;AAE1F,wDAAwD;AACxD,MAAM,gBAAgB,GAAoE;IACxF,SAAS,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,KAAK,CAAC;IACvC,MAAM,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,OAAO,EAAE,CAAC,OAAO,CAAC;IAClB,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;CAC5B,CAAC;AAEF,yEAAyE;AACzE,+BAA+B;AAC/B,MAAM,gBAAgB,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;AAChF,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;AAE9D,MAAM,WAAW,GAAG,2BAA2B,CAAC;AAEhD,+CAA+C;AAC/C,MAAM,cAAc,GAAG,+CAA+C,CAAC;AAEvE,MAAM,cAAc,GAAG,YAAY,CAAC;AAGpC,0DAA0D;AAC1D,MAAM,UAAU,eAAe,CAAC,IAAa;IAC3C,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;AACjG,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,KAAK,KAAK,CAAC,CAAC;AACtE,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACrC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACtD,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IAEtD,OAAO,IAAI,CAAC,cAAc,EAAE,KAAK,IAAI,IAAI,IAAI,CAAC,WAAW,EAAE,KAAK,KAAK,GAAG,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,KAAK,GAAG,CAAC;AACzG,CAAC;AAED,2EAA2E;AAC3E,4BAA4B;AAC5B,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAE9D,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AACjD,CAAC;AAED,6EAA6E;AAC7E,0EAA0E;AAC1E,gEAAgE;AAChE,MAAM,UAAU,mBAAmB,CAAC,KAA8B,EAAE,IAAsB;IACxF,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAE9B,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,WAAW;YACd,OAAO,cAAc,CAAC,KAAK,CAAC,CAAC;QAE/B,KAAK,QAAQ;YACX,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC;QAE5B,KAAK,aAAa;YAChB,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAEjC;YACE,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;AACH,CAAC;AAED,qEAAqE;AACrE,8DAA8D;AAC9D,MAAM,UAAU,oBAAoB,CAAC,KAAc,EAAE,IAAsB;IACzE,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC;QACH,OAAO,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,wEAAwE;AACxE,mEAAmE;AACnE,MAAM,UAAU,mBAAmB,CAAC,KAAc;IAChD,MAAM,GAAG,GAAG,aAAa,CAAC,KAAK,EAAE,kCAAkC,CAAC,CAAC;IACrE,WAAW,CAAC,GAAG,CAAC,CAAC;IACjB,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAEtB,MAAM,MAAM,GAAG,EAAE,CAAC,EAAE,0BAA0B,EAAE,GAAG,SAAS,CAAC,GAAG,EAAE,gBAAgB,CAAC,EAAsB,CAAC;IAC1G,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,MAAM,EAAE,2BAA2B,CAAC,CAAC;IACnE,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;IACzB,CAAC;IAED,IAAI,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;QACvB,MAAM,CAAC,OAAO,GAAG,kBAAkB,CAAC,GAAG,CAAC,OAAO,EAAE,+BAA+B,CAAC,CAAC;IACpF,CAAC;IAED,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QACrB,MAAM,CAAC,KAAK,GAAG,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QACtB,MAAM,CAAC,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IAED,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QACrB,MAAM,CAAC,KAAK,GAAG,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,6DAA6D;AAC7D,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,sBAAsB;AACtB,MAAM,UAAU,kBAAkB,CAChC,IAAsB,EACtB,KAA0C;IAE1C,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,IAAI,CAAC;IACd,CAAC;IAED,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,WAAW;YACd,OAAO,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC;gBAClC,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,MAAM,EAAE;gBAC5B,CAAC,CAAC,YAAY,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAE7F,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,MAAM,aAAa,GAAG,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;YAErD,OAAO,YAAY,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAC/F,CAAC;QAED,KAAK,aAAa;YAChB,OAAO,YAAY,CAAC,EAAE,GAAG,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAEtF;YACE,OAAO,YAAY,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,SAAS,EAAE,CAAC,CAAC;IACrE,CAAC;AACH,CAAC;AAED,2EAA2E;AAC3E,6EAA6E;AAC7E,0EAA0E;AAC1E,8DAA8D;AAC9D,MAAM,UAAU,gBAAgB,CAC9B,IAAsB,EACtB,MAA6C,EAC7C,eAAoE;IAEpE,IAAI,CAAC,MAAM,IAAI,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;QACzB,OAAO,EAAE,GAAG,MAAM,EAAE,CAAC;IACvB,CAAC;IAED,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;QACpB,MAAM,KAAK,GAAG,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAE/C,OAAO,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IACxF,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;AAChF,CAAC;AAED,2EAA2E;AAC3E,6EAA6E;AAC7E,6EAA6E;AAC7E,4EAA4E;AAC5E,4EAA4E;AAC5E,6EAA6E;AAC7E,0EAA0E;AAC1E,yBAAyB;AACzB,MAAM,UAAU,WAAW,CACzB,IAAsB,EACtB,OAAyB,EACzB,WAAoC,IAAI;IAExC,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI,KAAK,CAAC;WACpD,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC;WACpD,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC;WACrC,WAAW,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,EAAE,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;AAC1D,CAAC;AAED,4EAA4E;AAC5E,0EAA0E;AAC1E,MAAM,UAAU,oBAAoB,CAClC,CAAwC,EACxC,CAAwC;IAExC,OAAO,cAAc,CAAC,CAAC,CAAC,KAAK,cAAc,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC;AAED,6EAA6E;AAC7E,4EAA4E;AAC5E,gCAAgC;AAChC,MAAM,UAAU,cAAc,CAAC,IAA2C;IACxE,MAAM,IAAI,GAAsB,EAAE,CAAC;IAEnC,KAAK,MAAM,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,CAAC;QAC9B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC;eACnF,IAAI,CAAC,MAAM,KAAK,eAAe,EAAE,CAAC;YACrC,MAAM;QACR,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IACtD,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,2EAA2E;AAC3E,wCAAwC;AACxC,MAAM,UAAU,aAAa,CAC3B,CAAgD,EAChD,CAAgD;IAEhD,OAAO,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;AACrC,CAAC;AAED,4EAA4E;AAC5E,6EAA6E;AAC7E,2EAA2E;AAC3E,QAAQ;AACR,MAAM,UAAU,cAAc,CAAC,MAA2C,EAAE,MAAwB;IAClG,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,KAAK,GAAoC,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;IAEnE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,EAAE;QACjE,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAEzE,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;YAC7B,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC;QAC1E,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,MAAM,MAAM,GAAqB,EAAE,GAAG,SAAS,CAAC,MAA4C,EAAE,gBAAgB,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC;IAC7H,OAAO,MAAM,CAAC,KAAK,CAAC;IAEpB,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;AACnE,CAAC;AAED,uEAAuE;AACvE,2EAA2E;AAC3E,4EAA4E;AAC5E,4EAA4E;AAC5E,6EAA6E;AAC7E,mEAAmE;AACnE,MAAM,UAAU,gBAAgB,CAAC,IAA4C,EAAE,OAAyB;IACtG,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAC7B,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,IAAI,EAAE,CAAC;SACrD,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,EAAE,EAAE,OAAO,CAAC,CAAC;SACpH,MAAM,CAAC;IACV,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE,CAAC;SACnD,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,KAAK,GAAG,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAE/G,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,GAAG,KAAK,CAAC;AACnH,CAAC;AAED,2EAA2E;AAC3E,yEAAyE;AACzE,oCAAoC;AACpC,MAAM,UAAU,kBAAkB,CAAC,KAAa,EAAE,SAAS,GAAG,IAAI;IAChE,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,IAAI,GAAG,KAAK,KAAK,CAAC;QACtB,CAAC,CAAC,uEAAuE;QACzE,CAAC,CAAC,GAAG,KAAK,qEAAqE,CAAC;IAElF,OAAO,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,mCAAmC,CAAC,CAAC,CAAC,IAAI,CAAC;AACvE,CAAC;AAED,wEAAwE;AACxE,4DAA4D;AAC5D,MAAM,UAAU,cAAc,CAC5B,QAA8C,EAC9C,WAAoB;IAEpB,OAAO,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AAC9D,CAAC;AAED,SAAS,YAAY,CAAC,IAAsB,EAAE,OAAyB,EAAE,QAAiC;IACxG,OAAO,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,EAAE;QACpE,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC;YACpF,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC9B,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;QAExC,OAAO,cAAc,CAAC,IAAI,CAAC,KAAK,cAAc,CAAC,KAAK,CAAC,CAAC;IACxD,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,WAAW,CAAC,IAAqC,EAAE,OAAwC;IAClG,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAEjF,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;AAChH,CAAC;AAED,wEAAwE;AACxE,yEAAyE;AACzE,iBAAiB;AACjB,SAAS,YAAY,CAAC,MAAmC,EAAE,OAAoC;IAC7F,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,CAAC,CAAC;IACX,CAAC;IAED,OAAO;QACL,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM;QAC/C,CAAC,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,OAAO,EAAE,MAAM;QACnC,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC;QAC7D,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM;KAC3D,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;AAC3B,CAAC;AAED,2EAA2E;AAC3E,4EAA4E;AAC5E,QAAQ;AACR,SAAS,cAAc,CAAC,KAA4C;IAClE,MAAM,MAAM,GAAG,KAAK,IAAI,EAAE,CAAC;IAC3B,MAAM,KAAK,GAAG,CAAC,IAA2B,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;IAE/F,OAAO,IAAI,CAAC,SAAS,CAAC;QACpB,MAAM,CAAC,QAAQ,IAAI,IAAI;QACvB,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,IAAI;QAClC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,IAAI;QAChC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC;QACpB,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE;QAC3B,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI;QAChC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI;KACjC,CAAC,CAAC;AACL,CAAC;AAED,6EAA6E;AAC7E,iDAAiD;AACjD,SAAS,YAAY,CAAC,IAAiC;IACrD,OAAO,IAAI,CAAC,SAAS,CAAC;QACpB,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI;QAC5E,IAAI,EAAE,MAAM,IAAI,EAAE;QAClB,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE;QAChC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;KACtB,CAAC,CAAC;AACL,CAAC;AAED,SAAS,QAAQ,CAAC,IAAmD;IACnE,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC;SAC/B,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/G,CAAC;AAED,8EAA8E;AAC9E,WAAW;AACX,SAAS,SAAS,CAAC,IAAkC;IACnD,MAAM,IAAI,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC;IAEvE,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AACxC,CAAC;AAED,uEAAuE;AACvE,6DAA6D;AAC7D,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAEhF,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AACpF,CAAC;AAED,4DAA4D;AAC5D,SAAS,YAAY,CAAC,MAA0B;IAC9C,OAAO,cAAc,CAAC,MAAM,CAAC,KAAK,cAAc,CAAC,IAAI,CAAC,CAAC;AACzD,CAAC;AAED,8DAA8D;AAC9D,SAAS,YAAY,CAAC,KAA8B;IAClD,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAE9B,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AACpD,CAAC;AAED,SAAS,gBAAgB,CAAC,KAA8B,EAAE,IAAsB;IAC9E,MAAM,OAAO,GAAsB,gBAAgB,CAAC,IAAI,CAAC,IAAI,gBAAgB,CAAC,OAAO,CAAC;IACtF,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IAE3E,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,KAAK,IAAI,kBAAkB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChG,CAAC;AACH,CAAC;AAED,+CAA+C;AAC/C,SAAS,cAAc,CAAC,KAA8B;IACpD,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;IAC7C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACtC,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAElC,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;QACpB,OAAO,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IACjC,CAAC;IAED,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,iFAAiF,CAAC,CAAC;IACrG,CAAC;IAED,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,KAAK,CAAC,4BAA4B,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC1F,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,CAAC;AACtB,CAAC;AAED,6DAA6D;AAC7D,SAAS,WAAW,CAAC,KAA8B;IACjD,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACzC,MAAM,aAAa,GAAG,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;IAEvD,IAAI,MAAM,KAAK,IAAI,IAAI,aAAa,KAAK,IAAI,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,8EAA8E,CAAC,CAAC;IAClG,CAAC;IAED,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;AAC5C,CAAC;AAED,SAAS,YAAY,CAAC,KAA8B;IAClD,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAEtC,OAAO,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AAC5C,CAAC;AAED,sDAAsD;AACtD,SAAS,gBAAgB,CAAC,KAA8B;IACtD,MAAM,GAAG,GAAG,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACpC,MAAM,GAAG,GAAG,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAEpC,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,QAAQ,GAAG,mBAAmB,GAAG,IAAI,CAAC,CAAC;IACzD,CAAC;IAED,OAAO,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;AAC/B,CAAC;AAED,4EAA4E;AAC5E,mCAAmC;AACnC,SAAS,QAAQ,CAAC,KAA8B,EAAE,GAAW;IAC3D,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;IACxB,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QACxC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QACzD,MAAM,IAAI,KAAK,CAAC,GAAG,GAAG,gBAAgB,CAAC,CAAC;IAC1C,CAAC;IAED,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;AAC7B,CAAC;AAED,qEAAqE;AACrE,SAAS,OAAO,CAAC,KAA8B,EAAE,GAAW;IAC1D,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAClC,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC9B,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,GAAG,GAAG,4BAA4B,CAAC,CAAC;IACtD,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED,0EAA0E;AAC1E,4EAA4E;AAC5E,WAAW;AACX,SAAS,QAAQ,CAAC,KAA8B,EAAE,GAAW;IAC3D,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;IAC7B,MAAM,KAAK,GAAc,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAE1D,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;QACzD,MAAM,IAAI,KAAK,CAAC,gBAAgB,GAAG,qCAAqC,CAAC,CAAC;IAC5E,CAAC;IAED,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC;IAEhE,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;AACnC,CAAC;AAED,6EAA6E;AAC7E,wCAAwC;AACxC,SAAS,SAAS,CAAC,KAA8B,EAAE,GAAW;IAC5D,MAAM,GAAG,GAAG,OAAO,KAAK,CAAC,GAAG,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAE,KAAK,CAAC,GAAG,CAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACxF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,GAAG,KAAK,EAAE,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,KAAK,GAAG,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAClE,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACzD,MAAM,IAAI,KAAK,CAAC,GAAG,GAAG,2BAA2B,CAAC,CAAC;IACrD,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,WAAW,CAAC,GAA4B;IAC/C,IAAI,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,qBAAqB,EAAE,CAAC;QACjF,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;IAClD,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,OAAgB;IACtC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAC1D,CAAC;IAED,IAAI,OAAO,KAAK,0BAA0B,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,yCAAyC,0BAA0B,QAAQ,CAAC,CAAC;IAC/F,CAAC;AACH,CAAC;AAED,SAAS,YAAY,CAAC,KAAc;IAClC,IAAI,KAAK,KAAK,KAAK,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,wEAAwE;AACxE,SAAS,UAAU,CAAC,GAAY;IAC9B,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,EAAE,sCAAsC,CAAC,CAAC,CAAC;IAC3F,IAAI,OAAO,CAAC,MAAM,GAAG,sBAAsB,EAAE,CAAC;QAC5C,MAAM,IAAI,KAAK,CAAC,wBAAwB,sBAAsB,UAAU,CAAC,CAAC;IAC5E,CAAC;IAED,MAAM,MAAM,GAA8C,EAAE,CAAC;IAC7D,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;QAC/B,MAAM,EAAE,GAAG,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACvC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACxB,MAAM,IAAI,GAAG,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAE7D,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;QACpB,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,2EAA2E;AAC3E,0DAA0D;AAC1D,SAAS,gBAAgB,CAAC,KAAc;IACtC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAChC,MAAM,IAAI,GAAI,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAwB;SAC/D,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAE,gBAAgB,CAAC,SAAS,CAAuB,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAE9G,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC7E,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAc;IACtC,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAE9E,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,qBAAqB,CAAC,EAAE,CAAC;QACrF,MAAM,IAAI,KAAK,CAAC,+BAA+B,qBAAqB,UAAU,CAAC,CAAC;IAClF,CAAC;AACH,CAAC;AAED,8BAA8B;AAC9B,SAAS,SAAS,CAAC,GAAY;IAC7B,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,EAAE,8CAA8C,CAAC,CAAC,CAAC;IACnG,IAAI,OAAO,CAAC,MAAM,GAAG,qBAAqB,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,wBAAwB,qBAAqB,SAAS,CAAC,CAAC;IAC1E,CAAC;IAED,MAAM,KAAK,GAAoC,EAAE,CAAC;IAClD,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;QAC/B,KAAK,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,QAAQ,CAAC,GAAY;IAC5B,MAAM,IAAI,GAAG,aAAa,CAAC,GAAG,EAAE,iCAAiC,CAAC,CAAC;IACnE,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,EAAE,eAAe,CAAoB,CAAC;IAElE,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,KAAK,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACvB,KAAK,CAAC,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;IACpE,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACvB,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACtB,KAAK,CAAC,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,QAAQ,CAAC,GAAY;IAC5B,MAAM,IAAI,GAAG,aAAa,CAAC,GAAG,EAAE,wCAAwC,CAAC,CAAC;IAC1E,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;IACtE,IAAI,MAAM,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,IAAI,IAAI,CAAC,SAAS,KAAK,MAAM,CAAC,EAAE,CAAC;QACtG,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IAC5D,CAAC;IAED,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,SAAoC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC;AACxG,CAAC;AAED,SAAS,UAAU,CAAC,GAAY;IAC9B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,EAAE,CAAC;QACxE,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC;AAClB,CAAC;AAED,SAAS,SAAS,CAAC,GAAY;IAC7B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,GAAG,CAAC,MAAM,GAAG,eAAe,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,8BAA8B,eAAe,SAAS,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,IAAa,EAAE,EAAE;QAC/B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACzF,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;QAClE,CAAC;QAED,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;IAClD,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,YAAY,CAAC,KAAc;IAClC,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC;AAClF,CAAC;AAED,8DAA8D;AAC9D,SAAS,SAAS,CAAC,MAA+B,EAAE,KAAwB;IAC1E,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAC5F,CAAC;AAED,SAAS,UAAU,CAAC,GAAY,EAAE,OAAe;IAC/C,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,IAAK,GAAc,GAAG,CAAC,EAAE,CAAC;QAClD,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAED,OAAO,GAAa,CAAC;AACvB,CAAC;AAED,SAAS,YAAY,CAAC,GAAW,EAAE,KAAa;IAC9C,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,6BAA6B,GAAG,IAAI,CAAC,CAAC;IAChE,CAAC;IAED,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;AACrB,CAAC;AAED,SAAS,kBAAkB,CAAC,GAAY,EAAE,OAAe;IACvD,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,aAAa,CAAC,GAAY,EAAE,OAAe;IAClD,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,aAAa,CAAC,GAAY,EAAE,OAAe;IAClD,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,KAAK,CAAC,KAAc;IAC3B,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,CAAC;AAC/C,CAAC;AAED,SAAS,aAAa,CAAC,KAAc;IACnC,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAED,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,SAAS,CAAC;AAC9F,CAAC;AAED,sCAAsC;AACtC,SAAS,OAAO,CAAC,KAA8B;IAC7C,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAuB,CAAC;AAC3G,CAAC","sourcesContent":["// The viewer's durable state as one document (ReportViewConfig, version 1): a\n// saved view's config.\n// Pure, so the node harness runs it against the server's own case table: the\n// rules below mirror the server's ReportViewConfig and ReportFilterGroupValue\n// DTOs, and the two must agree on every case.\n//\n// - A group value takes the keys its group's type owns (groupValueFromArray).\n//   One written in a shape that does not fit is refused, naming what is\n//   wrong; one read back that does not fit is dropped whole, never applied in\n//   part (groupValueFromStored).\n// - A document (viewConfigFromArray) is refused when it is not one, breaks a\n//   cap or holds a malformed known key. Keys this viewer does not know, at\n//   the top and in a tile, are kept as they were and never read. A group\n//   value that no group type could hold is dropped whole.\n// - The viewer's state service turns its values into this shape and back\n//   (toStoredGroupValue, toLiveGroupValue), and asks viewDiffers whether the\n//   screen still shows the open view.\n// - The view service (ReportViewService) saves a view through withStoredKeys\n//   and counts what a view lost through viewDroppedCount; the chat names the\n//   open view through chatViewFields.\nimport { ReportChatViewerState } from './interfaces/report-chat-viewer-state.interface';\nimport { ReportDrillStep } from './interfaces/report-drill-step.interface';\nimport { ReportTileState } from './interfaces/report-tile-state.interface';\nimport { ReportViewConfig } from './interfaces/report-view-config.interface';\nimport { ReportViewSummary } from './interfaces/report-view-summary.interface';\nimport { ReportView } from './interfaces/report-view.interface';\nimport {\n  ChartGranularity,\n  FilterGroupDefault,\n  FilterGroupValue,\n  GRANULARITY_OPTIONS,\n  ReportFilterType,\n  ReportRelativeRange,\n  ReportSort,\n} from './interfaces/report.interface';\nimport { dateBoundString, dateFromBound } from './report-filter-items';\n\n\n// The version this viewer writes and reads.\nexport const REPORT_VIEW_CONFIG_VERSION = 1;\n\n// The caps of a view document, the server's.\nexport const VIEW_CONFIG_MAX_BYTES = 32 * 1024;\nexport const VIEW_CONFIG_MAX_GROUPS = 100;\nexport const VIEW_CONFIG_MAX_TILES = 200;\nexport const GROUP_VALUE_MAX_PICKS = 500;\nexport const DRILL_MAX_DEPTH = 5;\n\n// Every relative range name the server knows, in its enum's order. A record\n// rather than a list, so the build fails when ReportRelativeRange gains a\n// name this misses.\nconst RELATIVE_RANGES: Record<ReportRelativeRange, true> = {\n  thisWeek: true,\n  lastWeek: true,\n  last7Days: true,\n  last30Days: true,\n  last3Months: true,\n  last6Months: true,\n  last12Months: true,\n  thisMonth: true,\n  thisQuarter: true,\n  thisYear: true,\n  yearToDate: true,\n};\n\n// The same names as a list, in the server enum's order (the record's key\n// order): the order the date picker offers them in.\nexport const RELATIVE_RANGE_NAMES = Object.keys(RELATIVE_RANGES) as ReportRelativeRange[];\n\n// The keys a group value may hold, by its group's type.\nconst GROUP_VALUE_KEYS: Record<ReportFilterType, readonly (keyof FilterGroupDefault)[]> = {\n  dateRange: ['relative', 'start', 'end'],\n  select: ['values', 'excludeValues'],\n  keyword: ['value'],\n  numberRange: ['min', 'max'],\n};\n\n// The keys of a view document and of a tile state this viewer reads. Any\n// other key is kept as it was.\nconst VIEW_CONFIG_KEYS = ['v', 'pageId', 'groupBy', 'match', 'groups', 'tiles'];\nconst TILE_STATE_KEYS = ['sort', 'search', 'hidden', 'drill'];\n\nconst DAY_PATTERN = /^(\\d{4})-(\\d{2})-(\\d{2})$/;\n\n// A number as text: what a masked input sends.\nconst NUMBER_PATTERN = /^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i;\n\nconst ID_KEY_PATTERN = /^[1-9]\\d*$/;\n\n\n// Whether a name is a relative range the server resolves.\nexport function isRelativeRange(name: unknown): name is ReportRelativeRange {\n  return typeof name === 'string' && Object.prototype.hasOwnProperty.call(RELATIVE_RANGES, name);\n}\n\nexport function isChartGranularity(value: unknown): value is ChartGranularity {\n  return GRANULARITY_OPTIONS.some((option) => option.value === value);\n}\n\n// Whether text is a real calendar day written 'yyyy-MM-dd' (no 2026-02-30).\nexport function isCalendarDay(text: string): boolean {\n  const parts = DAY_PATTERN.exec(text);\n  if (!parts) {\n    return false;\n  }\n\n  const [year, month, day] = parts.slice(1).map(Number);\n  const date = new Date(Date.UTC(year, month - 1, day));\n\n  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;\n}\n\n// A number written as text (a masked input's value), or null when the text\n// is not one finite number.\nexport function numberFromText(text: string): number | null {\n  const number = NUMBER_PATTERN.test(text) ? Number(text) : NaN;\n\n  return Number.isFinite(number) ? number : null;\n}\n\n// A group value read for a group of `type`, on its way to being stored: only\n// the parts that hold something. Throws, naming what is wrong, when a key\n// does not belong to the type or a part breaks its type's rule.\nexport function groupValueFromArray(value: Record<string, unknown>, type: ReportFilterType): FilterGroupDefault {\n  requireGroupKeys(value, type);\n\n  switch (type) {\n    case 'dateRange':\n      return dateRangeValue(value);\n\n    case 'select':\n      return selectValue(value);\n\n    case 'numberRange':\n      return numberRangeValue(value);\n\n    default:\n      return keywordValue(value);\n  }\n}\n\n// A group value read back (a saved view) for a group of `type`: what\n// groupValueFromArray gives, or null when it would refuse it.\nexport function groupValueFromStored(value: unknown, type: ReportFilterType): FilterGroupDefault | null {\n  if (!isPlainObject(value)) {\n    return null;\n  }\n\n  try {\n    return groupValueFromArray(value, type);\n  } catch {\n    return null;\n  }\n}\n\n// A view document read for storing or applying. Throws when it is not a\n// version 1 document, breaks a cap or holds a malformed known key.\nexport function viewConfigFromArray(input: unknown): ReportViewConfig {\n  const doc = requireObject(input, 'A view config must be an object.');\n  requireSize(doc);\n  requireVersion(doc.v);\n\n  const config = { v: REPORT_VIEW_CONFIG_VERSION, ...otherKeys(doc, VIEW_CONFIG_KEYS) } as ReportViewConfig;\n  const pageId = optionalId(doc.pageId, 'pageId must be a page id.');\n  if (pageId !== null) {\n    config.pageId = pageId;\n  }\n\n  if (isSet(doc.groupBy)) {\n    config.groupBy = requireGranularity(doc.groupBy, 'groupBy must be a time grain.');\n  }\n\n  if (isSet(doc.match)) {\n    config.match = requireMatch(doc.match);\n  }\n\n  if (isSet(doc.groups)) {\n    config.groups = viewGroups(doc.groups);\n  }\n\n  if (isSet(doc.tiles)) {\n    config.tiles = viewTiles(doc.tiles);\n  }\n\n  return config;\n}\n\n// A group's value as a view stores it, read for the keys its\n// group's type owns, or null when it holds nothing. A date range that still\n// carries its relative preset is stored as that preset whatever today is: the\n// viewer did not edit it, so a view saved after midnight with the page still\n// open keeps rolling.\nexport function toStoredGroupValue(\n  type: ReportFilterType,\n  value: FilterGroupValue | null | undefined,\n): FilterGroupDefault | null {\n  if (!value) {\n    return null;\n  }\n\n  switch (type) {\n    case 'dateRange':\n      return isRelativeRange(value.preset)\n        ? { relative: value.preset }\n        : storedOrNull({ start: dateBoundString(value.start), end: dateBoundString(value.end) });\n\n    case 'select': {\n      const excludeValues = keptPicks(value.excludeValues);\n\n      return storedOrNull(excludeValues ? { excludeValues } : { values: keptPicks(value.values) });\n    }\n\n    case 'numberRange':\n      return storedOrNull({ min: finiteNumber(value.min), max: finiteNumber(value.max) });\n\n    default:\n      return storedOrNull({ value: value.value?.trim() || undefined });\n  }\n}\n\n// A group value in its stored shape as the value the bars and the requests\n// read: a relative preset as today's days in the report's zone, carrying its\n// name; fixed days as dates; any other value as it is. Null when it holds\n// nothing, or names a preset `resolveRelative` does not know.\nexport function toLiveGroupValue(\n  type: ReportFilterType,\n  stored: FilterGroupDefault | null | undefined,\n  resolveRelative: (name: string) => { start: Date; end: Date } | null,\n): FilterGroupValue | null {\n  if (!stored || holdsNothing(stored)) {\n    return null;\n  }\n\n  if (type !== 'dateRange') {\n    return { ...stored };\n  }\n\n  if (stored.relative) {\n    const range = resolveRelative(stored.relative);\n\n    return range ? { start: range.start, end: range.end, preset: stored.relative } : null;\n  }\n\n  return { start: dateFromBound(stored.start), end: dateFromBound(stored.end) };\n}\n\n// Whether the screen's state differs from the view it opened on. `current`\n// is a snapshot, so it holds every group the report has; a group only `base`\n// holds is one the report no longer has, and is not compared. A group `base`\n// does not hold was added after the view was saved: it is compared with its\n// value in `authored` (the report's defaults), so leaving it at its default\n// changes nothing. The page is not compared (moving to another page does not\n// edit a view), and neither are keys this viewer does not know. Picks are\n// compared in any order.\nexport function viewDiffers(\n  base: ReportViewConfig,\n  current: ReportViewConfig,\n  authored: ReportViewConfig | null = null,\n): boolean {\n  return (base.match ?? 'all') !== (current.match ?? 'all')\n    || (base.groupBy ?? null) !== (current.groupBy ?? null)\n    || groupsDiffer(base, current, authored)\n    || tilesDiffer(base.tiles ?? {}, current.tiles ?? {});\n}\n\n// Whether two stored group values are the same filter, as viewDiffers reads\n// a group: picks in any order, text trimmed, an empty value read as none.\nexport function sameStoredGroupValue(\n  a: FilterGroupDefault | null | undefined,\n  b: FilterGroupDefault | null | undefined,\n): boolean {\n  return storedValueKey(a) === storedValueKey(b);\n}\n\n// A drill path kept to what a tile can carry: its steps up to the first that\n// is not a time level with a plain value (the steps before it are kept), at\n// most DRILL_MAX_DEPTH of them.\nexport function cleanDrillPath(path: readonly unknown[] | null | undefined): ReportDrillStep[] {\n  const kept: ReportDrillStep[] = [];\n\n  for (const step of path ?? []) {\n    if (!isPlainObject(step) || !isChartGranularity(step.level) || !isDrillValue(step.value)\n      || kept.length === DRILL_MAX_DEPTH) {\n      break;\n    }\n\n    kept.push({ level: step.level, value: step.value });\n  }\n\n  return kept;\n}\n\n// Whether two drill paths are the same steps. A value is compared as text,\n// so 2026 and '2026' are the same step.\nexport function sameDrillPath(\n  a: readonly ReportDrillStep[] | null | undefined,\n  b: readonly ReportDrillStep[] | null | undefined,\n): boolean {\n  return drillKey(a) === drillKey(b);\n}\n\n// A view's config to save: the screen (`screen`, a snapshot), with the keys\n// this viewer does not know kept from the stored document (`stored`), at the\n// top and in each tile. They are never read here, and saving must not lose\n// them.\nexport function withStoredKeys(stored: ReportViewConfig | null | undefined, screen: ReportViewConfig): ReportViewConfig {\n  if (!stored) {\n    return screen;\n  }\n\n  const tiles: Record<number, ReportTileState> = { ...screen.tiles };\n\n  Object.entries(stored.tiles ?? {}).forEach(([componentId, tile]) => {\n    const kept = isPlainObject(tile) ? otherKeys(tile, TILE_STATE_KEYS) : {};\n\n    if (Object.keys(kept).length) {\n      tiles[Number(componentId)] = { ...kept, ...tiles[Number(componentId)] };\n    }\n  });\n\n  const config: ReportViewConfig = { ...otherKeys(stored as unknown as Record<string, unknown>, VIEW_CONFIG_KEYS), ...screen };\n  delete config.tiles;\n\n  return Object.keys(tiles).length ? { ...config, tiles } : config;\n}\n\n// How many settings of a saved view no longer apply because the report\n// changed: what the server left out when it read the view (`dropped`), and\n// what the viewer could not apply (`applied` is the view as it applied, the\n// state service's base): a group value that no longer fits its group, and a\n// list sort, search or hidden columns, or a chart's drill path, its tile can\n// no longer take (a list column gone, a chart turned into a list).\nexport function viewDroppedCount(view: Pick<ReportView, 'config' | 'dropped'>, applied: ReportViewConfig): number {\n  const dropped = view.dropped;\n  const groups = Object.entries(view.config?.groups ?? {})\n    .filter(([groupId, value]) => value !== null && !Object.prototype.hasOwnProperty.call(applied.groups ?? {}, groupId))\n    .length;\n  const tiles = Object.entries(view.config?.tiles ?? {})\n    .reduce((count, [componentId, tile]) => count + tileKeysLost(tile, applied.tiles?.[Number(componentId)]), 0);\n\n  return (dropped?.groups?.length ?? 0) + (dropped?.tiles?.length ?? 0) + (dropped?.page ? 1 : 0) + groups + tiles;\n}\n\n// The note a view opens with when some of its settings no longer apply, or\n// null when every setting applies. Only a viewer who may change the view\n// (`canChange`) is told to save it.\nexport function viewDroppedMessage(count: number, canChange = true): string | null {\n  if (count < 1) {\n    return null;\n  }\n\n  const note = count === 1\n    ? '1 setting in this view no longer applies, because the report changed.'\n    : `${count} settings in this view no longer apply, because the report changed.`;\n\n  return canChange ? `${note} Save changes to update the view.` : note;\n}\n\n// The open view as a chat turn names it: its id, and whether the screen\n// differs from it. Both are left out while no view is open.\nexport function chatViewFields(\n  openView: Pick<ReportViewSummary, 'id'> | null,\n  viewChanged: boolean,\n): Pick<ReportChatViewerState, 'viewId' | 'viewChanged'> {\n  return openView ? { viewId: openView.id, viewChanged } : {};\n}\n\nfunction groupsDiffer(base: ReportViewConfig, current: ReportViewConfig, authored: ReportViewConfig | null): boolean {\n  return Object.entries(current.groups ?? {}).some(([groupId, value]) => {\n    const kept = base.groups && Object.prototype.hasOwnProperty.call(base.groups, groupId)\n      ? base.groups[Number(groupId)]\n      : authored?.groups?.[Number(groupId)];\n\n    return storedValueKey(kept) !== storedValueKey(value);\n  });\n}\n\nfunction tilesDiffer(base: Record<number, ReportTileState>, current: Record<number, ReportTileState>): boolean {\n  const ids = new Set([...Object.keys(base), ...Object.keys(current)].map(Number));\n\n  return [...ids].some((componentId) => tileStateKey(base[componentId]) !== tileStateKey(current[componentId]));\n}\n\n// How many keys of a stored tile state the tile, as it applied, lost: a\n// sort, a search or a drill path it no longer has, and hidden columns it\n// kept fewer of.\nfunction tileKeysLost(stored: ReportTileState | undefined, applied: ReportTileState | undefined): number {\n  if (!stored) {\n    return 0;\n  }\n\n  return [\n    !!stored.sort?.column && !applied?.sort?.column,\n    !!stored.search && !applied?.search,\n    (stored.hidden?.length ?? 0) > (applied?.hidden?.length ?? 0),\n    (stored.drill?.length ?? 0) > 0 && !applied?.drill?.length,\n  ].filter(Boolean).length;\n}\n\n// One text for a stored group value, the same for every way of writing the\n// same filter: picks in any order, text trimmed, and an empty value read as\n// none.\nfunction storedValueKey(value: FilterGroupDefault | null | undefined): string {\n  const stored = value ?? {};\n  const picks = (list: unknown[] | undefined) => [...(keptPicks(list) ?? [])].map(String).sort();\n\n  return JSON.stringify([\n    stored.relative ?? null,\n    stored.start?.slice(0, 10) ?? null,\n    stored.end?.slice(0, 10) ?? null,\n    picks(stored.values),\n    picks(stored.excludeValues),\n    (stored.value ?? '').trim(),\n    finiteNumber(stored.min) ?? null,\n    finiteNumber(stored.max) ?? null,\n  ]);\n}\n\n// One text for a tile's state, over the keys this viewer reads. No direction\n// reads as ascending, the way a list applies it.\nfunction tileStateKey(tile: ReportTileState | undefined): string {\n  return JSON.stringify([\n    tile?.sort?.column ? [tile.sort.column, tile.sort.direction ?? 'asc'] : null,\n    tile?.search ?? '',\n    [...(tile?.hidden ?? [])].sort(),\n    drillKey(tile?.drill),\n  ]);\n}\n\nfunction drillKey(path: readonly ReportDrillStep[] | null | undefined): string {\n  return JSON.stringify((path ?? [])\n    .map((step) => [step.level, step.value === null || step.value === undefined ? null : String(step.value)]));\n}\n\n// The picks of a list with blanks (null, '') left out, or undefined when none\n// is left.\nfunction keptPicks(list: unknown[] | null | undefined): unknown[] | undefined {\n  const kept = (list ?? []).filter((pick) => isSet(pick) && pick !== '');\n\n  return kept.length ? kept : undefined;\n}\n\n// A range end as a number. A masked input sends its number as text, so\n// numeric text is read as its number, as boundPart reads it.\nexport function finiteNumber(value: unknown): number | undefined {\n  const number = typeof value === 'string' ? numberFromText(value.trim()) : value;\n\n  return typeof number === 'number' && Number.isFinite(number) ? number : undefined;\n}\n\n// Whether a stored value reads the same as no value at all.\nfunction holdsNothing(stored: FilterGroupDefault): boolean {\n  return storedValueKey(stored) === storedValueKey(null);\n}\n\n// Only the parts that hold something, or null when none does.\nfunction storedOrNull(value: Record<string, unknown>): FilterGroupDefault | null {\n  const stored = compact(value);\n\n  return Object.keys(stored).length ? stored : null;\n}\n\nfunction requireGroupKeys(value: Record<string, unknown>, type: ReportFilterType): void {\n  const allowed: readonly string[] = GROUP_VALUE_KEYS[type] ?? GROUP_VALUE_KEYS.keyword;\n  const unknown = Object.keys(value).filter((key) => !allowed.includes(key));\n\n  if (unknown.length) {\n    throw new Error(`A ${type} default takes ${allowed.join(', ')} — not ${unknown.join(', ')}.`);\n  }\n}\n\n// A relative range, or fixed days; never both.\nfunction dateRangeValue(value: Record<string, unknown>): FilterGroupDefault {\n  const relative = textPart(value, 'relative');\n  const start = dayPart(value, 'start');\n  const end = dayPart(value, 'end');\n\n  if (relative === '') {\n    return compact({ start, end });\n  }\n\n  if (start !== null || end !== null) {\n    throw new Error('A dateRange default is either a relative preset or a fixed start/end, not both.');\n  }\n\n  if (!isRelativeRange(relative)) {\n    throw new Error(`relative must be one of: ${Object.keys(RELATIVE_RANGES).join(', ')}.`);\n  }\n\n  return { relative };\n}\n\n// The values to keep or the values to leave out; never both.\nfunction selectValue(value: Record<string, unknown>): FilterGroupDefault {\n  const values = pickList(value, 'values');\n  const excludeValues = pickList(value, 'excludeValues');\n\n  if (values !== null && excludeValues !== null) {\n    throw new Error('A select default either keeps values or leaves out exclude_values, not both.');\n  }\n\n  return compact({ values, excludeValues });\n}\n\nfunction keywordValue(value: Record<string, unknown>): FilterGroupDefault {\n  const text = textPart(value, 'value');\n\n  return text !== '' ? { value: text } : {};\n}\n\n// Either end may be open; 0 is an end like any other.\nfunction numberRangeValue(value: Record<string, unknown>): FilterGroupDefault {\n  const min = boundPart(value, 'min');\n  const max = boundPart(value, 'max');\n\n  if (min !== null && max !== null && min > max) {\n    throw new Error(`min (${min}) is above max (${max}).`);\n  }\n\n  return compact({ min, max });\n}\n\n// The text `key` holds, trimmed, or '' when absent. A number is read as its\n// text; any other kind is refused.\nfunction textPart(value: Record<string, unknown>, key: string): string {\n  const text = value[key];\n  if (text === undefined || text === null) {\n    return '';\n  }\n\n  if (typeof text !== 'string' && typeof text !== 'number') {\n    throw new Error(`${key} must be text.`);\n  }\n\n  return String(text).trim();\n}\n\n// A calendar-day bound: its first ten characters must be a real day.\nfunction dayPart(value: Record<string, unknown>, key: string): string | null {\n  const text = textPart(value, key);\n  if (text === '') {\n    return null;\n  }\n\n  const day = text.slice(0, 10);\n  if (!isCalendarDay(day)) {\n    throw new Error(`${key} must be a yyyy-MM-dd day.`);\n  }\n\n  return day;\n}\n\n// The picks of `key` with blanks (null, '') dropped, or null when none is\n// left. A lone pick is a list of one; a pick that is a list or an object is\n// refused.\nfunction pickList(value: Record<string, unknown>, key: string): unknown[] | null {\n  const raw = value[key] ?? [];\n  const picks: unknown[] = Array.isArray(raw) ? raw : [raw];\n\n  if (picks.some((pick) => isSet(pick) && !isScalar(pick))) {\n    throw new Error(`Each pick in ${key} must be a plain value, not a list.`);\n  }\n\n  const kept = picks.filter((pick) => isSet(pick) && pick !== '');\n\n  return kept.length ? kept : null;\n}\n\n// One end of a number range: null when absent or blank, else a finite number\n// (numeric text is read as its number).\nfunction boundPart(value: Record<string, unknown>, key: string): number | null {\n  const raw = typeof value[key] === 'string' ? (value[key] as string).trim() : value[key];\n  if (!isSet(raw) || raw === '') {\n    return null;\n  }\n\n  const bound = typeof raw === 'string' ? numberFromText(raw) : raw;\n  if (typeof bound !== 'number' || !Number.isFinite(bound)) {\n    throw new Error(`${key} must be a finite number.`);\n  }\n\n  return bound;\n}\n\nfunction requireSize(doc: Record<string, unknown>): void {\n  if (new TextEncoder().encode(JSON.stringify(doc)).length > VIEW_CONFIG_MAX_BYTES) {\n    throw new Error('A view config is over 32 KB.');\n  }\n}\n\nfunction requireVersion(version: unknown): void {\n  if (!isSet(version)) {\n    throw new Error('A view config needs its version (v).');\n  }\n\n  if (version !== REPORT_VIEW_CONFIG_VERSION) {\n    throw new Error(`This viewer reads view config version ${REPORT_VIEW_CONFIG_VERSION} only.`);\n  }\n}\n\nfunction requireMatch(match: unknown): ReportViewConfig['match'] {\n  if (match !== 'all' && match !== 'any') {\n    throw new Error('match must be all or any.');\n  }\n\n  return match;\n}\n\n// Group id -> value. A value no group type could hold is dropped whole.\nfunction viewGroups(raw: unknown): Record<number, FilterGroupDefault | null> {\n  const entries = Object.entries(requireObject(raw, 'groups must map group ids to values.'));\n  if (entries.length > VIEW_CONFIG_MAX_GROUPS) {\n    throw new Error(`A view holds at most ${VIEW_CONFIG_MAX_GROUPS} groups.`);\n  }\n\n  const groups: Record<number, FilterGroupDefault | null> = {};\n  entries.forEach(([key, value]) => {\n    const id = requireIdKey(key, 'groups');\n    requirePickCount(value);\n    const kept = value === null ? null : storedGroupValue(value);\n\n    if (kept !== undefined) {\n      groups[id] = kept;\n    }\n  });\n\n  return groups;\n}\n\n// A stored group value, read for the one type its keys belong to (an empty\n// value fits every type), or undefined when it fits none.\nfunction storedGroupValue(value: unknown): FilterGroupDefault | undefined {\n  if (!isPlainObject(value)) {\n    return undefined;\n  }\n\n  const keys = Object.keys(value);\n  const type = (Object.keys(GROUP_VALUE_KEYS) as ReportFilterType[])\n    .find((candidate) => keys.every((key) => (GROUP_VALUE_KEYS[candidate] as readonly string[]).includes(key)));\n\n  return type ? (groupValueFromStored(value, type) ?? undefined) : undefined;\n}\n\nfunction requirePickCount(value: unknown): void {\n  const lists = isPlainObject(value) ? [value.values, value.excludeValues] : [];\n\n  if (lists.some((list) => Array.isArray(list) && list.length > GROUP_VALUE_MAX_PICKS)) {\n    throw new Error(`A group value holds at most ${GROUP_VALUE_MAX_PICKS} values.`);\n  }\n}\n\n// Component id -> tile state.\nfunction viewTiles(raw: unknown): Record<number, ReportTileState> {\n  const entries = Object.entries(requireObject(raw, 'tiles must map component ids to tile states.'));\n  if (entries.length > VIEW_CONFIG_MAX_TILES) {\n    throw new Error(`A view holds at most ${VIEW_CONFIG_MAX_TILES} tiles.`);\n  }\n\n  const tiles: Record<number, ReportTileState> = {};\n  entries.forEach(([key, value]) => {\n    tiles[requireIdKey(key, 'tiles')] = viewTile(value);\n  });\n\n  return tiles;\n}\n\nfunction viewTile(raw: unknown): ReportTileState {\n  const tile = requireObject(raw, 'A tile state must be an object.');\n  const state = otherKeys(tile, TILE_STATE_KEYS) as ReportTileState;\n\n  if (isSet(tile.sort)) {\n    state.sort = viewSort(tile.sort);\n  }\n\n  if (isSet(tile.search)) {\n    state.search = requireString(tile.search, 'search must be text.');\n  }\n\n  if (isSet(tile.hidden)) {\n    state.hidden = viewHidden(tile.hidden);\n  }\n\n  if (isSet(tile.drill)) {\n    state.drill = viewDrill(tile.drill);\n  }\n\n  return state;\n}\n\nfunction viewSort(raw: unknown): ReportSort {\n  const sort = requireObject(raw, 'sort must be a column and a direction.');\n  const column = requireString(sort.column, 'sort must name a column.');\n  if (column === '' || (isSet(sort.direction) && sort.direction !== 'asc' && sort.direction !== 'desc')) {\n    throw new Error('sort must be a column and a direction.');\n  }\n\n  return sort.direction ? { column, direction: sort.direction as ReportSort['direction'] } : { column };\n}\n\nfunction viewHidden(raw: unknown): string[] {\n  if (!Array.isArray(raw) || raw.some((name) => typeof name !== 'string')) {\n    throw new Error('hidden must list column names.');\n  }\n\n  return [...raw];\n}\n\nfunction viewDrill(raw: unknown): ReportDrillStep[] {\n  if (!Array.isArray(raw)) {\n    throw new Error('drill must list steps.');\n  }\n\n  if (raw.length > DRILL_MAX_DEPTH) {\n    throw new Error(`A drill path holds at most ${DRILL_MAX_DEPTH} steps.`);\n  }\n\n  return raw.map((step: unknown) => {\n    if (!isPlainObject(step) || !isChartGranularity(step.level) || !isDrillValue(step.value)) {\n      throw new Error('A drill step needs a time level and a value.');\n    }\n\n    return { level: step.level, value: step.value };\n  });\n}\n\nfunction isDrillValue(value: unknown): value is ReportDrillStep['value'] {\n  return value === null || typeof value === 'string' || typeof value === 'number';\n}\n\n// The keys of `source` that are not in `known`, as they were.\nfunction otherKeys(source: Record<string, unknown>, known: readonly string[]): Record<string, unknown> {\n  return Object.fromEntries(Object.entries(source).filter(([key]) => !known.includes(key)));\n}\n\nfunction optionalId(raw: unknown, refusal: string): number | null {\n  if (!isSet(raw)) {\n    return null;\n  }\n\n  if (!Number.isInteger(raw) || (raw as number) < 1) {\n    throw new Error(refusal);\n  }\n\n  return raw as number;\n}\n\nfunction requireIdKey(key: string, where: string): number {\n  if (!ID_KEY_PATTERN.test(key)) {\n    throw new Error(`${where} are keyed by id, not by '${key}'.`);\n  }\n\n  return Number(key);\n}\n\nfunction requireGranularity(raw: unknown, refusal: string): ChartGranularity {\n  if (!isChartGranularity(raw)) {\n    throw new Error(refusal);\n  }\n\n  return raw;\n}\n\nfunction requireString(raw: unknown, refusal: string): string {\n  if (typeof raw !== 'string') {\n    throw new Error(refusal);\n  }\n\n  return raw;\n}\n\nfunction requireObject(raw: unknown, refusal: string): Record<string, unknown> {\n  if (!isPlainObject(raw)) {\n    throw new Error(refusal);\n  }\n\n  return raw;\n}\n\nfunction isSet(value: unknown): boolean {\n  return value !== undefined && value !== null;\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n\nfunction isScalar(value: unknown): boolean {\n  return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';\n}\n\n// Only the parts that hold something.\nfunction compact(value: Record<string, unknown>): FilterGroupDefault {\n  return Object.fromEntries(Object.entries(value).filter(([, part]) => isSet(part))) as FilterGroupDefault;\n}\n"]}