@pithy-sh/core 0.11.0 → 0.13.0

package/dist/privacy/classify.d.ts

@@ -0,0 +1,336 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import type { z } from "zod";
+/**
+ * **Reading a privacy marker off a schema, and every marker off a schema tree** (#132).
+ *
+ * The marker is `meta({ privacy })` on the schema a marker was handed. {@link privacyOf} reads it through the
+ * wrappers that are the same field — `pii(z.string()).optional()` is `pii` — and {@link classifyPrivacy} names
+ * each position of a schema that `redact` masks.
+ *
+ * ## The redaction contract
+ *
+ * `redact`, `classifyPrivacy` and `Redacted<T>` all read the one record this module builds for a position, so they
+ * agree on every one. The contract they keep is stated on #132 and in `docs/PRIVACY.md`:
+ *
+ * - **Walked exactly**: objects (strict, loose, catchall, and `pick`, `omit`, `partial`, `extend` of one), arrays,
+ *   tuples and their rest, records, `Map` and `Set`; the wrappers `optional`, `nullable`, `default`, `catch` with a
+ *   constant value, `readonly` and a brand; unions, discriminated unions and intersections, where an option's marks apply where
+ *   the value has that option's shape — a marked string option to a string, never to an array or a number beside
+ *   it — and a mark reached through no option applies to every value; the kit's `SQLiteDate`, `SQLiteBoolean` and
+ *   `sqliteJson(schema)`, read through to the schema they decode to; and recursion, a `z.lazy` or a getter, to the
+ *   one limit below.
+ * - **Everything else is opaque**: a transform, a pipe, a preprocess, any other codec, `z.custom`, `any`, `unknown`,
+ *   and an `.overwrite()` or a `.catch()` with a fallback function over a structure, which make a new value.
+ *   Nothing inside one is walked. With a mark anywhere beneath it, its position is masked whole with the strongest
+ *   class it carries; with none, it is kept, a union option beside a marked one included.
+ * - **A mark on a container masks it whole**, and the container carries every class marked inside it as well as its
+ *   own: `pii(z.object({ token: secret(z.string()) }))` is listed `pii` and `secret`, and masked `[secret]`.
+ * - **Nesting is bounded once**, at {@link MAX_RECURSION_DEPTH} levels: a position deeper than that is masked whole as
+ *   {@link TRUNCATED_MASK}, whatever nests it, a recursion or a schema written out level by level. It is a safety
+ *   cutoff rather than a privacy class. A recursion that repeats a position (the same set of schemas) already read on
+ *   its path needs no cut in the list: its classes are those of the position already read. Recursions defined once
+ *   side by side in a union, with cycles of different lengths, can reach the limit before any position repeats. Where
+ *   a read reaches the limit on a chain of positions not yet seen on its path, a factory or plain nesting, or such a
+ *   union, nothing past it was read, so the list assumes every class there, each `truncated`, as past the budget, and
+ *   `hasPrivacy` answers yes for each: the list never says less than is marked. A path that reaches the limit ends
+ *   alone: every other path is still read, so a class beside a recursion is found whatever the field order, and a
+ *   position masked whole for a class it carries is masked with that class, cut off below or not. The cutoff is a flag
+ *   beside the classes, never instead of them. Every answer is a function of the schema and the value alone.
+ * - **One budget per call, {@link MAX_READ_SCHEMAS} schemas.** `redact`, `classifyPrivacy`, `hasPrivacy` and
+ *   `walkPrivacy` each read at most that many in one call, and every position and every search in it draws on it: each
+ *   schema a read meets counts one, and so does each schema a lazy or an object's shape yields, where a getter runs and
+ *   may build one. So a call's time and memory grow linearly with the size of the schema and the value, and are bounded
+ *   beyond that by the budget and by what the schema's own getters build. Reads go shallowest first, so a class above the point the budget runs out on is found and
+ *   kept. Past it the call fails closed: `redact` masks each position it has not resolved whole, with the strongest
+ *   class it found there or {@link TRUNCATED_MASK} where it found none, and the list names every class at each position
+ *   it has not read, each `truncated`: nothing there was read, so any class may be marked there, and the list never
+ *   says less than the schema marks. It is one of five places the list says more than `redact` masks, beside a position
+ *   cut at the depth limit, the classes a cut assumes, a reference's own path and an intersection that narrows. A position read once is read once
+ *   wherever it sits in the call, so a schema reused in many fields costs one, and each call starts with the whole
+ *   budget and keeps nothing for the next, so every answer is a function of the schema and the value alone. A position
+ *   the walk cannot read at all, nested deeper than the stack can follow, is listed with every class, each `truncated`:
+ *   nothing here throws.
+ * - **`classifyPrivacy` writes out at most {@link MAX_LISTED_PATHS} paths.** A schema reused in two fields at every
+ *   level has a path per field per level, two to the depth; past the cap a position met again is listed at its own path
+ *   once per class marked beneath it, with `sameAs` the path it was first written out under: `redact` masks the paths
+ *   below it, not that path itself. So the paths it writes out are bounded too, however many reach one schema, and
+ *   every class is still listed.
+ * - **An intersection is not narrowed.** Where one side narrows a field so it can never hold the type the other side
+ *   marks, `classifyPrivacy` may still list that field: the inventory can list more than `redact` masks, and never
+ *   less. `z.intersection(z.object({ b: z.number() }), z.object({ b: z.union([pii(z.string()), z.number()]) }))`
+ *   lists `b` as `pii`, and `redact` keeps a `b` of `3`.
+ *
+ * ## What a path looks like
+ *
+ * Object keys join with `.`, an array or set element is `[]`, a tuple position is `[i]`, a record's or a map's value
+ * and an object's catchall are `*`, and a record's or a map's key is `<key>`: `address.line1`, `devices[].token`,
+ * `pair[1]`, `notes.*`, `byEmail.<key>`. A marked root is the empty path. A position masked whole is listed once per
+ * class it carries, and nothing below it is.
+ */
+/** One marked path in a schema, and its class. The per-field record the inventory is built from. */
+export interface PrivacyField {
+    /** Where in the value the field sits: `email`, `address.line1`, `devices[].token`, or `""` for the root. */
+    path: string;
+    /** The class it was marked with. */
+    class: string;
+    /**
+     * Set where the class is assumed rather than found: a position the call ran out of {@link MAX_READ_SCHEMAS} before it
+     * read, or a read beneath a position that ran out of it, a position cut at {@link MAX_RECURSION_DEPTH} on a chain of
+     * schemas not yet seen on its path, or a schema the walk could not read at all, nested deeper than the stack. Each
+     * lists {@link unreadClasses}. Absent everywhere the schema was read to the end.
+     */
+    truncated?: true;
+    /**
+     * Set on a reference: the path this field's position was first listed under. Once the walk has written out
+     * {@link MAX_LISTED_PATHS} paths, a position it meets again is listed once per class marked beneath it, with the path
+     * it was first written out under, rather than once per path below it. The paths below `sameAs` are the paths below
+     * this one.
+     */
+    sameAs?: string;
+    /**
+     * Whether the field rests encrypted in its store (#390): `true` for a field marked `encrypted()`, `false` for one
+     * that is not. Set by the inventory, on the observed side of #132's attestation split, and **absent where the core
+     * cannot say** — an assumed class, a reference, or a core older than #390 — never defaulted to `false`.
+     */
+    encryptedAtRest?: boolean;
+    /** Set on an encrypted field whose storage is not D1: nothing can prove it re-sealed, so it blocks retirement. */
+    unrotatable?: true;
+}
+/**
+ * **The one recursion limit**, shared by `redact`, `classifyPrivacy` and `Redacted<T>` (`./types` reads this constant's
+ * type). Depth is counted in levels of nesting: every object, array, tuple, record, map and set a position sits inside.
+ * It applies to all nesting, not only recursion: a position deeper than this is masked whole as {@link TRUNCATED_MASK}
+ * and typed `unknown`, whatever nests it: a `z.lazy`, a getter that returns one schema, one that builds a new schema
+ * each read, or a schema written out level by level. The list assumes every class there, unless the chain repeats a
+ * position (the same set of schemas) already read on its path. A search for a mark beneath an opaque node or a marked
+ * container ends a path at the same depth, counting each lazy too, and reads every other path; so does the one
+ * `Redacted<T>` makes. So does a read of the shapes a choice can have, and of the schemas that reach one position, each
+ * counting the lazies nested above a schema: a lazy that builds a new choice each read never meets a schema twice. A
+ * union of many lazies, none inside another, counts one.
+ */
+export declare const MAX_RECURSION_DEPTH = 256;
+/**
+ * **The one budget**: how many schemas one call of `redact`, `classifyPrivacy`, `hasPrivacy` or `walkPrivacy` reads.
+ * Every position and every search in that call draws on it. Each schema a read meets counts one — a step of the read of
+ * a position, of the shapes a choice can have, or of a search beneath a marked container or an opaque node — and so
+ * does each schema a lazy or an object's shape yields: a lazy's target, and each field of a shape, where a getter runs
+ * and may build a new schema. A schema met again in the same read costs nothing. So a call reads at most this many
+ * schemas, and runs at most this many of the schema's own getters beyond the fields of the one object it was reading
+ * when the budget ran out. So its time and memory grow linearly with the size of the schema and the value, and are
+ * bounded beyond that by the budget and by what one of those getters builds. Past it the call fails closed: what it has not read, it assumes. `redact` masks each position it has
+ * not resolved whole, with the strongest class it found there or {@link TRUNCATED_MASK} where it found none; the list
+ * names every class at each position it has not read, each `truncated`. Far past any schema written out by hand, and
+ * past any recursion defined once: only a schema that builds new ones as it is read, or one wider than any written out,
+ * reaches it. Each call starts with the whole budget and keeps nothing for the next, so every answer is a function of
+ * the schema and the value alone, whichever call came first.
+ */
+export declare const MAX_READ_SCHEMAS = 10000;
+/**
+ * How many paths {@link walkPrivacy} writes out before a position it met already is listed by reference. A schema
+ * reused in two fields at every level of thirty has thirty-one schemas and a billion paths, so a list of every path
+ * cannot be built; past this many, each new position is still read and written out once, and each one met again is
+ * listed at its own path with every class beneath it and `sameAs` the path it was written out under. So the paths it
+ * writes out are bounded too, however many reach one schema. Far past any table written out: a book of 22 groups of 22
+ * contacts of 22 addresses is written out whole.
+ */
+export declare const MAX_LISTED_PATHS = 50000;
+/**
+ * What `redact` puts where it stops: a value nested past {@link MAX_RECURSION_DEPTH}, an opaque value over a recursion
+ * that reaches it, and a position the call ran out of {@link MAX_READ_SCHEMAS} before it read, where no class was
+ * found. A safety cutoff rather than a privacy class, so it is never a placeholder for one.
+ */
+export declare const TRUNCATED_MASK = "[truncated]";
+/**
+ * The classes {@link classifyPrivacy} lists for a position it did not read: every class registered, strongest first,
+ * because nothing there was read and any of them may be marked below it. So the list never says less than the schema
+ * marks, and `hasPrivacy` answers yes for each. A read that runs out of {@link MAX_READ_SCHEMAS} assumes them where it
+ * stopped, a cut at {@link MAX_RECURSION_DEPTH} on a chain of schemas not yet seen assumes them where it cut, and a
+ * schema the walk cannot read at all is listed with them.
+ */
+export declare function unreadClasses(): string[];
+/**
+ * One call of `redact`, `classifyPrivacy`, `hasPrivacy` or `walkPrivacy`: how much of {@link MAX_READ_SCHEMAS} it has
+ * left, and what it has read, so a schema met again in the call is read once. Made new for each call and kept by none.
+ */
+export interface Call {
+    /** How many more schemas the call may read. */
+    left: number;
+    /** The shapes each schema's output can have, read to its end. */
+    readonly kinds: Map<z.ZodType, KindsFound>;
+    /** The fewest lazies above each schema from which a read of its shapes is known to run past the limit. */
+    readonly stops: Map<z.ZodType, number>;
+    /** What a search found beneath each schema. */
+    readonly searched: Map<z.ZodType, Search>;
+    /** Every position read, by the schemas that reach it. */
+    readonly positions: Map<string, Position>;
+    /** Every position walked into, by its structural nodes and its masks. */
+    readonly walked: Map<string, Position>;
+}
+/** A call with the whole budget, and nothing read. */
+export declare function newCall(): Call;
+/**
+ * The shapes a value can have, as far as a choice is concerned: what `typeof` says, with an object told apart by what
+ * it is. An option's marks apply to a value of a shape the option names, and to no other.
+ */
+export type ValueKind = "string" | "number" | "bigint" | "boolean" | "symbol" | "function" | "date" | "object" | "array" | "map" | "set";
+/** The shape of a value, or `undefined` for `null` and `undefined`, which are kept wherever they are. */
+export declare function kindOfValue(value: unknown): ValueKind | undefined;
+/** A schema's shapes, read to its end, and how many lazies deep the read went below it. */
+interface KindsFound {
+    readonly kinds: ReadonlySet<ValueKind>;
+    readonly reach: number;
+}
+/**
+ * The class a field was marked with, read through its wrappers — `pii(z.string()).optional()` is `pii` — or
+ * `null` when nothing along the chain carries one. A field marked twice, `pii(secret(x))`, is its strongest class.
+ * It never throws: a schema whose metadata cannot be read, cloned by `.describe()` or `.meta()` more times than Zod
+ * can read it back through, may carry any class, so it answers the strongest of {@link unreadClasses}.
+ */
+export declare function privacyOf(schema: z.ZodType): string | null;
+/** What a search found beneath a schema. */
+interface Search {
+    /** Every class it found marked. */
+    readonly classes: ReadonlySet<string>;
+    /** Whether a path ended at the recursion limit, or the search at the budget. */
+    readonly truncated: boolean;
+    /**
+     * Whether every class is assumed beneath it: the search ended at the call's {@link MAX_READ_SCHEMAS}, or a path of
+     * schemas it had not met reached {@link MAX_RECURSION_DEPTH}. Either way, what lies past it was never read.
+     */
+    readonly unread: boolean;
+}
+/** How a position is masked whole. */
+export interface Mask {
+    /**
+     * The strongest class found at the position: its placeholder is the mask, unless `own`. Never a class only assumed.
+     * Empty where none was found — a recursion that reached the limit, or a read that ran out of
+     * {@link MAX_READ_SCHEMAS}, is all there is — and only there is the mask {@link TRUNCATED_MASK}.
+     */
+    readonly className: string;
+    /** Whether the class's own mask applies: one class, from a marker, nothing opaque, and nothing cut off. */
+    readonly own: boolean;
+    /**
+     * Every class marked at the position, in the order met, then every class a read that ran out of
+     * {@link MAX_READ_SCHEMAS}, or reached {@link MAX_RECURSION_DEPTH} on a chain of schemas not yet seen, assumed. Never
+     * the cutoff, which is not a class.
+     */
+    readonly classes: readonly string[];
+    /**
+     * The classes in `classes` that no read found, only assumed: a read here ran out of {@link MAX_READ_SCHEMAS}, or
+     * reached {@link MAX_RECURSION_DEPTH} on a chain of schemas not yet seen, so any class may be marked past it. Listed
+     * `truncated`.
+     */
+    readonly assumed: readonly string[];
+    /**
+     * Whether a recursion here reached {@link MAX_RECURSION_DEPTH}, or a read ran out of {@link MAX_READ_SCHEMAS}: a flag
+     * beside the classes, never instead of them. A class found here is still the mask.
+     */
+    readonly truncated: boolean;
+}
+/** One position: every schema that reaches it, flattened through wrappers, choices, lazies and the kit's codecs. */
+export interface Position {
+    /**
+     * Set when some value here is masked whole: every class the position masks, whatever the value's shape. What
+     * `classifyPrivacy` lists.
+     */
+    readonly mask: Mask | undefined;
+    /**
+     * How an object's string key is masked when it is read here. A string key is a string whatever the key schema says,
+     * a number key's included, so every mark applies to it but one that only a symbol option reaches.
+     */
+    readonly nameMask: Mask | undefined;
+    /** Whether every value here is masked whole, whatever its shape. */
+    readonly whole: boolean;
+    /**
+     * How a value is masked here, by its shape: a mark reached through a union option applies to a value of that
+     * option's shape, and one reached through no option to every value. `undefined` where the value is walked or kept.
+     */
+    maskFor(value: unknown): Mask | undefined;
+    /**
+     * Whether a value's kind and prototype miss what the schemas here expect, and how it is masked where they do: a
+     * class instance or a plain object where none of its kind is named, a `Date`, an array, a `Map` or a `Set` of a
+     * subclass or with fields where an object is, an array-like instance where an array is. `undefined` where it fits:
+     * a schema here names its kind and it is typical of that kind, or only an opaque node here takes its kind. A misfit
+     * is never walked. Its mask is the strongest class beneath the schemas here of its kind, or beneath every schema here
+     * where none names it, and `undefined`, to keep it as it is, where nothing there is marked.
+     */
+    misfit(value: unknown): {
+        readonly mask: Mask | undefined;
+    } | undefined;
+    /** The structural kinds here — `object`, `array`, `map` … — a value is walked by: none of a shape masked whole. */
+    readonly kinds: ReadonlySet<string>;
+    /** Whether anything here but a structural node may hold the value: a scalar, an opaque node. */
+    readonly other: boolean;
+    /** The position at an object key or a record's value. */
+    field(key: PropertyKey): Position | undefined;
+    /** The keys the objects here name, in order. */
+    readonly keys: readonly PropertyKey[];
+    /** The position at a key no object names: a catchall, a record's value. */
+    readonly catchall: Position | undefined;
+    /** The position a record's keys are read at. */
+    readonly key: Position | undefined;
+    /** The position at element `index` of an array or a tuple. */
+    item(index: number): Position | undefined;
+    /** How many items the longest tuple here names. */
+    readonly items: number;
+    /** The position at an element past every tuple item: an array's element, a tuple's rest. */
+    readonly rest: Position | undefined;
+    /** The positions of a map's keys and values. */
+    readonly mapKey: Position | undefined;
+    readonly mapValue: Position | undefined;
+    /** The position of a set's elements. */
+    readonly element: Position | undefined;
+}
+/** The position `schemas` reach, read once in the call for that list of schemas. */
+export declare function positionOf(schemas: readonly z.ZodType[], call: Call): Position | undefined;
+/** The position at the root of a schema, read in `call`: a new one, with the whole budget, unless one is given. */
+export declare function rootPosition(schema: z.ZodType, call?: Call): Position;
+/** What a walk says beside one masked path and class. */
+export interface MarkNote {
+    /**
+     * Set where the class is assumed rather than found: a read ran out of its budget there, or the schema could not be
+     * read at all, so any class may be marked below it.
+     */
+    readonly truncated?: true;
+    /**
+     * Set on a reference, once {@link MAX_LISTED_PATHS} paths are written out: the path this position was first listed
+     * under. The class is marked somewhere beneath both, and the paths beneath this one are those beneath that one.
+     */
+    readonly sameAs?: string;
+}
+/**
+ * What a walk reports. `marked` is called once per masked path and class. `unmarkedKey`, when given, is called for each
+ * object key whose position is not masked whole, before the walk steps into it — the hook `pithy privacy scan` reads a
+ * field's name through, so the scan and the inventory walk one tree the same way.
+ */
+export interface PrivacyVisitor {
+    /** One masked path and class, with a {@link MarkNote} where the class is assumed or the path is a reference. */
+    marked(path: string, className: string, note?: MarkNote): void;
+    unmarkedKey?(path: string, key: string): void;
+}
+/**
+ * Walk a schema tree the way {@link classifyPrivacy} does, from `path`, and report to `visitor`. Exported so a second
+ * reader of the tree — the CLI's scan — cannot walk it differently. A position met again below itself is a recursion
+ * defined once, and is not walked again: its fields are listed once. A position nested more than
+ * {@link MAX_RECURSION_DEPTH} levels deep is cut off by `redact` as {@link TRUNCATED_MASK}; where it is a position not
+ * met on its path, nothing past it was read, so it is listed with every class, each truncated.
+ *
+ * Positions are read level by level, shallowest first, and reported in the schema's own order, all in one call with one
+ * {@link MAX_READ_SCHEMAS}. Each distinct position is read once, wherever it sits; every level above the one the budget
+ * runs out on is read whole, and each position it did not read is listed with {@link unreadClasses}, each truncated.
+ * Once {@link MAX_LISTED_PATHS} paths are written out, a position met again is a reference: its path is listed with
+ * every class beneath it and the path it was first written out under, and nothing below it is written out again. So the
+ * walk is bounded by the budget, however many paths reach one schema. A schema that cannot be read at all, nested
+ * deeper than the stack or behind a getter that throws, is listed with every class, each truncated. It never throws.
+ */
+export declare function walkPrivacy(schema: z.ZodType, visitor: PrivacyVisitor, path?: string): void;
+/**
+ * Every position `redact` masks in a schema, and its class — the Art. 30 record for one object, derived rather than
+ * maintained. Empty for a schema with no markers. A path reached twice is listed once per class. It never throws.
+ */
+export declare function classifyPrivacy(schema: z.ZodType): PrivacyField[];
+/** Whether a schema holds a field of `className` at any depth: exactly what {@link classifyPrivacy} lists. */
+export declare function hasPrivacy(schema: z.ZodType, className: string): boolean;
+export {};
+//# sourceMappingURL=classify.d.ts.map

