@graphty/graph-format 0.0.0 → 0.2.0

package/dist/src/snapshot/graph-snapshot.d.ts

@@ -0,0 +1,509 @@
+/**
+ * The concrete GraphSnapshot class (design sections 3, 5.8, 7, 9.3 and 11.4) and its factory
+ * `createSnapshot(parts)`, plus the boundary helpers `isGraphSnapshot` / `equalsTopology` (design
+ * section 7.5) and the arena helpers a GPU consumer binds segments with (section 10.3).
+ *
+ * The object is frozen with `Object.freeze` so `snapshot.rowPtr = x` throws in strict mode; every
+ * lazily populated member (the identity permutations of design section 3.1, the view cache of
+ * section 7.2, the checksum records of section 5.8, the content hash, the edge id index) lives in
+ * one mutable state record reachable only through a private field, which `Object.freeze` does not
+ * reach. `arcToEdge` / `edgeToArc` are prototype getters that materialise an identity permutation on
+ * first access outside the arena (never on the wire, never in `byteLength()`); `rowPtr`, `colIdx`
+ * and `weights` are plain data properties so hot loops pay nothing. Every method that reads the core
+ * throws `E_DETACHED` once the core buffer was transferred away (`detached` is derived:
+ * `rowPtr.length === 0`).
+ *
+ * Views are computed by views.ts, queries by queries.ts, derived graphs by derived.ts (which returns
+ * SnapshotParts that this module wraps), invariant checks by validate.ts and hashes by hash.ts. The
+ * wire methods (`toWire`, `toBytes`, `toByteChunks`, `transferables`) call the wire module directly;
+ * the wire module imports this one too, and the cycle is safe because each side reaches the other
+ * only through hoisted function declarations invoked at call time, never at module load.
+ */
+import { SNAPSHOT_BRAND } from "../constants.js";
+import { type ArenaLayout, type AttributeTable, type ByteLengthOptions, type ColumnInput, type ContractOptions, type CooView, type DegreeOrderOptions, type DegreeOrderView, type DerivedGraph, type EdgeId, type EdgeListView, type EdgeMask, type F32, type F64, type GraphMeta, type GraphSnapshotContract, type NodeIdMap, type NodeMask, type ReverseView, type SimplifyOptions, type SnapshotFlags, type ToBytesOptions, type ToUndirectedOptions, type ToWireOptions, type TypedArrayData, type U8, type U32, type ValidateOptions, type ViewName, type WireSnapshot } from "../types/index.js";
+import { type SnapshotParts, type ViewCache } from "../types/internal.js";
+/**
+ * The own enumerable property every snapshot carries whose value is a function, so that
+ * `structuredClone(snapshot)` and `postMessage(snapshot)` throw `DataCloneError` immediately (design
+ * section 7.5; the structured clone algorithm refuses functions and visits enumerable own
+ * properties only).
+ */
+export declare const CLONE_GUARD_KEY = "__graphtyNoStructuredClone";
+export { EMPTY_GRAPH_META } from "./graph-meta.js";
+/**
+ * The frozen graph (design section 3): a CSR core over 4-byte typed arrays, the id map, the
+ * attribute tables, the flags and a per-instance view cache. Topology, counts, flags, id map and
+ * immutable columns never change after construction (invariant I17); the column SET of `nodes` /
+ * `edges` / `graph` and the CONTENTS of columns declared mutable are mutable side tables (design
+ * section 5.8). Every view is a pure function of the core, memoised once and SHARED: a call returns
+ * the cached array itself, so writing into a view is a contract violation; call `.slice()` for
+ * scratch. Index-taking queries are total for in-range arguments and unchecked otherwise (design
+ * section 11.1). Instances come from `createSnapshot()` (the builder, `fromCsr`, `fromWire` and the
+ * derived-graph methods); `isGraphSnapshot()` recognises them structurally by brand and
+ * formatVersion.
+ */
+export declare class GraphSnapshot implements GraphSnapshotContract {
+    /** Symbol.for brand read by isGraphSnapshot() (design section 7.5). */
+    readonly [SNAPSHOT_BRAND]: true;
+    /** Process-unique identity of the CORE; shared by withColumns() snapshots (design section 5.8). */
+    readonly serial: number;
+    /** Debugging aid supplied at freeze. */
+    readonly label: string | null;
+    /** The data-model major (design section 13.5). */
+    readonly formatVersion: 1;
+    /** Whether the graph is directed. */
+    readonly directed: boolean;
+    /** n (invariant I3). */
+    readonly nodeCount: number;
+    /** Number of logical edges (invariant I13). */
+    readonly edgeCount: number;
+    /** colIdx.length (invariants I6, I7). */
+    readonly arcCount: number;
+    /** Logical edges with source === target. */
+    readonly selfLoopCount: number;
+    /** nodeCount + 1 row offsets (invariant I1). */
+    readonly rowPtr: U32;
+    /** Target node index of each arc, sorted within each row (invariants I2, I4). */
+    readonly colIdx: U32;
+    /** arcCount f32 weights; null when unweighted. */
+    readonly weights: F32 | null;
+    /** Flags kernels branch on (design section 3.8). */
+    readonly flags: SnapshotFlags;
+    /** The id map (design section 4). */
+    readonly ids: NodeIdMap;
+    /** Node attribute table, rowCount === nodeCount. */
+    readonly nodes: AttributeTable;
+    /** Edge attribute table, rowCount === edgeCount, indexed by logical edge. */
+    readonly edges: AttributeTable;
+    /** Graph attribute table, rowCount === 1. */
+    readonly graph: AttributeTable;
+    /** Extension tables keyed by name (design section 5.10). */
+    readonly extensions: ReadonlyMap<string, AttributeTable>;
+    /** Graph-level metadata (design section 5.9). */
+    readonly meta: GraphMeta;
+    /** The arena holding the core arrays, or null (design section 10.3). */
+    readonly arena: ArenaLayout | null;
+    /**
+     * The lazily populated members (design section 5.8): defined as a NON-enumerable own property in
+     * the constructor (`declare` keeps tsc from emitting a field), so `Object.keys(snapshot)` lists
+     * exactly the public fields plus the documented clone guard, and JSON / spread / structured
+     * clone never walk the view cache.
+     */
+    private readonly state;
+    /**
+     * rowPtr.length === 0: the core buffer was transferred away (design section 9.4). Derived from the
+     * array state, never a stored bit, so every holder of the same core agrees.
+     * @returns true when detached
+     */
+    get detached(): boolean;
+    /**
+     * Logical edge of every arc (invariant I5); an identity permutation is materialised on first
+     * access as a separate 4-byte-aligned array outside the arena. GPU code tests
+     * `flags.arcToEdgeIsIdentity` before reading it.
+     * @returns arcCount entries; E_DETACHED after a consuming transfer
+     */
+    get arcToEdge(): U32;
+    /**
+     * The arc holding the declared orientation of every logical edge (invariant I5); an identity
+     * permutation is materialised on first access outside the arena.
+     * @returns edgeCount entries; E_DETACHED after a consuming transfer
+     */
+    get edgeToArc(): U32;
+    /**
+     * The out-arc range of a node: [rowPtr[u], rowPtr[u + 1]]. Allocates a tuple; hot loops read
+     * rowPtr directly.
+     * @param u - the node index
+     * @returns the half-open arc range as [start, end]
+     */
+    outArcs(u: number): readonly [start: number, end: number];
+    /**
+     * rowPtr[u + 1] - rowPtr[u]: the out-arc count (a self-loop counted once).
+     * @param u - the node index
+     * @returns the out-degree
+     */
+    outDegreeOf(u: number): number;
+    /**
+     * Binary search for the first arc u -> v (the lowest logical edge index among parallels).
+     * @param u - the source node index
+     * @param v - the target node index
+     * @returns the arc index, or INVALID_INDEX when absent
+     */
+    findArc(u: number, v: number): number;
+    /**
+     * Whether an arc u -> v exists.
+     * @param u - the source node index
+     * @param v - the target node index
+     * @returns findArc(u, v) !== INVALID_INDEX
+     */
+    hasArc(u: number, v: number): boolean;
+    /**
+     * The half-open arc range [lo, hi) of every arc u -> v; empty when lo === hi. Allocates a tuple.
+     * @param u - the source node index
+     * @param v - the target node index
+     * @returns the range as [lo, hi]
+     */
+    arcsBetween(u: number, v: number): readonly [lo: number, hi: number];
+    /**
+     * Number of parallel arcs u -> v.
+     * @param u - the source node index
+     * @param v - the target node index
+     * @returns hi - lo of arcsBetween(u, v)
+     */
+    multiplicity(u: number, v: number): number;
+    /**
+     * The row containing an arc: O(1) through the cached coo() view, else a binary search on rowPtr.
+     * @param a - the arc index
+     * @returns the source node index
+     */
+    arcSource(a: number): number;
+    /**
+     * Declared source of a logical edge: arcSource(edgeToArc[e]).
+     * @param e - the logical edge index
+     * @returns the source node index
+     */
+    edgeSource(e: number): number;
+    /**
+     * Declared target of a logical edge: colIdx[edgeToArc[e]].
+     * @param e - the logical edge index
+     * @returns the target node index
+     */
+    edgeTarget(e: number): number;
+    /**
+     * Lookup through the role "id" edge column, backed by a Map built on first call and rebuilt when the
+     * column is replaced or a mutable id column's version changes (design section 4.6).
+     * @param id - the edge id
+     * @returns the logical edge index, or INVALID_INDEX on a miss or when no id column exists
+     */
+    edgeIndexOf(id: EdgeId): number;
+    /**
+     * The in-adjacency, rows sorted by source; the forward arrays themselves when undirected. Cached
+     * and shared.
+     * @returns the reverse view
+     */
+    reverse(): ReverseView;
+    /**
+     * Per-arc COO form; src is the only new array. Cached and shared.
+     * @returns the COO view
+     */
+    coo(): CooView;
+    /**
+     * Every logical edge once in declared orientation. Cached and shared.
+     * @returns the edge list view
+     */
+    edgeList(): EdgeListView;
+    /**
+     * rowPtr differences materialised; a self-loop counted once. Cached and shared: call `.slice()`
+     * before writing.
+     * @returns Uint32Array(n)
+     */
+    outDegree(): U32;
+    /**
+     * Arcs targeting each node, via reverse().rowPtr; the same object as outDegree() when undirected.
+     * Cached and shared: call `.slice()` before writing.
+     * @returns Uint32Array(n)
+     */
+    inDegree(): U32;
+    /**
+     * Graph-theoretic degree (NetworkX convention, design section 3.4): in + out when directed; out
+     * plus self-loops when undirected. Cached and shared: call `.slice()` before writing.
+     * @returns Uint32Array(n)
+     */
+    degree(): U32;
+    /**
+     * Row sums of weights (a self-loop arc counted once); outDegree widened when unweighted. F64 for
+     * CPU precision; may be 0 for a node with out-arcs. Cached and shared: call `.slice()` before
+     * writing.
+     * @returns Float64Array(n)
+     */
+    weightedOutDegree(): F64;
+    /**
+     * Weight sums over incoming arcs; the same object as weightedOutDegree() when undirected. Cached
+     * and shared: call `.slice()` before writing.
+     * @returns Float64Array(n)
+     */
+    weightedInDegree(): F64;
+    /**
+     * NetworkX weighted degree: weightedOutDegree + (directed ? weightedInDegree : selfLoopWeight), so
+     * the sum is 2 * totalWeight() when undirected. Cached and shared: call `.slice()` before writing.
+     * @returns Float64Array(n)
+     */
+    weightedDegree(): F64;
+    /**
+     * Sum of weights over each node's self-loop arcs (selfLoopsPerNode widened when unweighted).
+     * Cached and shared: call `.slice()` before writing.
+     * @returns Float64Array(n)
+     */
+    selfLoopWeight(): F64;
+    /**
+     * Sum of weights over logical edges (each undirected edge once). Cached.
+     * @returns the total weight
+     */
+    totalWeight(): number;
+    /**
+     * The arcs a with colIdx[a] === row(a), found by binary search per row. Cached and shared: call
+     * `.slice()` before writing.
+     * @returns Uint32Array(selfLoopCount)
+     */
+    selfLoopArcs(): U32;
+    /**
+     * Self-loop arcs per node. Cached and shared: call `.slice()` before writing.
+     * @returns Uint32Array(n)
+     */
+    selfLoopsPerNode(): U32;
+    /**
+     * Point query: self-loop arcs at one node, O(log d).
+     * @param u - the node index
+     * @returns the count
+     */
+    selfLoopsAt(u: number): number;
+    /**
+     * For every arc, the arc storing the opposite orientation of the same edge (a self-loop maps to
+     * itself); the lockstep walk of design section 6.4. Undirected only. Cached and shared: call
+     * `.slice()` before writing.
+     * @returns Uint32Array(arcCount); E_DIRECTED on a directed snapshot
+     */
+    mate(): U32;
+    /**
+     * Nodes ordered by descending out-degree of the forward or reverse adjacency with the cuGraph tier
+     * boundaries. Both variants cached; on an undirected snapshot they are the same object.
+     * @param options - which adjacency's degree to order by
+     * @returns the permutation and its tier offsets
+     */
+    degreeOrder(options?: DegreeOrderOptions): DegreeOrderView;
+    /**
+     * Whether the arc set is closed under reversal with equal weights (forward row v equals reverse row
+     * v for every v); true without work when undirected. Cached.
+     * @returns true when symmetric
+     */
+    isSymmetric(): boolean;
+    /**
+     * Compute a set of views eagerly (inside freeze() through FreezeOptions.prepare, or off the critical
+     * path).
+     * @param views - the views to materialise
+     * @returns this snapshot
+     */
+    prepare(views: readonly ViewName[]): this;
+    /**
+     * Release every cached view (and every identity permutation materialised on demand) and every
+     * cached `gpuView()` f32 copy of an f64 column (design section 7.2); they are recomputed on
+     * demand. The checksum records of the dropped views are dropped with them.
+     */
+    dropCaches(): void;
+    /**
+     * Which views are resident.
+     * @returns the names of the cached views, in the fixed ViewName order
+     */
+    cachedViews(): readonly ViewName[];
+    /**
+     * Every directed edge becomes undirected; reciprocal pairs collapse to one edge keeping the lower
+     * index's row (keep-first). Returns `{ snapshot: this, null maps }` on an undirected snapshot.
+     * @param options - reciprocal filtering and the weight reducer
+     * @returns the derived graph
+     */
+    toUndirected(options?: ToUndirectedOptions): DerivedGraph;
+    /**
+     * Orientation of every edge swapped: the reverse view's arrays become the core. Returns this on an
+     * undirected snapshot.
+     * @returns the derived graph (same node and edge spaces)
+     */
+    transpose(): DerivedGraph;
+    /**
+     * One edge per (u, v) group (parallels are adjacent by invariant I4), survivor = lowest index;
+     * flags.multigraph is false afterwards.
+     * @param options - reducers and self-loop policy
+     * @returns the derived graph
+     */
+    simplified(options?: SimplifyOptions): DerivedGraph;
+    /**
+     * Every edge with source !== target.
+     * @returns the derived graph
+     */
+    withoutSelfLoops(): DerivedGraph;
+    /**
+     * Keep the logical edges whose mask bit is set.
+     * @param keep - packed bitmap over logical edges; E_MASK_LENGTH when shorter than ceil(edgeCount / 32) words
+     * @returns the derived graph
+     */
+    filterEdges(keep: EdgeMask): DerivedGraph;
+    /**
+     * The subgraph induced by a node selection: an index list (order = new index order; E_INDEX_RANGE
+     * for an out-of-range or repeated index) or a packed mask (ascending order; E_MASK_LENGTH when
+     * short). Edges with both endpoints kept.
+     * @param selection - the node indices or a mask
+     * @returns the derived graph
+     */
+    inducedSubgraph(selection: U32 | {
+        readonly mask: NodeMask;
+    }): DerivedGraph;
+    /**
+     * Contract the nodes of each partition block into one node (design section 7.3).
+     * @param partition - one label per node; E_PARTITION for a wrong length or an INVALID_INDEX label
+     * @param options - weight reducer, self-loop and parallel policies, column reducers
+     * @returns the derived graph with blockSizes and an identity id map
+     */
+    contract(partition: U32, options?: ContractOptions): DerivedGraph;
+    /**
+     * Permute the node space: perm[newIndex] = oldIndex; the id map follows; edge order is preserved.
+     * @param perm - a permutation of 0..n-1; E_INVALID_PERMUTATION otherwise
+     * @returns the derived graph
+     */
+    relabel(perm: U32): DerivedGraph;
+    /**
+     * A new snapshot object sharing the core, the id map and the serial with a CLONED column set plus
+     * the given columns (the only operation that clones the column set).
+     * @param nodes - node columns to add, keyed by name
+     * @param edges - edge columns to add, keyed by name
+     * @returns the new snapshot
+     */
+    withColumns(nodes?: Readonly<Record<string, TypedArrayData | ColumnInput>>, edges?: Readonly<Record<string, TypedArrayData | ColumnInput>>): GraphSnapshot;
+    /**
+     * Resident bytes of the core (an identity permutation counts zero even when materialised), plus
+     * the side structures selected by the options.
+     * @param options - which side structures to include
+     * @returns the byte count
+     */
+    byteLength(options?: ByteLengthOptions): number;
+    /**
+     * A 64-bit content hash of the core arrays (two 32-bit FNV-1a lanes) as 16 hex characters,
+     * computed lazily and cached (design section 9.3).
+     * @returns the hash
+     */
+    contentHash(): string;
+    /**
+     * The distinct, exclusively owned backing buffers: the postMessage transfer list (design section
+     * 9.1). Buffers shared with another holder (a withColumns() sibling, a derived graph sharing the
+     * node table) are excluded.
+     * @returns the buffers
+     */
+    transferables(): ArrayBuffer[];
+    /**
+     * The plain-object wire form (design section 9.1): a JSON-serialisable manifest plus the backing
+     * buffers. With `transfer: true` only exclusively owned buffers are listed as transferables and
+     * shared ones are copied.
+     * @param options - transfer mode, views and columns to include
+     * @returns the wire snapshot
+     */
+    toWire(options?: ToWireOptions): WireSnapshot;
+    /**
+     * The GSNP byte container as one contiguous buffer (design section 9.2).
+     * @param options - views to include
+     * @returns the container bytes
+     */
+    toBytes(options?: ToBytesOptions): U8;
+    /**
+     * The GSNP container as a sequence of chunks (design section 9.2): the header plus manifest,
+     * then one chunk per non-empty segment.
+     * @param options - views to include
+     * @returns the chunks
+     */
+    toByteChunks(options?: ToBytesOptions): Iterable<U8>;
+    /**
+     * Check the invariants (design section 11.4): the recorded checksums first when `checksum` is set
+     * (a mutated frozen array is the most useful diagnosis, details.reason "checksum"; "no-checksum"
+     * when none were recorded), then "structure" or "full" (default) per the level table of design
+     * section 9.5. Throws E_INVALID_SNAPSHOT with details.invariant and the location on the first
+     * violation.
+     * @param options - level and checksum comparison
+     */
+    validate(options?: ValidateOptions): void;
+    /**
+     * Throw E_DETACHED when the core was transferred away.
+     */
+    private assertAttached;
+    /**
+     * Return the cached value of a view, computing and recording it on first use.
+     * @param name - the view name
+     * @param compute - the computation
+     * @returns the cached value
+     */
+    private cached;
+    /**
+     * Compute both self-loop views in one pass and seed the slot the caller did not ask for.
+     * @returns the two views
+     */
+    private materialiseSelfLoops;
+    /**
+     * Record the digests of a freshly materialised view when checksums are on.
+     * @param name - the view name
+     * @param value - the view
+     */
+    private recordView;
+    /**
+     * Compare every recorded checksum with the current bytes (design section 5.8).
+     */
+    private verifyChecksums;
+    /**
+     * The edge endpoints in declared orientation for the derived-graph functions: the cached edge list
+     * when resident, else a fresh one that is NOT cached (derived graphs must not grow the source's
+     * resident size, design section 7.3).
+     * @returns an edge list view
+     */
+    private edgeEndpoints;
+    /**
+     * Wrap derived parts into a DerivedGraph, creating the new snapshot (with this snapshot's checksum
+     * setting) or returning this for the identity cases.
+     * @param derived - the derived parts
+     * @returns the derived graph
+     */
+    private wrapDerived;
+    /**
+     * Materialise one named view (the prepare() dispatch).
+     * @param name - the view name
+     */
+    private materialiseView;
+}
+/**
+ * Create a snapshot from prepared parts (design section 6.3 step 12): the constructor freezes the
+ * object, records checksums when `parts.checksum` is set and allocates the per-instance view cache.
+ * @param parts - the parts; I1-I13 established by the producer, O(1) length rules checked here
+ * @returns the frozen snapshot
+ */
+export declare function createSnapshot(parts: SnapshotParts): GraphSnapshot;
+/**
+ * Structural check for a snapshot (design section 7.5): the SNAPSHOT_BRAND property plus the
+ * formatVersion, never instanceof, so a duplicated package copy still interoperates.
+ * @param x - any value
+ * @returns true when x is a GraphSnapshot of this format version
+ */
+export declare function isGraphSnapshot(x: unknown): x is GraphSnapshot;
+/**
+ * Compare the core arrays and id maps of two snapshots element by element (design section 7.5):
+ * directedness, counts, rowPtr, colIdx, weights (both absent or equal), arcToEdge / edgeToArc
+ * (identity compared without materialising) and every id (SameValueZero).
+ * @param a - the first snapshot
+ * @param b - the second snapshot
+ * @returns true when the topologies and id maps are equal
+ */
+export declare function equalsTopology(a: GraphSnapshot, b: GraphSnapshot): boolean;
+/**
+ * Install a view value the wire carried (`includeViews`, design section 9.1) into the snapshot's
+ * cache, so the receiver does not recompute it. The caller has already checked that the value has
+ * the shape of the view; the slot is only filled when it is still empty.
+ * @param snapshot - the snapshot
+ * @param name - the view name
+ * @param value - the view value
+ * @returns true when the view was installed, false when the slot was already resident
+ */
+export declare function seedView<K extends ViewName>(snapshot: GraphSnapshot, name: K, value: NonNullable<ViewCache[K]>): boolean;
+/**
+ * The cached value of a view without computing it (for tests and for the wire module's
+ * `includeViews`).
+ * @param snapshot - the snapshot
+ * @param name - the view name
+ * @returns the cached value, or null when not resident
+ */
+export declare function peekView<K extends ViewName>(snapshot: GraphSnapshot, name: K): ViewCache[K];
+/**
+ * Whether the snapshot's permutation arrays are held (materialised) rather than lazy, for tests of
+ * the identity rule and for the wire module (which never serialises an identity permutation).
+ * @param snapshot - the snapshot
+ * @returns true when arcToEdge has been materialised or was supplied
+ */
+export declare function permutationMaterialised(snapshot: GraphSnapshot): boolean;
+/**
+ * Whether checksums were recorded at construction (design section 5.8).
+ * @param snapshot - the snapshot
+ * @returns true when validate({ checksum: true }) can compare
+ */
+export declare function hasChecksums(snapshot: GraphSnapshot): boolean;
+//# sourceMappingURL=graph-snapshot.d.ts.map

