ushman-characterize 0.4.0

package/dist/trace-serializer.js

@@ -0,0 +1,607 @@
+import { DEFAULT_TRACE_DEPTH_LIMIT, EXEMPT_FIELD_MARKER, FLOAT_PRECISION_SCALE } from "./constants.js";
+const HASH_OFFSET_BASIS = 2_166_136_261;
+const HASH_PRIME = 16_777_619;
+const MAX_COLLECTION_ITEMS = 32;
+const MAX_TYPED_ARRAY_BYTES = 1_024;
+const MAX_OBJECT_PATH_SEGMENTS = 16;
+const asSerializableObject = (value) => value;
+export const roundTraceNumber = (value) => Math.round(value * FLOAT_PRECISION_SCALE) / FLOAT_PRECISION_SCALE;
+export const canonicalizeNumericValue = (value) => {
+    if (Number.isNaN(value)) {
+        return { __t: 'Number', value: 'NaN' };
+    }
+    if (value === Number.POSITIVE_INFINITY) {
+        return { __t: 'Number', value: 'Infinity' };
+    }
+    if (value === Number.NEGATIVE_INFINITY) {
+        return { __t: 'Number', value: '-Infinity' };
+    }
+    if (Object.is(value, -0)) {
+        return { __t: 'Number', value: '-0' };
+    }
+    return roundTraceNumber(value);
+};
+export const isPlainObject = (value) => {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
+export const buildStableHash = (value) => {
+    let hash = HASH_OFFSET_BASIS;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, HASH_PRIME);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+};
+const normalizePathSegment = (value) => {
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    return null;
+};
+const buildObjectPath = (value) => {
+    const segments = [];
+    let cursor = value;
+    while (cursor && segments.length < MAX_OBJECT_PATH_SEGMENTS) {
+        const label = normalizePathSegment(cursor.name) ??
+            normalizePathSegment(cursor.type) ??
+            normalizePathSegment(cursor.uuid) ??
+            cursor.constructor?.name;
+        if (label) {
+            segments.unshift(label);
+        }
+        cursor = isPlainObject(cursor.parent) ? cursor.parent : null;
+    }
+    return segments.join('/');
+};
+const sampleArrayLikeValues = (value) => {
+    if (ArrayBuffer.isView(value)) {
+        return Array.from(new Uint8Array(value.buffer, value.byteOffset, Math.min(value.byteLength, MAX_TYPED_ARRAY_BYTES))).map((item) => canonicalizeNumericValue(item));
+    }
+    if (Array.isArray(value)) {
+        return value
+            .slice(0, MAX_TYPED_ARRAY_BYTES)
+            .map((item) => (typeof item === 'number' ? canonicalizeNumericValue(item) : String(item)));
+    }
+    return null;
+};
+const describeGeometryAttribute = (value) => {
+    if (!isPlainObject(value)) {
+        return { type: 'unknown' };
+    }
+    return {
+        arraySample: sampleArrayLikeValues(value.array),
+        arrayType: value.array?.constructor?.name ?? null,
+        count: typeof value.count === 'number' ? value.count : null,
+        itemSize: typeof value.itemSize === 'number' ? value.itemSize : null,
+        normalized: typeof value.normalized === 'boolean' ? value.normalized : null,
+    };
+};
+const hashGeometryAttributes = (value) => {
+    const attributes = isPlainObject(value.attributes) ? value.attributes : {};
+    const describedAttributes = Object.fromEntries(Object.entries(attributes)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, attribute]) => [key, describeGeometryAttribute(attribute)]));
+    const indexDescription = describeGeometryAttribute(value.index);
+    return buildStableHash(JSON.stringify({
+        attributes: describedAttributes,
+        index: indexDescription,
+    }));
+};
+const resolveHexString = (value) => {
+    if (typeof value.getHexString !== 'function') {
+        return null;
+    }
+    try {
+        return String(value.getHexString());
+    }
+    catch {
+        return null;
+    }
+};
+const summarizeVectorLike = (value) => {
+    const ctor = typeof value.constructor?.name === 'string' ? value.constructor.name : 'Object';
+    if ((ctor !== 'Vector2' && ctor !== 'Vector3' && ctor !== 'Vector4') ||
+        typeof value.x !== 'number' ||
+        typeof value.y !== 'number') {
+        return null;
+    }
+    return {
+        __t: ctor,
+        ...(typeof value.z === 'number' ? { z: canonicalizeNumericValue(value.z) } : {}),
+        ...(typeof value.w === 'number' ? { w: canonicalizeNumericValue(value.w) } : {}),
+        x: canonicalizeNumericValue(value.x),
+        y: canonicalizeNumericValue(value.y),
+    };
+};
+const summarizeEulerLike = (value) => {
+    if (value.constructor?.name !== 'Euler' ||
+        typeof value.x !== 'number' ||
+        typeof value.y !== 'number' ||
+        typeof value.z !== 'number') {
+        return null;
+    }
+    return {
+        __t: 'Euler',
+        order: typeof value.order === 'string' ? value.order : null,
+        x: canonicalizeNumericValue(value.x),
+        y: canonicalizeNumericValue(value.y),
+        z: canonicalizeNumericValue(value.z),
+    };
+};
+const summarizeQuaternionLike = (value) => {
+    if (value.constructor?.name !== 'Quaternion' ||
+        typeof value.x !== 'number' ||
+        typeof value.y !== 'number' ||
+        typeof value.z !== 'number' ||
+        typeof value.w !== 'number') {
+        return null;
+    }
+    return {
+        __t: 'Quaternion',
+        w: canonicalizeNumericValue(value.w),
+        x: canonicalizeNumericValue(value.x),
+        y: canonicalizeNumericValue(value.y),
+        z: canonicalizeNumericValue(value.z),
+    };
+};
+const summarizeMatrix4Like = (value) => {
+    if (value.constructor?.name !== 'Matrix4' || !Array.isArray(value.elements)) {
+        return null;
+    }
+    return {
+        __t: 'Matrix4',
+        elements: value.elements.map((entry) => (typeof entry === 'number' ? canonicalizeNumericValue(entry) : entry)),
+    };
+};
+const summarizeColorLike = (value) => {
+    const hex = resolveHexString(value);
+    if (hex === null) {
+        return null;
+    }
+    return {
+        __t: value.constructor?.name === 'Color' ? 'Color' : String(value.constructor?.name ?? 'Color'),
+        hex,
+    };
+};
+const summarizeObject3DLike = (value) => {
+    if (typeof value.type !== 'string' || !Array.isArray(value.children)) {
+        return null;
+    }
+    return {
+        __t: 'Object3D',
+        children: value.children.length,
+        name: typeof value.name === 'string' ? value.name : '',
+        path: buildObjectPath(value),
+        type: value.type,
+    };
+};
+const summarizeBufferGeometryLike = (value) => {
+    if (typeof value.type !== 'string' || !('attributes' in value)) {
+        return null;
+    }
+    const attributes = isPlainObject(value.attributes) ? Object.keys(value.attributes).sort() : [];
+    return {
+        __t: 'BufferGeometry',
+        attributeKeys: attributes,
+        hash: hashGeometryAttributes(value),
+        hasIndex: Boolean(value.index),
+        type: value.type,
+    };
+};
+const summarizeMaterialLike = (value) => {
+    if (typeof value.type !== 'string' || !('opacity' in value || 'transparent' in value)) {
+        return null;
+    }
+    const color = isPlainObject(value.color) ? resolveHexString(value.color) : null;
+    return {
+        __t: 'Material',
+        color,
+        opacity: typeof value.opacity === 'number' ? canonicalizeNumericValue(value.opacity) : null,
+        transparent: typeof value.transparent === 'boolean' ? value.transparent : null,
+        type: value.type,
+    };
+};
+const summarizeTextureLike = (value) => {
+    if (!('image' in value) || !('name' in value)) {
+        return null;
+    }
+    const image = isPlainObject(value.image)
+        ? {
+            height: typeof value.image.height === 'number' ? value.image.height : null,
+            src: typeof value.image.src === 'string' ? value.image.src : null,
+            width: typeof value.image.width === 'number' ? value.image.width : null,
+        }
+        : null;
+    return {
+        __t: 'Texture',
+        image,
+        name: typeof value.name === 'string' ? value.name : '',
+    };
+};
+const THREE_LIKE_CANONICALIZERS = [
+    summarizeVectorLike,
+    summarizeEulerLike,
+    summarizeQuaternionLike,
+    summarizeMatrix4Like,
+    summarizeColorLike,
+    summarizeObject3DLike,
+    summarizeBufferGeometryLike,
+    summarizeMaterialLike,
+    summarizeTextureLike,
+];
+export const canonicalizeThreeLikeValue = (value) => {
+    for (const canonicalize of THREE_LIKE_CANONICALIZERS) {
+        const summary = canonicalize(value);
+        if (summary !== null) {
+            return summary;
+        }
+    }
+    return null;
+};
+const canonicalizePrimitiveValue = (value) => {
+    if (value === null) {
+        return null;
+    }
+    if (value === undefined) {
+        return { __t: 'Undefined' };
+    }
+    if (typeof value === 'number') {
+        return canonicalizeNumericValue(value);
+    }
+    if (typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'bigint') {
+        return { __t: 'BigInt', value: value.toString() };
+    }
+    if (typeof value === 'symbol') {
+        return { __t: 'Symbol', value: String(value) };
+    }
+    if (typeof value === 'function') {
+        return { __t: 'Function', name: value.name || 'anonymous' };
+    }
+    return null;
+};
+const canonicalizeSimpleObject = (value) => {
+    if (value instanceof Error) {
+        return { __t: 'Error', message: value.message, name: value.name };
+    }
+    if (value instanceof Date) {
+        return { __t: 'Date', iso: value.toISOString() };
+    }
+    if (value instanceof URL) {
+        return { __t: 'URL', href: value.href };
+    }
+    if (value instanceof ArrayBuffer) {
+        return { __t: 'ArrayBuffer', byteLength: value.byteLength };
+    }
+    if (ArrayBuffer.isView(value)) {
+        return {
+            __t: value.constructor.name,
+            byteLength: value.byteLength,
+            values: sampleArrayLikeValues(value),
+        };
+    }
+    return null;
+};
+const createTracker = (state, type) => {
+    const reference = {
+        __id: state.nextId,
+        __t: type,
+    };
+    const tracker = {
+        id: state.nextId,
+        reference,
+    };
+    state.nextId += 1;
+    return tracker;
+};
+const trackReference = (entry, state, type) => {
+    const tracker = createTracker(state, type);
+    state.seen.set(entry, tracker);
+    return tracker.reference;
+};
+const createTraceReference = ({ ctorName, value, }) => Array.isArray(value)
+    ? 'Array'
+    : ctorName === 'Object'
+        ? 'Object'
+        : ctorName === 'Map'
+            ? 'Map'
+            : ctorName === 'Set'
+                ? 'Set'
+                : 'Instance';
+const canonicalizeTrackedCollection = ({ depth, state, value, }) => {
+    const seenTracker = state.seen.get(value);
+    if (seenTracker) {
+        return { __ref: seenTracker.id };
+    }
+    if (Array.isArray(value)) {
+        const reference = trackReference(value, state, 'Array');
+        reference.items = value.map((entry) => visitTraceValue(entry, depth + 1, state));
+        return reference;
+    }
+    if (value instanceof Map) {
+        const reference = trackReference(value, state, 'Map');
+        reference.entries = [...value.entries()]
+            .slice(0, MAX_COLLECTION_ITEMS)
+            .map(([key, entry]) => [visitTraceValue(key, depth + 1, state), visitTraceValue(entry, depth + 1, state)]);
+        return reference;
+    }
+    if (value instanceof Set) {
+        const reference = trackReference(value, state, 'Set');
+        reference.values = [...value.values()]
+            .slice(0, MAX_COLLECTION_ITEMS)
+            .map((entry) => visitTraceValue(entry, depth + 1, state));
+        return reference;
+    }
+    const ctorName = typeof value.constructor?.name === 'string' ? value.constructor.name : 'Object';
+    const reference = trackReference(value, state, createTraceReference({ ctorName, value }));
+    const props = Object.fromEntries(Object.keys(asSerializableObject(value))
+        .filter((key) => key !== 'uuid')
+        .sort((left, right) => left.localeCompare(right))
+        .map((key) => [key, visitTraceValue(asSerializableObject(value)[key], depth + 1, state)]));
+    reference.props = props;
+    if (ctorName !== 'Object') {
+        reference.ctor = ctorName;
+    }
+    return reference;
+};
+const visitTraceValue = (value, depth, state) => {
+    const primitive = canonicalizePrimitiveValue(value);
+    if (primitive !== null) {
+        return primitive;
+    }
+    if (depth > state.depthLimit) {
+        return { __t: 'DepthLimit' };
+    }
+    if (!(value instanceof Object)) {
+        return String(value);
+    }
+    const simple = canonicalizeSimpleObject(value);
+    if (simple !== null) {
+        return simple;
+    }
+    const threeLike = canonicalizeThreeLikeValue(asSerializableObject(value));
+    if (threeLike !== null) {
+        return threeLike;
+    }
+    const maybeElement = asSerializableObject(value);
+    if (typeof maybeElement.nodeType === 'number' && 'tagName' in maybeElement) {
+        return {
+            __t: 'Element',
+            className: typeof maybeElement.className === 'string' ? maybeElement.className : '',
+            id: typeof maybeElement.id === 'string' ? maybeElement.id : '',
+            tagName: typeof maybeElement.tagName === 'string' ? maybeElement.tagName : '',
+        };
+    }
+    return canonicalizeTrackedCollection({
+        depth,
+        state,
+        value,
+    });
+};
+export const canonicalizeTraceValue = (value, options = {}) => visitTraceValue(value, 0, {
+    depthLimit: options.depthLimit ?? DEFAULT_TRACE_DEPTH_LIMIT,
+    nextId: 1,
+    seen: new WeakMap(),
+});
+export const canonicalizeThrownValue = (value) => canonicalizeTraceValue(value);
+const createHydrationState = () => ({
+    refs: new Map(),
+});
+const hydrateSequence = ({ state, value, }) => value.map((entry) => hydrateTraceValue(entry, state));
+const hydrateEntries = (value, state) => Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, hydrateTraceValue(entry, state)]));
+const hydrateReference = ({ state, value, }) => (typeof value.__ref === 'number' ? (state.refs.get(value.__ref) ?? undefined) : null);
+const hydrateTrackedArray = ({ state, value, }) => {
+    if (value.__t !== 'Array' || !Array.isArray(value.items)) {
+        return null;
+    }
+    const array = [];
+    if (typeof value.__id === 'number') {
+        state.refs.set(value.__id, array);
+    }
+    array.push(...hydrateSequence({ state, value: value.items }));
+    return array;
+};
+const hydrateTrackedMap = ({ state, value, }) => {
+    if (value.__t !== 'Map' || !Array.isArray(value.entries)) {
+        return null;
+    }
+    const map = new Map();
+    if (typeof value.__id === 'number') {
+        state.refs.set(value.__id, map);
+    }
+    for (const entry of value.entries) {
+        if (!Array.isArray(entry) || entry.length !== 2) {
+            continue;
+        }
+        map.set(hydrateTraceValue(entry[0], state), hydrateTraceValue(entry[1], state));
+    }
+    return map;
+};
+const hydrateTrackedSet = ({ state, value, }) => {
+    if (value.__t !== 'Set' || !Array.isArray(value.values)) {
+        return null;
+    }
+    const set = new Set();
+    if (typeof value.__id === 'number') {
+        state.refs.set(value.__id, set);
+    }
+    for (const entry of value.values) {
+        set.add(hydrateTraceValue(entry, state));
+    }
+    return set;
+};
+const hydrateTrackedObject = ({ state, value, }) => {
+    if ((value.__t !== 'Object' && value.__t !== 'Instance') || !isPlainObject(value.props)) {
+        return null;
+    }
+    const target = value.__t === 'Instance' && typeof value.ctor === 'string'
+        ? Object.create({ constructor: { name: value.ctor } })
+        : {};
+    if (typeof value.__id === 'number') {
+        state.refs.set(value.__id, target);
+    }
+    Object.assign(target, hydrateEntries(value.props, state));
+    return target;
+};
+export const hydrateTraceValue = (value, state = createHydrationState()) => {
+    if (Array.isArray(value)) {
+        return hydrateSequence({ state, value });
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const serialized = asSerializableObject(value);
+    if (serialized.__t === 'Undefined') {
+        return undefined;
+    }
+    const ref = hydrateReference({ state, value: serialized });
+    if (ref !== null) {
+        return ref;
+    }
+    const array = hydrateTrackedArray({ state, value: serialized });
+    if (array !== null) {
+        return array;
+    }
+    const map = hydrateTrackedMap({ state, value: serialized });
+    if (map !== null) {
+        return map;
+    }
+    const set = hydrateTrackedSet({ state, value: serialized });
+    if (set !== null) {
+        return set;
+    }
+    const object = hydrateTrackedObject({ state, value: serialized });
+    if (object !== null) {
+        return object;
+    }
+    return hydrateEntries(serialized, state);
+};
+const compareObjects = ({ actual, expected, mode, }) => {
+    const expectedKeys = Object.keys(expected).sort();
+    const actualKeys = Object.keys(actual).sort();
+    if (mode === 'strict' && expectedKeys.join('|') !== actualKeys.join('|')) {
+        return false;
+    }
+    return expectedKeys.every((key) => {
+        if (!(key in actual) && mode === 'lenient') {
+            return true;
+        }
+        return compareTraceValues(expected[key], actual[key], mode);
+    });
+};
+export const compareTraceValues = (expected, actual, mode = 'strict') => {
+    if (Array.isArray(expected) && Array.isArray(actual)) {
+        return (expected.length === actual.length &&
+            expected.every((entry, index) => compareTraceValues(entry, actual[index], mode)));
+    }
+    if (expected && actual && typeof expected === 'object' && typeof actual === 'object') {
+        return compareObjects({
+            actual: asSerializableObject(actual),
+            expected: asSerializableObject(expected),
+            mode,
+        });
+    }
+    return JSON.stringify(expected) === JSON.stringify(actual);
+};
+const visitSceneValue = (value, exempt, pathParts) => {
+    const pathKey = pathParts.join('.');
+    if (exempt.has(pathKey)) {
+        return EXEMPT_FIELD_MARKER;
+    }
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return roundTraceNumber(value);
+    }
+    if (typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry, index) => visitSceneValue(entry, exempt, [...pathParts, String(index)]));
+    }
+    if (typeof value === 'object') {
+        return Object.fromEntries(Object.entries(asSerializableObject(value))
+            .filter(([key]) => key !== 'uuid')
+            .map(([key, entry]) => [key, visitSceneValue(entry, exempt, [...pathParts, key])]));
+    }
+    return String(value);
+};
+export const canonicalizeSceneTree = (value, options = {}) => visitSceneValue(value, new Set(options.exemptFields ?? []), []);
+const TRACE_RUNTIME_FUNCTIONS = [
+    asSerializableObject,
+    roundTraceNumber,
+    canonicalizeNumericValue,
+    isPlainObject,
+    buildStableHash,
+    normalizePathSegment,
+    sampleArrayLikeValues,
+    describeGeometryAttribute,
+    hashGeometryAttributes,
+    resolveHexString,
+    summarizeVectorLike,
+    summarizeEulerLike,
+    summarizeQuaternionLike,
+    summarizeMatrix4Like,
+    summarizeColorLike,
+    buildObjectPath,
+    summarizeObject3DLike,
+    summarizeBufferGeometryLike,
+    summarizeMaterialLike,
+    summarizeTextureLike,
+    canonicalizeThreeLikeValue,
+    canonicalizePrimitiveValue,
+    canonicalizeSimpleObject,
+    createTracker,
+    trackReference,
+    createTraceReference,
+    canonicalizeTrackedCollection,
+    visitTraceValue,
+    canonicalizeTraceValue,
+    createHydrationState,
+    hydrateSequence,
+    hydrateEntries,
+    hydrateReference,
+    hydrateTrackedArray,
+    hydrateTrackedMap,
+    hydrateTrackedSet,
+    hydrateTrackedObject,
+    hydrateTraceValue,
+    compareObjects,
+    compareTraceValues,
+    visitSceneValue,
+    canonicalizeSceneTree,
+];
+export const buildTraceRuntimeSupportSource = () => [
+    `const FLOAT_PRECISION_SCALE = ${FLOAT_PRECISION_SCALE};`,
+    `const DEFAULT_TRACE_DEPTH_LIMIT = ${DEFAULT_TRACE_DEPTH_LIMIT};`,
+    `const EXEMPT_FIELD_MARKER = ${JSON.stringify(EXEMPT_FIELD_MARKER)};`,
+    `const HASH_OFFSET_BASIS = ${HASH_OFFSET_BASIS};`,
+    `const HASH_PRIME = ${HASH_PRIME};`,
+    `const MAX_COLLECTION_ITEMS = ${MAX_COLLECTION_ITEMS};`,
+    `const MAX_TYPED_ARRAY_BYTES = ${MAX_TYPED_ARRAY_BYTES};`,
+    `const MAX_OBJECT_PATH_SEGMENTS = ${MAX_OBJECT_PATH_SEGMENTS};`,
+    'const THREE_LIKE_CANONICALIZERS = [];',
+    ...TRACE_RUNTIME_FUNCTIONS.map((fn) => {
+        const source = fn.toString();
+        return source.startsWith('function ') ? source : `const ${fn.name} = ${source};`;
+    }),
+    `THREE_LIKE_CANONICALIZERS.push(
+  summarizeVectorLike,
+  summarizeEulerLike,
+  summarizeQuaternionLike,
+  summarizeMatrix4Like,
+  summarizeColorLike,
+  summarizeObject3DLike,
+  summarizeBufferGeometryLike,
+  summarizeMaterialLike,
+  summarizeTextureLike,
+);`,
+].join('\n\n');
+export { EXEMPT_FIELD_MARKER };

