@elaraai/e3-ui 1.0.83 → 1.0.85

package/dist/src/query/steps.d.ts

@@ -0,0 +1,613 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The query builder's steps (#933) — a query as the builder edits it: a data
+ * source and the steps that read it, in plain words.
+ *
+ * Steps are a projection of a query's jq program: each step prints as a
+ * canonical form of jq (`Query Editor Spec.md` §4.7), and a program made of
+ * canonical forms parses back into its steps. They are East values, because
+ * the builder's edits are drafts of the shared editing session, which holds,
+ * compares and diffs its entries as East values. The functions over them —
+ * printing, parsing, checking, editing and counting — are e3-ui-components'.
+ *
+ * A field is named by a string: `"total"`, `"status"` (a variant's case) or
+ * `"status.shipped.date"` (a field of a case's payload).
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BooleanType, DictType, FloatType, NullType, OptionType, RecursiveType, StringType, StructType, VariantType } from "@elaraai/east";
+/**
+ * A value a step compares with or fills in.
+ *
+ * @property text - Text, a case's name, or a date written as ISO text ("2026-03-01")
+ * @property number - A number; a whole one prints as an Integer
+ * @property boolean - Yes or no
+ * @property null - Nothing
+ */
+export declare const QueryStepValueType: VariantType<{
+    readonly text: StringType;
+    readonly number: FloatType;
+    readonly boolean: BooleanType;
+    readonly null: NullType;
+}>;
+/** Type representing a value a step compares with or fills in. */
+export type QueryStepValueType = typeof QueryStepValueType;
+/**
+ * A count or a bound a step takes: a number, or the text typed when it is not
+ * one, which the check reports.
+ *
+ * @property number - The number
+ * @property text - The text as typed
+ */
+export declare const QueryStepInputType: VariantType<{
+    readonly number: FloatType;
+    readonly text: StringType;
+}>;
+/** Type representing a count or a bound a step takes. */
+export type QueryStepInputType = typeof QueryStepInputType;
+/**
+ * How a step's or a group's conditions combine.
+ *
+ * @property all - Every condition holds
+ * @property any - At least one holds
+ */
+export declare const QueryMatchType: VariantType<{
+    readonly all: NullType;
+    readonly any: NullType;
+}>;
+/** Type representing how conditions combine. */
+export type QueryMatchType = typeof QueryMatchType;
+/**
+ * How a condition compares a field. The builder gives each its words ("is at
+ * least"); the field's kind decides which apply.
+ *
+ * @property eq - Is
+ * @property ne - Is not
+ * @property ge - Is at least
+ * @property le - Is at most
+ * @property gt - Is more than
+ * @property lt - Is less than
+ * @property contains - Contains, for text
+ * @property startsWith - Starts with, for text
+ * @property missing - Is missing, for an optional field
+ * @property present - Has a value, for an optional field
+ * @property yes - Is yes
+ * @property no - Is no
+ * @property inYear - Is in a year, for a date
+ * @property inMonth - Is in a month ("2026-03"), for a date
+ * @property onOrAfter - Is on or after a day, for a date
+ * @property before - Is before a day, for a date
+ * @property lengthAtLeast - Has at least a number of items, for a list
+ * @property anyWhere - Has an item where an inner condition holds, for a list
+ */
+export declare const QueryComparisonType: VariantType<{
+    readonly eq: NullType;
+    readonly ne: NullType;
+    readonly ge: NullType;
+    readonly le: NullType;
+    readonly gt: NullType;
+    readonly lt: NullType;
+    readonly contains: NullType;
+    readonly startsWith: NullType;
+    readonly missing: NullType;
+    readonly present: NullType;
+    readonly yes: NullType;
+    readonly no: NullType;
+    readonly inYear: NullType;
+    readonly inMonth: NullType;
+    readonly onOrAfter: NullType;
+    readonly before: NullType;
+    readonly lengthAtLeast: NullType;
+    readonly anyWhere: NullType;
+}>;
+/** Type representing how a condition compares a field. */
+export type QueryComparisonType = typeof QueryComparisonType;
+/**
+ * A condition of a Keep rows where step: one test of a field, or a group of
+ * conditions with its own match.
+ *
+ * @property test - A field compared: `id` names it for the editing session;
+ *   `field`, `cmp` and `value` are its slots, empty until chosen; `inner` is
+ *   the condition on each item of a list (`anyWhere`); `whole` compares a
+ *   variant as a whole value rather than its case, which the check refuses
+ * @property group - Conditions with their own match: `id` names it, `match`
+ *   combines `conds`
+ */
+export declare const QueryConditionType: RecursiveType<VariantType<{
+    readonly test: StructType<{
+        readonly id: StringType;
+        readonly field: OptionType<StringType>;
+        readonly cmp: OptionType<VariantType<{
+            readonly eq: NullType;
+            readonly ne: NullType;
+            readonly ge: NullType;
+            readonly le: NullType;
+            readonly gt: NullType;
+            readonly lt: NullType;
+            readonly contains: NullType;
+            readonly startsWith: NullType;
+            readonly missing: NullType;
+            readonly present: NullType;
+            readonly yes: NullType;
+            readonly no: NullType;
+            readonly inYear: NullType;
+            readonly inMonth: NullType;
+            readonly onOrAfter: NullType;
+            readonly before: NullType;
+            readonly lengthAtLeast: NullType;
+            readonly anyWhere: NullType;
+        }>>;
+        readonly value: OptionType<VariantType<{
+            readonly text: StringType;
+            readonly number: FloatType;
+            readonly boolean: BooleanType;
+            readonly null: NullType;
+        }>>;
+        readonly inner: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+        readonly whole: BooleanType;
+    }>;
+    readonly group: StructType<{
+        readonly id: StringType;
+        readonly match: VariantType<{
+            readonly all: NullType;
+            readonly any: NullType;
+        }>;
+        readonly conds: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+    }>;
+}>>;
+/** Type representing a condition of a Keep rows where step. */
+export type QueryConditionType = typeof QueryConditionType;
+/**
+ * What a Group and total step totals with.
+ *
+ * @property count - How many rows
+ * @property sum - Adds up a number
+ * @property mean - Averages a number
+ * @property min - The lowest
+ * @property max - The highest
+ * @property distinct - How many different values
+ */
+export declare const QueryAggregateFunctionType: VariantType<{
+    readonly count: NullType;
+    readonly sum: NullType;
+    readonly mean: NullType;
+    readonly min: NullType;
+    readonly max: NullType;
+    readonly distinct: NullType;
+}>;
+/** Type representing what a total totals with. */
+export type QueryAggregateFunctionType = typeof QueryAggregateFunctionType;
+/**
+ * One total of a Group and total step.
+ *
+ * @property id - Names it for the editing session
+ * @property fn - What it totals with
+ * @property field - The field it totals; `none` for a count, and until chosen
+ * @property as - The name of the field it makes. While it is the name the
+ *   builder gives the total (`count`, the field's, `max_cost`), it follows the
+ *   total and its field; the jq holds no more than the name, so that is all a
+ *   total keeps.
+ */
+export declare const QueryAggregateType: StructType<{
+    readonly id: StringType;
+    readonly fn: VariantType<{
+        readonly count: NullType;
+        readonly sum: NullType;
+        readonly mean: NullType;
+        readonly min: NullType;
+        readonly max: NullType;
+        readonly distinct: NullType;
+    }>;
+    readonly field: OptionType<StringType>;
+    readonly as: StringType;
+}>;
+/** Type representing one total of a Group and total step. */
+export type QueryAggregateType = typeof QueryAggregateType;
+/**
+ * What a Group and total step groups by.
+ *
+ * @property field - One group per value of a field
+ * @property all - All rows together, as one group
+ */
+export declare const QueryGroupByType: VariantType<{
+    readonly field: StringType;
+    readonly all: NullType;
+}>;
+/** Type representing what a Group and total step groups by. */
+export type QueryGroupByType = typeof QueryGroupByType;
+/**
+ * Which way a Sort step orders.
+ *
+ * @property asc - Lowest, earliest or A first
+ * @property desc - Highest, latest or Z first
+ */
+export declare const QuerySortDirectionType: VariantType<{
+    readonly asc: NullType;
+    readonly desc: NullType;
+}>;
+/** Type representing which way a Sort step orders. */
+export type QuerySortDirectionType = typeof QuerySortDirectionType;
+/**
+ * The part a Take part of a date step takes.
+ *
+ * @property year - The year, a whole number
+ * @property month - The month, as text ("2026-03")
+ * @property weekday - The day of the week, as text ("Monday")
+ */
+export declare const QueryDatePartType: VariantType<{
+    readonly year: NullType;
+    readonly month: NullType;
+    readonly weekday: NullType;
+}>;
+/** Type representing the part a Take part of a date step takes. */
+export type QueryDatePartType = typeof QueryDatePartType;
+/**
+ * One field a Show only fields step shows.
+ *
+ * @property id - Names it for the editing session
+ * @property field - The field shown; `none` until chosen
+ * @property as - The name it is shown under
+ */
+export declare const QueryPickFieldType: StructType<{
+    readonly id: StringType;
+    readonly field: OptionType<StringType>;
+    readonly as: StringType;
+}>;
+/** Type representing one field a Show only fields step shows. */
+export type QueryPickFieldType = typeof QueryPickFieldType;
+/**
+ * One step of a query. Each has an `id`, which names it for the editing
+ * session; a slot that is `none` is not chosen yet, and a step with an empty
+ * slot it needs is unfinished, and left out of the program.
+ *
+ * @property filter - Keep rows where: `conds`, combined by `match`
+ * @property lookup - Look up from another dataset: the bound `dataset` keyed
+ *   by `key`, a field of the rows; `fields` are its values' fields brought in
+ * @property group - Group and total: `by` a field or all rows together, with
+ *   `aggs` its totals
+ * @property sort - Sort by a `field` in a direction
+ * @property limit - Keep the first `n` rows
+ * @property count - Count the rows
+ * @property pick - Show only these `fields`, each under its name
+ * @property fill - Fill in missing values: where `field` is missing, use `value`
+ * @property drill - Open each list: one row per item of the list `field`
+ * @property datepart - Take part of a date `field`, as a field named `as`
+ * @property walk - List every part in the tree, through its list of parts `via`
+ * @property tabulate - Try the model over a range: the input `over` from
+ *   `from` to `to` every `step`, the other inputs `fixed`, the result named `as`
+ * @property jq - A jq step: its `text`, checked but not shown as words
+ */
+export declare const QueryStepType: VariantType<{
+    readonly filter: StructType<{
+        readonly id: StringType;
+        readonly match: VariantType<{
+            readonly all: NullType;
+            readonly any: NullType;
+        }>;
+        readonly conds: ArrayType<RecursiveType<VariantType<{
+            readonly test: StructType<{
+                readonly id: StringType;
+                readonly field: OptionType<StringType>;
+                readonly cmp: OptionType<VariantType<{
+                    readonly eq: NullType;
+                    readonly ne: NullType;
+                    readonly ge: NullType;
+                    readonly le: NullType;
+                    readonly gt: NullType;
+                    readonly lt: NullType;
+                    readonly contains: NullType;
+                    readonly startsWith: NullType;
+                    readonly missing: NullType;
+                    readonly present: NullType;
+                    readonly yes: NullType;
+                    readonly no: NullType;
+                    readonly inYear: NullType;
+                    readonly inMonth: NullType;
+                    readonly onOrAfter: NullType;
+                    readonly before: NullType;
+                    readonly lengthAtLeast: NullType;
+                    readonly anyWhere: NullType;
+                }>>;
+                readonly value: OptionType<VariantType<{
+                    readonly text: StringType;
+                    readonly number: FloatType;
+                    readonly boolean: BooleanType;
+                    readonly null: NullType;
+                }>>;
+                readonly inner: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly whole: BooleanType;
+            }>;
+            readonly group: StructType<{
+                readonly id: StringType;
+                readonly match: VariantType<{
+                    readonly all: NullType;
+                    readonly any: NullType;
+                }>;
+                readonly conds: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            }>;
+        }>>>;
+    }>;
+    readonly lookup: StructType<{
+        readonly id: StringType;
+        readonly dataset: OptionType<StringType>;
+        readonly key: OptionType<StringType>;
+        readonly fields: ArrayType<StringType>;
+    }>;
+    readonly group: StructType<{
+        readonly id: StringType;
+        readonly by: OptionType<VariantType<{
+            readonly field: StringType;
+            readonly all: NullType;
+        }>>;
+        readonly aggs: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly fn: VariantType<{
+                readonly count: NullType;
+                readonly sum: NullType;
+                readonly mean: NullType;
+                readonly min: NullType;
+                readonly max: NullType;
+                readonly distinct: NullType;
+            }>;
+            readonly field: OptionType<StringType>;
+            readonly as: StringType;
+        }>>;
+    }>;
+    readonly sort: StructType<{
+        readonly id: StringType;
+        readonly field: OptionType<StringType>;
+        readonly dir: VariantType<{
+            readonly asc: NullType;
+            readonly desc: NullType;
+        }>;
+    }>;
+    readonly limit: StructType<{
+        readonly id: StringType;
+        readonly n: VariantType<{
+            readonly number: FloatType;
+            readonly text: StringType;
+        }>;
+    }>;
+    readonly count: StructType<{
+        readonly id: StringType;
+    }>;
+    readonly pick: StructType<{
+        readonly id: StringType;
+        readonly fields: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly field: OptionType<StringType>;
+            readonly as: StringType;
+        }>>;
+    }>;
+    readonly fill: StructType<{
+        readonly id: StringType;
+        readonly field: OptionType<StringType>;
+        readonly value: OptionType<VariantType<{
+            readonly text: StringType;
+            readonly number: FloatType;
+            readonly boolean: BooleanType;
+            readonly null: NullType;
+        }>>;
+    }>;
+    readonly drill: StructType<{
+        readonly id: StringType;
+        readonly field: OptionType<StringType>;
+    }>;
+    readonly datepart: StructType<{
+        readonly id: StringType;
+        readonly field: OptionType<StringType>;
+        readonly part: VariantType<{
+            readonly year: NullType;
+            readonly month: NullType;
+            readonly weekday: NullType;
+        }>;
+        readonly as: StringType;
+    }>;
+    readonly walk: StructType<{
+        readonly id: StringType;
+        readonly via: OptionType<StringType>;
+    }>;
+    readonly tabulate: StructType<{
+        readonly id: StringType;
+        readonly over: StringType;
+        readonly from: VariantType<{
+            readonly number: FloatType;
+            readonly text: StringType;
+        }>;
+        readonly to: VariantType<{
+            readonly number: FloatType;
+            readonly text: StringType;
+        }>;
+        readonly step: VariantType<{
+            readonly number: FloatType;
+            readonly text: StringType;
+        }>;
+        readonly fixed: DictType<StringType, VariantType<{
+            readonly text: StringType;
+            readonly number: FloatType;
+            readonly boolean: BooleanType;
+            readonly null: NullType;
+        }>>;
+        readonly as: StringType;
+    }>;
+    readonly jq: StructType<{
+        readonly id: StringType;
+        readonly text: StringType;
+    }>;
+}>;
+/** Type representing one step of a query. */
+export type QueryStepType = typeof QueryStepType;
+/**
+ * A query as steps: the data source it starts from — a field of the root,
+ * `orders` for `.orders` — and its steps, in order.
+ *
+ * @property source - The data source it starts from
+ * @property steps - Its steps
+ */
+export declare const QueryStepsType: StructType<{
+    readonly source: StringType;
+    readonly steps: ArrayType<VariantType<{
+        readonly filter: StructType<{
+            readonly id: StringType;
+            readonly match: VariantType<{
+                readonly all: NullType;
+                readonly any: NullType;
+            }>;
+            readonly conds: ArrayType<RecursiveType<VariantType<{
+                readonly test: StructType<{
+                    readonly id: StringType;
+                    readonly field: OptionType<StringType>;
+                    readonly cmp: OptionType<VariantType<{
+                        readonly eq: NullType;
+                        readonly ne: NullType;
+                        readonly ge: NullType;
+                        readonly le: NullType;
+                        readonly gt: NullType;
+                        readonly lt: NullType;
+                        readonly contains: NullType;
+                        readonly startsWith: NullType;
+                        readonly missing: NullType;
+                        readonly present: NullType;
+                        readonly yes: NullType;
+                        readonly no: NullType;
+                        readonly inYear: NullType;
+                        readonly inMonth: NullType;
+                        readonly onOrAfter: NullType;
+                        readonly before: NullType;
+                        readonly lengthAtLeast: NullType;
+                        readonly anyWhere: NullType;
+                    }>>;
+                    readonly value: OptionType<VariantType<{
+                        readonly text: StringType;
+                        readonly number: FloatType;
+                        readonly boolean: BooleanType;
+                        readonly null: NullType;
+                    }>>;
+                    readonly inner: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly whole: BooleanType;
+                }>;
+                readonly group: StructType<{
+                    readonly id: StringType;
+                    readonly match: VariantType<{
+                        readonly all: NullType;
+                        readonly any: NullType;
+                    }>;
+                    readonly conds: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+            }>>>;
+        }>;
+        readonly lookup: StructType<{
+            readonly id: StringType;
+            readonly dataset: OptionType<StringType>;
+            readonly key: OptionType<StringType>;
+            readonly fields: ArrayType<StringType>;
+        }>;
+        readonly group: StructType<{
+            readonly id: StringType;
+            readonly by: OptionType<VariantType<{
+                readonly field: StringType;
+                readonly all: NullType;
+            }>>;
+            readonly aggs: ArrayType<StructType<{
+                readonly id: StringType;
+                readonly fn: VariantType<{
+                    readonly count: NullType;
+                    readonly sum: NullType;
+                    readonly mean: NullType;
+                    readonly min: NullType;
+                    readonly max: NullType;
+                    readonly distinct: NullType;
+                }>;
+                readonly field: OptionType<StringType>;
+                readonly as: StringType;
+            }>>;
+        }>;
+        readonly sort: StructType<{
+            readonly id: StringType;
+            readonly field: OptionType<StringType>;
+            readonly dir: VariantType<{
+                readonly asc: NullType;
+                readonly desc: NullType;
+            }>;
+        }>;
+        readonly limit: StructType<{
+            readonly id: StringType;
+            readonly n: VariantType<{
+                readonly number: FloatType;
+                readonly text: StringType;
+            }>;
+        }>;
+        readonly count: StructType<{
+            readonly id: StringType;
+        }>;
+        readonly pick: StructType<{
+            readonly id: StringType;
+            readonly fields: ArrayType<StructType<{
+                readonly id: StringType;
+                readonly field: OptionType<StringType>;
+                readonly as: StringType;
+            }>>;
+        }>;
+        readonly fill: StructType<{
+            readonly id: StringType;
+            readonly field: OptionType<StringType>;
+            readonly value: OptionType<VariantType<{
+                readonly text: StringType;
+                readonly number: FloatType;
+                readonly boolean: BooleanType;
+                readonly null: NullType;
+            }>>;
+        }>;
+        readonly drill: StructType<{
+            readonly id: StringType;
+            readonly field: OptionType<StringType>;
+        }>;
+        readonly datepart: StructType<{
+            readonly id: StringType;
+            readonly field: OptionType<StringType>;
+            readonly part: VariantType<{
+                readonly year: NullType;
+                readonly month: NullType;
+                readonly weekday: NullType;
+            }>;
+            readonly as: StringType;
+        }>;
+        readonly walk: StructType<{
+            readonly id: StringType;
+            readonly via: OptionType<StringType>;
+        }>;
+        readonly tabulate: StructType<{
+            readonly id: StringType;
+            readonly over: StringType;
+            readonly from: VariantType<{
+                readonly number: FloatType;
+                readonly text: StringType;
+            }>;
+            readonly to: VariantType<{
+                readonly number: FloatType;
+                readonly text: StringType;
+            }>;
+            readonly step: VariantType<{
+                readonly number: FloatType;
+                readonly text: StringType;
+            }>;
+            readonly fixed: DictType<StringType, VariantType<{
+                readonly text: StringType;
+                readonly number: FloatType;
+                readonly boolean: BooleanType;
+                readonly null: NullType;
+            }>>;
+            readonly as: StringType;
+        }>;
+        readonly jq: StructType<{
+            readonly id: StringType;
+            readonly text: StringType;
+        }>;
+    }>>;
+}>;
+/** Type representing a query as steps. */
+export type QueryStepsType = typeof QueryStepsType;
+//# sourceMappingURL=steps.d.ts.map

package/dist/src/query/steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps.d.ts","sourceRoot":"","sources":["../../../src/query/steps.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACH,SAAS,EACT,WAAW,EACX,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,UAAU,EACV,aAAa,EACb,UAAU,EACV,UAAU,EACV,WAAW,EACd,MAAM,eAAe,CAAC;AAMvB;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;;;EAK7B,CAAC;AAEH,kEAAkE;AAClE,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC;AAE3D;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;EAG7B,CAAC;AAEH,yDAAyD;AACzD,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC;AAM3D;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;EAGzB,CAAC;AAEH,gDAAgD;AAChD,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;EAmB9B,CAAC;AAEH,0DAA0D;AAC1D,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAc5B,CAAC;AAEJ,+DAA+D;AAC/D,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC;AAM3D;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B;;;;;;;EAOrC,CAAC;AAEH,kDAAkD;AAClD,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAC;AAE3E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAK7B,CAAC;AAEH,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;EAG3B,CAAC;AAEH,+DAA+D;AAC/D,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;;EAGjC,CAAC;AAEH,sDAAsD;AACtD,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAC;AAEH,mEAAmE;AACnE,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;EAI7B,CAAC;AAEH,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC;AAM3D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiExB,CAAC;AAEH,6CAA6C;AAC7C,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC;AAEjD;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGzB,CAAC;AAEH,0CAA0C;AAC1C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC"}