package/dist/src/snapshot/graph-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-snapshot.d.ts","sourceRoot":"","sources":["../../../src/snapshot/graph-snapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,EAAiC,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIhF,OAAO,EACH,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EAEtB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,OAAO,EAEZ,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,QAAQ,EACb,KAAK,GAAG,EACR,KAAK,GAAG,EACR,KAAK,SAAS,EACd,KAAK,qBAAqB,EAC1B,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,EAAE,EACP,KAAK,GAAG,EACR,KAAK,eAAe,EACpB,KAAK,QAAQ,EACb,KAAK,YAAY,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAmE1E;;;;;GAKG;AACH,eAAO,MAAM,eAAe,+BAA+B,CAAC;AAE5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAiKnD;;;;;;;;;;;GAWG;AACH,qBAAa,aAAc,YAAW,qBAAqB;IACvD,uEAAuE;IACvE,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC;IAChC,mGAAmG;IACnG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,kDAAkD;IAClD,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC;IAC1B,qCAAqC;IACrC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,wBAAwB;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+CAA+C;IAC/C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IACrB,iFAAiF;IACjF,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IACrB,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,qCAAqC;IACrC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,4DAA4D;IAC5D,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACzD,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAEnC;;;;;OAKG;IACH,iBAAyB,KAAK,CAAgB;IA0E9C;;;;OAIG;IACH,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;;;;;OAKG;IACH,IAAI,SAAS,IAAI,GAAG,CAQnB;IAED;;;;OAIG;IACH,IAAI,SAAS,IAAI,GAAG,CAQnB;IAID;;;;;OAKG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC;IAKzD;;;;OAIG;IACH,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAK9B;;;;;OAKG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAKrC;;;;;OAKG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAIrC;;;;;OAKG;IACH,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC;IAKpE;;;;;OAKG;IACH,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAK1C;;;;OAIG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAS5B;;;;OAIG;IACH,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAS7B;;;;OAIG;IACH,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAI7B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAa/B;;;;OAIG;IACH,OAAO,IAAI,WAAW;IAItB;;;OAGG;IACH,GAAG,IAAI,OAAO;IAId;;;OAGG;IACH,QAAQ,IAAI,YAAY;IAIxB;;;;OAIG;IACH,SAAS,IAAI,GAAG;IAIhB;;;;OAIG;IACH,QAAQ,IAAI,GAAG;IAMf;;;;OAIG;IACH,MAAM,IAAI,GAAG;IAMb;;;;;OAKG;IACH,iBAAiB,IAAI,GAAG;IAQxB;;;;OAIG;IACH,gBAAgB,IAAI,GAAG;IAYvB;;;;OAIG;IACH,cAAc,IAAI,GAAG;IAMrB;;;;OAIG;IACH,cAAc,IAAI,GAAG;IASrB;;;OAGG;IACH,WAAW,IAAI,MAAM;IAIrB;;;;OAIG;IACH,YAAY,IAAI,GAAG;IAInB;;;OAGG;IACH,gBAAgB,IAAI,GAAG;IAIvB;;;;OAIG;IACH,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAK9B;;;;;OAKG;IACH,IAAI,IAAI,GAAG;IAIX;;;;;OAKG;IACH,WAAW,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,eAAe;IAY1D;;;;OAIG;IACH,WAAW,IAAI,OAAO;IAItB;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,IAAI;IAOzC;;;;OAIG;IACH,UAAU,IAAI,IAAI;IAmBlB;;;OAGG;IACH,WAAW,IAAI,SAAS,QAAQ,EAAE;IAYlC;;;;;OAKG;IACH,YAAY,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,YAAY;IAQzD;;;;OAIG;IACH,SAAS,IAAI,YAAY;IAQzB;;;;;OAKG;IACH,UAAU,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,YAAY;IAKnD;;;OAGG;IACH,gBAAgB,IAAI,YAAY;IAKhC;;;;OAIG;IACH,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,YAAY;IAKzC;;;;;;OAMG;IACH,eAAe,CAAC,SAAS,EAAE,GAAG,GAAG;QAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;KAAE,GAAG,YAAY;IAK3E;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,YAAY;IAKjE;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,YAAY;IAKhC;;;;;;OAMG;IACH,WAAW,CACP,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW,CAAC,CAAC,EAC9D,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW,CAAC,CAAC,GAC/D,aAAa;IAehB;;;;;OAKG;IACH,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM;IA8BnD;;;;OAIG;IACH,WAAW,IAAI,MAAM;IAOrB;;;;;OAKG;IACH,aAAa,IAAI,WAAW,EAAE;IAK9B;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,YAAY;IAK7C;;;;OAIG;IACH,OAAO,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,EAAE;IAKrC;;;;;OAKG;IACH,YAAY,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,QAAQ,CAAC,EAAE,CAAC;IAKpD;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,IAAI;IAuC7C;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;;;;OAKG;IACH,OAAO,CAAC,MAAM;IAad;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAc5B;;;;OAIG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,eAAe;IAyDvB;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAgBnB;;;OAGG;IACH,OAAO,CAAC,eAAe;CA2D1B;AAqCD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,GAAG,aAAa,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,aAAa,CAM9D;AAoBD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,OAAO,CAwC1E;AAmBD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,EACvC,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GACjC,OAAO,CAQT;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAM3F;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAGxE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAG7D"}