package/dist/tracer-runtime.d.ts

@@ -0,0 +1,25 @@
+export type TraceDrainPayload = {
+    readonly records: readonly {
+        readonly args: unknown;
+        readonly bindingName: string;
+        readonly className: null | string;
+        readonly count: number;
+        readonly expected: unknown;
+        readonly functionName: string;
+        readonly memberKind: 'function' | 'method';
+        readonly methodName: null | string;
+        readonly sideEffects: readonly unknown[];
+        readonly thisArg: unknown;
+        readonly threw: unknown;
+    }[];
+    readonly stats: {
+        readonly droppedUniqueCalls: number;
+        readonly rawCalls: number;
+        readonly uniqueCalls: number;
+    };
+};
+export declare const buildTracerRuntimeSource: ({ captureSideEffects, perFunctionShapeCap, }: {
+    readonly captureSideEffects: boolean;
+    readonly perFunctionShapeCap?: number;
+}) => string;
+//# sourceMappingURL=tracer-runtime.d.ts.map

package/dist/tracer-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracer-runtime.d.ts","sourceRoot":"","sources":["../src/tracer-runtime.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,iBAAiB,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,SAAS;QACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,QAAQ,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;QAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;QAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,QAAQ,CAAC;QAC3C,QAAQ,CAAC,UAAU,EAAE,IAAI,GAAG,MAAM,CAAC;QACnC,QAAQ,CAAC,WAAW,EAAE,SAAS,OAAO,EAAE,CAAC;QACzC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;QAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;KAC3B,EAAE,CAAC;IACJ,QAAQ,CAAC,KAAK,EAAE;QACZ,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;QACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;KAChC,CAAC;CACL,CAAC;AAuGF,eAAO,MAAM,wBAAwB,GAAI,8CAGtC;IACC,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CACzC,WA4LK,CAAC"}