package/dist/privacy/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../src/privacy/classify.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAI7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AAEH,oGAAoG;AACpG,MAAM,WAAW,YAAY;IAC3B,4GAA4G;IAC5G,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,kHAAkH;IAClH,WAAW,CAAC,EAAE,IAAI,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,QAAS,CAAC;AAEvC;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,QAAS,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,cAAc,gBAAgB,CAAC;AAE5C;;;;;;GAMG;AACH,wBAAgB,aAAa,IAAI,MAAM,EAAE,CAExC;AAED;;;GAGG;AACH,MAAM,WAAW,IAAI;IACnB,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAC3C,0GAA0G;IAC1G,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACvC,+CAA+C;IAC/C,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC1C,yDAAyD;IACzD,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC1C,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACxC;AAED,sDAAsD;AACtD,wBAAgB,OAAO,IAAI,IAAI,CAS9B;AAwFD;;;GAGG;AACH,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,UAAU,GACV,MAAM,GACN,QAAQ,GACR,OAAO,GACP,KAAK,GACL,KAAK,CAAC;AAoCV,yGAAyG;AACzG,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAQjE;AA4DD,2FAA2F;AAC3F,UAAU,UAAU;IAClB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAyLD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,MAAM,GAAG,IAAI,CAY1D;AAwCD,4CAA4C;AAC5C,UAAU,MAAM;IACd,mCAAmC;IACnC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC,gFAAgF;IAChF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAqED,sCAAsC;AACtC,MAAM,WAAW,IAAI;IACnB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,2GAA2G;IAC3G,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,oHAAoH;AACpH,MAAM,WAAW,QAAQ;IACvB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,IAAI,GAAG,SAAS,CAAC;IACpC,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;IAC1C;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG;QAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAA;KAAE,GAAG,SAAS,CAAC;IACxE,mHAAmH;IACnH,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,gGAAgG;IAChG,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,yDAAyD;IACzD,KAAK,CAAC,GAAG,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC9C,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;IACxC,gDAAgD;IAChD,QAAQ,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS,CAAC;IACnC,8DAA8D;IAC9D,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC1C,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4FAA4F;IAC5F,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;IACpC,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;IACxC,wCAAwC;IACxC,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,SAAS,CAAC;CACxC;AA2BD,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,GAAG,QAAQ,GAAG,SAAS,CAiB1F;AA+VD,mHAAmH;AACnH,wBAAgB,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,IAAI,GAAE,IAAgB,GAAG,QAAQ,CAEhF;AAED,yDAAyD;AACzD,MAAM,WAAW,QAAQ;IACvB;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,gHAAgH;IAChH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC/D,WAAW,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/C;AAyHD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,IAAI,SAAK,GAAG,IAAI,CAoDvF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,YAAY,EAAE,CAejE;AAED,8GAA8G;AAC9G,wBAAgB,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAExE"}