foldkit-entity 0.12.0 → 0.13.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +114 -17
- package/dist/conformance/index.d.mts +22 -4
- package/dist/conformance/index.d.mts.map +1 -1
- package/dist/conformance/index.mjs +196 -81
- package/dist/conformance/index.mjs.map +1 -1
- package/dist/{index-B9fbDo_-.d.mts → index-hu8IYlNc.d.mts} +293 -25
- package/dist/index-hu8IYlNc.d.mts.map +1 -0
- package/dist/index.d.mts +2 -2
- package/dist/index.mjs +1 -1
- package/dist/{src-CSxcKUv6.mjs → src-DBAilaDV.mjs} +494 -86
- package/dist/src-DBAilaDV.mjs.map +1 -0
- package/package.json +1 -1
- package/dist/index-B9fbDo_-.d.mts.map +0 -1
- package/dist/src-CSxcKUv6.mjs.map +0 -1
|
@@ -85,14 +85,17 @@ type Law = Data.TaggedEnum<{
|
|
|
85
85
|
readonly domain: Option.Option<Schema.Top>;
|
|
86
86
|
};
|
|
87
87
|
}>;
|
|
88
|
-
/**
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
readonly
|
|
95
|
-
|
|
88
|
+
/**
|
|
89
|
+
* A law as JSON says it: what `Operators.describe` lists and evidence names.
|
|
90
|
+
* Its witnesses are values as stored and operators by name; its domain is a
|
|
91
|
+
* JSON Schema, or `null` for the operator's whole input.
|
|
92
|
+
*/
|
|
93
|
+
declare const LawDescription: Schema.Struct<{
|
|
94
|
+
readonly kind: Schema.String;
|
|
95
|
+
readonly witnesses: Schema.$Record<Schema.String, Schema.Unknown>;
|
|
96
|
+
readonly domain: Schema.Unknown;
|
|
97
|
+
}>;
|
|
98
|
+
type LawDescription = typeof LawDescription.Type;
|
|
96
99
|
declare const Law: {
|
|
97
100
|
associative: {
|
|
98
101
|
readonly _tag: "Associative";
|
|
@@ -278,6 +281,12 @@ declare const Law: {
|
|
|
278
281
|
readonly domain: Option.Option<Schema.Top>;
|
|
279
282
|
}, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Absorbing" | "Associative" | "Commutative" | "Distributes" | "Idempotent" | "Identity" | "Inverse" | "Monotonic" | "PreservesCollation"]>>;
|
|
280
283
|
};
|
|
284
|
+
/**
|
|
285
|
+
* The operators a law, as JSON, calls besides its own (`inverse`'s and
|
|
286
|
+
* `distributes`' witnesses), by name: evidence of it is of their
|
|
287
|
+
* implementations too, and goes when one of them is replaced.
|
|
288
|
+
*/
|
|
289
|
+
witnessesNamed: (law: LawDescription) => ReadonlyArray<string>;
|
|
281
290
|
/** The law as JSON: its kind, its witnesses (operators by name) and its domain's JSON Schema. */
|
|
282
291
|
describe: (law: Law) => LawDescription;
|
|
283
292
|
};
|
|
@@ -362,9 +371,20 @@ interface OperatorDescriptor {
|
|
|
362
371
|
interface OperatorTable {
|
|
363
372
|
/** Whether this table implements the operator. */
|
|
364
373
|
readonly has: (operator: OperatorDescriptor) => boolean;
|
|
374
|
+
/**
|
|
375
|
+
* The versions of the operator `id` it implements: what a refusal of a call
|
|
376
|
+
* to another version names, since a client and a server on different
|
|
377
|
+
* deploys can disagree on one.
|
|
378
|
+
*/
|
|
379
|
+
readonly versions: (id: string) => ReadonlyArray<number>;
|
|
365
380
|
}
|
|
366
381
|
/** A table implementing nothing: every primitive operator is unsupported by it. */
|
|
367
382
|
declare const noOperators: OperatorTable;
|
|
383
|
+
/**
|
|
384
|
+
* An operator `operators` does not implement, by name, with the versions of it
|
|
385
|
+
* the table does implement: `acme.slug@2 (this table has acme.slug)`.
|
|
386
|
+
*/
|
|
387
|
+
declare const missingName: (operator: OperatorDescriptor, operators: OperatorTable) => string;
|
|
368
388
|
/**
|
|
369
389
|
* A call of an operator whose result is a scalar. `expansion` is the
|
|
370
390
|
* expression it means, built from its arguments when it was called: an
|
|
@@ -680,6 +700,12 @@ declare const Expr: {
|
|
|
680
700
|
* out. A call with no definition stays, for the interpreter to run or refuse
|
|
681
701
|
* by name.
|
|
682
702
|
*/
|
|
703
|
+
/**
|
|
704
|
+
* Whether a constant written in these expressions is text holding a NUL, or
|
|
705
|
+
* a list holding one: SQL refuses such a parameter wherever it compiles, so
|
|
706
|
+
* an interpreter refuses the run, not one row.
|
|
707
|
+
*/
|
|
708
|
+
givesNul: (...nodes: ReadonlyArray<AnyExpr | Predicate>) => boolean;
|
|
683
709
|
expanded: <N extends Predicate | AnyExpr>(node: N) => N extends Predicate ? Predicate : AnyExpr;
|
|
684
710
|
/**
|
|
685
711
|
* What these expressions need that an interpreter lacks, as `Query.unsupported`
|
|
@@ -741,7 +767,7 @@ declare const Expr: {
|
|
|
741
767
|
* nullable column that should match everything on an empty search says so:
|
|
742
768
|
* `Expr.or(Expr.isNull(field), Expr.contains(field, input.search))`.
|
|
743
769
|
*/
|
|
744
|
-
contains: <L extends TextOperand>(value: L, search: string |
|
|
770
|
+
contains: <L extends TextOperand>(value: L, search: string | LiteralExpr<string> | InputExpr<string> | InputExpr<string | null>) => ContainsPredicate & Reads<ReadsOf<L>>;
|
|
745
771
|
/**
|
|
746
772
|
* Whether a value is one of `among`: a list written out, or an input whose
|
|
747
773
|
* value is one. Each element is compared as `eq` compares.
|
|
@@ -981,6 +1007,12 @@ declare const Query: {
|
|
|
981
1007
|
placement: (self: AnyQuery, input: Readonly<Record<string, unknown>>, options?: {
|
|
982
1008
|
readonly operators?: OperatorTable | undefined;
|
|
983
1009
|
}) => Placement;
|
|
1010
|
+
/**
|
|
1011
|
+
* Each operator the body calls, by name (`id`, or `id@version` past the
|
|
1012
|
+
* first), in the order it first calls them: a defined one, and each
|
|
1013
|
+
* primitive one its expansion calls.
|
|
1014
|
+
*/
|
|
1015
|
+
operators: (self: AnyQuery) => ReadonlyArray<string>;
|
|
984
1016
|
/**
|
|
985
1017
|
* What the whole query reads: the fields and inputs of every predicate and
|
|
986
1018
|
* every ordering term, and the operations it uses, with the fields also
|
|
@@ -1023,6 +1055,7 @@ declare const Query: {
|
|
|
1023
1055
|
*/
|
|
1024
1056
|
show: (self: AnyQuery) => string;
|
|
1025
1057
|
};
|
|
1058
|
+
declare const testedByRunner: (record: Evidence) => boolean;
|
|
1026
1059
|
/** What an implementation is told besides its arguments. */
|
|
1027
1060
|
interface OperatorContext {
|
|
1028
1061
|
/** The collation the call compares text under, from its operator's `collation` rule. */
|
|
@@ -1153,17 +1186,43 @@ declare const Evidence: {
|
|
|
1153
1186
|
type TestedEvidence = Extract<Evidence, {
|
|
1154
1187
|
readonly _tag: 'Tested';
|
|
1155
1188
|
}>;
|
|
1156
|
-
/**
|
|
1157
|
-
|
|
1158
|
-
|
|
1159
|
-
|
|
1160
|
-
|
|
1189
|
+
/**
|
|
1190
|
+
* An operator as JSON, by its signature and never its body (a defined
|
|
1191
|
+
* operator says `defined`, not what it means): what a server can publish of
|
|
1192
|
+
* what a body may call, and a client compare with what it runs. Its schemas
|
|
1193
|
+
* are each argument's and the result's stored side, as JSON Schemas.
|
|
1194
|
+
*/
|
|
1195
|
+
declare const OperatorDescription: Schema.Struct<{
|
|
1196
|
+
/** By id, and `@version` past the first: what tables, evidence and refusals name. */
|
|
1197
|
+
readonly name: Schema.String;
|
|
1198
|
+
readonly id: Schema.String;
|
|
1199
|
+
readonly version: Schema.Int;
|
|
1200
|
+
readonly description: Schema.NullOr<Schema.String>;
|
|
1201
|
+
readonly input: Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>;
|
|
1202
|
+
readonly output: Schema.$Record<Schema.String, Schema.Unknown>;
|
|
1203
|
+
readonly nulls: Schema.Literals<readonly ["strict", "handled"]>;
|
|
1204
|
+
readonly collation: Schema.Literals<readonly ["none", "operands", "required"]>;
|
|
1205
|
+
readonly laws: Schema.$Array<Schema.Struct<{
|
|
1206
|
+
readonly kind: Schema.String;
|
|
1207
|
+
readonly witnesses: Schema.$Record<Schema.String, Schema.Unknown>;
|
|
1208
|
+
readonly domain: Schema.Unknown;
|
|
1209
|
+
}>>;
|
|
1210
|
+
readonly defined: Schema.Boolean;
|
|
1211
|
+
}>;
|
|
1212
|
+
type OperatorDescription = typeof OperatorDescription.Type;
|
|
1213
|
+
/** One operator a table implements, as `Operators.describeTable` lists it: described, with its evidence. */
|
|
1214
|
+
interface ImplementedOperator extends OperatorDescription {
|
|
1161
1215
|
readonly evidence: ReadonlyArray<Evidence>;
|
|
1162
1216
|
}
|
|
1163
1217
|
/** The in-memory interpreter's implementations, by operator. */
|
|
1164
1218
|
interface MemoryOperators extends OperatorTable {
|
|
1165
1219
|
readonly _tag: 'MemoryOperators';
|
|
1166
1220
|
readonly get: (operator: OperatorDescriptor) => Option.Option<MemoryImplementation['run']>;
|
|
1221
|
+
/**
|
|
1222
|
+
* The operator it implements under a name (`id`, or `id@version` past the
|
|
1223
|
+
* first): how a computed assignment carried as data finds what to run.
|
|
1224
|
+
*/
|
|
1225
|
+
readonly named: (name: string) => Option.Option<OperatorDescriptor>;
|
|
1167
1226
|
/** Whether each answer is checked against its operator's output schema: for tests. */
|
|
1168
1227
|
readonly checked: boolean;
|
|
1169
1228
|
readonly implementations: ReadonlyArray<MemoryImplementation>;
|
|
@@ -1200,16 +1259,38 @@ declare const Operators: {
|
|
|
1200
1259
|
/**
|
|
1201
1260
|
* The table with what is known of its implementations' laws recorded: each
|
|
1202
1261
|
* record of an operator it implements and a law that operator declares.
|
|
1203
|
-
* `Conformance.laws` gives `Tested` records
|
|
1204
|
-
*
|
|
1262
|
+
* `Conformance.laws` gives `Tested` records, each of the implementation it
|
|
1263
|
+
* ran, and a table takes only those of its own; `Evidence.Proven` says a
|
|
1264
|
+
* proof elsewhere covers one.
|
|
1205
1265
|
*/
|
|
1206
1266
|
withEvidence: (base: MemoryOperators, evidence: ReadonlyArray<Evidence>) => MemoryOperators;
|
|
1267
|
+
/**
|
|
1268
|
+
* The memory implementation `Conformance.laws` tested a record on; none for
|
|
1269
|
+
* a record of a runner (`Conformance.lawsBy`) or a proof.
|
|
1270
|
+
*/
|
|
1271
|
+
testedOn: (record: Evidence) => Option.Option<MemoryImplementation>;
|
|
1272
|
+
/**
|
|
1273
|
+
* Whether `Conformance.lawsBy` made a record, through a runner: what an SQL
|
|
1274
|
+
* table takes. Which runner it was, the database's or another, is the
|
|
1275
|
+
* caller's word; a record built by hand, copied, or tested in memory is not.
|
|
1276
|
+
*/
|
|
1277
|
+
testedByRunner: typeof testedByRunner;
|
|
1207
1278
|
/**
|
|
1208
1279
|
* Each operator the table implements, by name, with the laws it declares and
|
|
1209
1280
|
* the evidence the table records of them: what a server can publish of how
|
|
1210
1281
|
* it runs a body. JSON as it is.
|
|
1211
1282
|
*/
|
|
1212
1283
|
describeTable: (base: MemoryOperators) => ReadonlyArray<ImplementedOperator>;
|
|
1284
|
+
/**
|
|
1285
|
+
* An operator as JSON (`OperatorDescription`): its name, version and
|
|
1286
|
+
* description, each argument's and its result's stored side as a JSON
|
|
1287
|
+
* Schema (as JSON carries it: a number also admits the strings `"Infinity"`,
|
|
1288
|
+
* `"-Infinity"` and `"NaN"`), its null and collation rules, its laws, and
|
|
1289
|
+
* whether it is defined. Its signature, never its body.
|
|
1290
|
+
*/
|
|
1291
|
+
describe: (operator: {
|
|
1292
|
+
readonly descriptor: OperatorDescriptor;
|
|
1293
|
+
}) => OperatorDescription;
|
|
1213
1294
|
/**
|
|
1214
1295
|
* The table, checking every answer against its operator's output schema, so
|
|
1215
1296
|
* an implementation that answers the wrong kind fails where it answered. For
|
|
@@ -1233,8 +1314,18 @@ declare class OperatorMissingError extends QueryEvaluateError {
|
|
|
1233
1314
|
readonly operator: OperatorDescriptor;
|
|
1234
1315
|
/** The operator by its id, and its version past the first. */
|
|
1235
1316
|
readonly named: string;
|
|
1236
|
-
|
|
1317
|
+
/** `operators`, the table that lacks it, names the versions of it that it does hold. */
|
|
1318
|
+
constructor(operator: OperatorDescriptor, operators?: OperatorTable);
|
|
1237
1319
|
}
|
|
1320
|
+
/**
|
|
1321
|
+
* A primitive operator over stored values, as a call of it is run: what a
|
|
1322
|
+
* computed assignment comes to (`Write.apply`). Refused, as a call is, when
|
|
1323
|
+
* `operators` does not implement it.
|
|
1324
|
+
*/
|
|
1325
|
+
declare const applyOperator: (operator: OperatorDescriptor, values: ReadonlyArray<unknown>, options: {
|
|
1326
|
+
readonly collation: Option.Option<Collation>;
|
|
1327
|
+
readonly operators: MemoryOperators;
|
|
1328
|
+
}) => unknown;
|
|
1238
1329
|
/** SQL's unknown: neither true nor false, and a row is kept only on true. */
|
|
1239
1330
|
type Truth = boolean | 'unknown';
|
|
1240
1331
|
/**
|
|
@@ -1296,6 +1387,25 @@ declare const assertSupported: (body: AnyQuery, operators?: MemoryOperators) =>
|
|
|
1296
1387
|
declare const evaluate: (body: AnyQuery, input: Row, rows: ReadonlyArray<Row>, options?: {
|
|
1297
1388
|
readonly operators?: MemoryOperators | undefined;
|
|
1298
1389
|
}) => ReadonlyArray<Row>;
|
|
1390
|
+
/** What `evaluateEach` made of each row: those it matched, in order, and those it refused. */
|
|
1391
|
+
interface Evaluated {
|
|
1392
|
+
readonly matched: ReadonlyArray<Row>;
|
|
1393
|
+
readonly refused: ReadonlyArray<Row>;
|
|
1394
|
+
}
|
|
1395
|
+
/**
|
|
1396
|
+
* As `evaluate`, with each row judged alone: a row whose own values are
|
|
1397
|
+
* refused (text holding a NUL, a value an operator fails on) is set aside in
|
|
1398
|
+
* `refused` and the others are still answered. A client judging the rows it
|
|
1399
|
+
* holds wants this, since one bad stored row says nothing about the rest.
|
|
1400
|
+
*
|
|
1401
|
+
* What no single row causes still refuses the run: an operation or operator
|
|
1402
|
+
* the table lacks, an order by a locale collation, an input the body reads
|
|
1403
|
+
* holding a NUL (every row would refuse, and no row is the cause), and order
|
|
1404
|
+
* keys of different kinds across rows.
|
|
1405
|
+
*/
|
|
1406
|
+
declare const evaluateEach: (body: AnyQuery, input: Row, rows: ReadonlyArray<Row>, options?: {
|
|
1407
|
+
readonly operators?: MemoryOperators | undefined;
|
|
1408
|
+
}) => Evaluated;
|
|
1299
1409
|
/** One invariant of an Entity, as its interpreters read it. */
|
|
1300
1410
|
interface Invariant {
|
|
1301
1411
|
/** Stable, unique within its Entity: what a refusal names, and forms and logs key on. */
|
|
@@ -1391,9 +1501,11 @@ declare const Text: {
|
|
|
1391
1501
|
* | the prefix is `''` | true |
|
|
1392
1502
|
* | otherwise | whether it begins so, compared under the collation |
|
|
1393
1503
|
*
|
|
1394
|
-
* The collation is the text
|
|
1395
|
-
*
|
|
1396
|
-
*
|
|
1504
|
+
* The collation is the one its text operands share (a field's declared one,
|
|
1505
|
+
* or a call's), or one given to the call. `binary` compares exactly;
|
|
1506
|
+
* `asciiFold` folds ASCII letters on both sides. Operands declaring
|
|
1507
|
+
* different collations, text with none, or a backend's locale are refused
|
|
1508
|
+
* where the call is written.
|
|
1397
1509
|
* Prefixes are by character, so non-ASCII and astral text begin as they read.
|
|
1398
1510
|
*
|
|
1399
1511
|
* ```ts
|
|
@@ -1458,6 +1570,121 @@ interface WriteSet {
|
|
|
1458
1570
|
interface WriteIncrement extends WriteSet {
|
|
1459
1571
|
readonly integer: boolean;
|
|
1460
1572
|
}
|
|
1573
|
+
/**
|
|
1574
|
+
* One field the write computes (`label := concat(title, ' draft')`): an
|
|
1575
|
+
* expression over the row before the write and the input, every defined
|
|
1576
|
+
* operator in it expanded, so what is carried is primitive calls alone.
|
|
1577
|
+
*/
|
|
1578
|
+
interface WriteAssignment {
|
|
1579
|
+
readonly field: AnyField;
|
|
1580
|
+
readonly expr: AnyExpr;
|
|
1581
|
+
}
|
|
1582
|
+
/**
|
|
1583
|
+
* A computed assignment as data, bound to one input: what travels to a server
|
|
1584
|
+
* and sits in a client's pending patch, which holds no descriptor and no
|
|
1585
|
+
* function. A field of the row before the write, a stored value, or a call of
|
|
1586
|
+
* a primitive operator by name (`id`, or `id@version`), with the collation it
|
|
1587
|
+
* compares text under (`null` for none: this is JSON).
|
|
1588
|
+
*/
|
|
1589
|
+
type Computation = Data.TaggedEnum<{
|
|
1590
|
+
Field: {
|
|
1591
|
+
readonly key: string;
|
|
1592
|
+
};
|
|
1593
|
+
Value: {
|
|
1594
|
+
readonly value: unknown;
|
|
1595
|
+
};
|
|
1596
|
+
Call: {
|
|
1597
|
+
readonly operator: string;
|
|
1598
|
+
readonly args: ReadonlyArray<Computation>;
|
|
1599
|
+
readonly collation: Collation | null;
|
|
1600
|
+
};
|
|
1601
|
+
}>;
|
|
1602
|
+
declare const Computation: {
|
|
1603
|
+
readonly $is: <Tag extends "Call" | "Field" | "Value">(tag: Tag) => (u: unknown) => u is Extract<{
|
|
1604
|
+
readonly _tag: "Call";
|
|
1605
|
+
readonly operator: string;
|
|
1606
|
+
readonly args: ReadonlyArray<Computation>;
|
|
1607
|
+
readonly collation: Collation | null;
|
|
1608
|
+
}, {
|
|
1609
|
+
readonly _tag: Tag;
|
|
1610
|
+
}> | Extract<{
|
|
1611
|
+
readonly _tag: "Field";
|
|
1612
|
+
readonly key: string;
|
|
1613
|
+
}, {
|
|
1614
|
+
readonly _tag: Tag;
|
|
1615
|
+
}> | Extract<{
|
|
1616
|
+
readonly _tag: "Value";
|
|
1617
|
+
readonly value: unknown;
|
|
1618
|
+
}, {
|
|
1619
|
+
readonly _tag: Tag;
|
|
1620
|
+
}>;
|
|
1621
|
+
readonly $match: {
|
|
1622
|
+
<Cases extends { readonly [Tag in "Call" | "Field" | "Value"]: (args: Extract<{
|
|
1623
|
+
readonly _tag: "Call";
|
|
1624
|
+
readonly operator: string;
|
|
1625
|
+
readonly args: ReadonlyArray<Computation>;
|
|
1626
|
+
readonly collation: Collation | null;
|
|
1627
|
+
} | {
|
|
1628
|
+
readonly _tag: "Field";
|
|
1629
|
+
readonly key: string;
|
|
1630
|
+
} | {
|
|
1631
|
+
readonly _tag: "Value";
|
|
1632
|
+
readonly value: unknown;
|
|
1633
|
+
}, {
|
|
1634
|
+
readonly _tag: Tag;
|
|
1635
|
+
}>) => any; }>(cases: Cases): (value: {
|
|
1636
|
+
readonly _tag: "Call";
|
|
1637
|
+
readonly operator: string;
|
|
1638
|
+
readonly args: ReadonlyArray<Computation>;
|
|
1639
|
+
readonly collation: Collation | null;
|
|
1640
|
+
} | {
|
|
1641
|
+
readonly _tag: "Field";
|
|
1642
|
+
readonly key: string;
|
|
1643
|
+
} | {
|
|
1644
|
+
readonly _tag: "Value";
|
|
1645
|
+
readonly value: unknown;
|
|
1646
|
+
}) => import("effect/Unify").Unify<ReturnType<Cases["Call" | "Field" | "Value"]>>;
|
|
1647
|
+
<Cases extends { readonly [Tag in "Call" | "Field" | "Value"]: (args: Extract<{
|
|
1648
|
+
readonly _tag: "Call";
|
|
1649
|
+
readonly operator: string;
|
|
1650
|
+
readonly args: ReadonlyArray<Computation>;
|
|
1651
|
+
readonly collation: Collation | null;
|
|
1652
|
+
} | {
|
|
1653
|
+
readonly _tag: "Field";
|
|
1654
|
+
readonly key: string;
|
|
1655
|
+
} | {
|
|
1656
|
+
readonly _tag: "Value";
|
|
1657
|
+
readonly value: unknown;
|
|
1658
|
+
}, {
|
|
1659
|
+
readonly _tag: Tag;
|
|
1660
|
+
}>) => any; }>(value: {
|
|
1661
|
+
readonly _tag: "Call";
|
|
1662
|
+
readonly operator: string;
|
|
1663
|
+
readonly args: ReadonlyArray<Computation>;
|
|
1664
|
+
readonly collation: Collation | null;
|
|
1665
|
+
} | {
|
|
1666
|
+
readonly _tag: "Field";
|
|
1667
|
+
readonly key: string;
|
|
1668
|
+
} | {
|
|
1669
|
+
readonly _tag: "Value";
|
|
1670
|
+
readonly value: unknown;
|
|
1671
|
+
}, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Call" | "Field" | "Value"]>>;
|
|
1672
|
+
};
|
|
1673
|
+
readonly Call: Data.TaggedEnum.ConstructorFrom<{
|
|
1674
|
+
readonly _tag: "Call";
|
|
1675
|
+
readonly operator: string;
|
|
1676
|
+
readonly args: ReadonlyArray<Computation>;
|
|
1677
|
+
readonly collation: Collation | null;
|
|
1678
|
+
}, "_tag">;
|
|
1679
|
+
readonly Field: Data.TaggedEnum.ConstructorFrom<{
|
|
1680
|
+
readonly _tag: "Field";
|
|
1681
|
+
readonly key: string;
|
|
1682
|
+
}, "_tag">;
|
|
1683
|
+
readonly Value: Data.TaggedEnum.ConstructorFrom<{
|
|
1684
|
+
readonly _tag: "Value";
|
|
1685
|
+
readonly value: unknown;
|
|
1686
|
+
}, "_tag">;
|
|
1687
|
+
};
|
|
1461
1688
|
/** One input key the write points at another row with: a `one` relation, by the target's id. */
|
|
1462
1689
|
interface WriteLink {
|
|
1463
1690
|
readonly key: string;
|
|
@@ -1494,6 +1721,8 @@ interface Write<E extends AnyEntity, Fields extends Schema.Struct.Fields> {
|
|
|
1494
1721
|
* computed where the write commits: the input key, and the field it moves.
|
|
1495
1722
|
*/
|
|
1496
1723
|
readonly increments: ReadonlyArray<WriteIncrement>;
|
|
1724
|
+
/** The fields it computes, each from the row before the write and the input. */
|
|
1725
|
+
readonly assignments: ReadonlyArray<WriteAssignment>;
|
|
1497
1726
|
/** The `one` relations it points elsewhere, in the input's order. */
|
|
1498
1727
|
readonly links: ReadonlyArray<WriteLink>;
|
|
1499
1728
|
}
|
|
@@ -1510,9 +1739,19 @@ interface RowOptions<Fields extends Schema.Struct.Fields> {
|
|
|
1510
1739
|
type NumberKeys<Fields> = { [K in keyof Fields & string]: Fields[K] extends Schema.Top ? Schema.Schema.Type<Fields[K]> extends number ? K : never : never; }[keyof Fields & string];
|
|
1511
1740
|
/** An update's increments: a number field of the Entity, by the input key holding the amount. */
|
|
1512
1741
|
type WriteIncrements<E extends AnyEntity, Fields extends Schema.Struct.Fields> = { readonly [K in NumberKeys<{ [F in keyof E['fields']]: E['fields'][F]['schema']; }>]?: NumberKeys<Fields>; };
|
|
1513
|
-
/**
|
|
1742
|
+
/**
|
|
1743
|
+
* An update's computed fields: each a field of the Entity, by what it comes
|
|
1744
|
+
* to over the row before the write (`row`, each field as `Expr.field`) and
|
|
1745
|
+
* the input. Its kind is checked against the field's where it is declared.
|
|
1746
|
+
*/
|
|
1747
|
+
type WriteComputations<E extends AnyEntity, Fields extends Schema.Struct.Fields> = { readonly [F in keyof E['fields'] & string]?: (context: {
|
|
1748
|
+
readonly row: BeforeRow<E>;
|
|
1749
|
+
readonly input: { readonly [K in keyof Fields & string]: InputExpr<Schema.Schema.Type<Fields[K]>>; };
|
|
1750
|
+
}) => AnyExpr; };
|
|
1751
|
+
/** An update's options: a row's, what it moves by an amount, and what it computes. */
|
|
1514
1752
|
type UpdateOptions<E extends AnyEntity, Fields extends Schema.Struct.Fields> = RowOptions<Fields> & {
|
|
1515
1753
|
readonly increment?: WriteIncrements<E, Fields>;
|
|
1754
|
+
readonly compute?: WriteComputations<E, Fields>;
|
|
1516
1755
|
};
|
|
1517
1756
|
/** `update`: conditioned when given `when`, which the overloads tell apart. */
|
|
1518
1757
|
interface UpdateWrite {
|
|
@@ -1553,6 +1792,8 @@ interface BoundWrite {
|
|
|
1553
1792
|
readonly links: Readonly<Record<string, Option.Option<EntityRef>>>;
|
|
1554
1793
|
/** Each field it moves, by the amount, encoded: added by the server, and predicted over what a client holds. */
|
|
1555
1794
|
readonly increments: Readonly<Record<string, number>>;
|
|
1795
|
+
/** Each field it computes, as data: run by the server where it writes, predicted by a client. */
|
|
1796
|
+
readonly assignments: Readonly<Record<string, Computation>>;
|
|
1556
1797
|
}
|
|
1557
1798
|
declare const Write: {
|
|
1558
1799
|
/**
|
|
@@ -1572,6 +1813,12 @@ declare const Write: {
|
|
|
1572
1813
|
* `when` is what the row must hold for the update to land, checked where it
|
|
1573
1814
|
* commits (`({ input }) => Expr.eq(Post.fields.status, 'draft')`); a row it
|
|
1574
1815
|
* does not hold of is refused as unmet.
|
|
1816
|
+
*
|
|
1817
|
+
* `compute` sets a field to what an expression comes to over the row before
|
|
1818
|
+
* the write and the input, run where it commits
|
|
1819
|
+
* (`{ label: ({ row }) => concat(row.title, ' draft') }`). It is refused for
|
|
1820
|
+
* a field another key writes, an expression over the row after the write or
|
|
1821
|
+
* another Entity, or one of a kind the field does not store.
|
|
1575
1822
|
*/
|
|
1576
1823
|
update: UpdateWrite;
|
|
1577
1824
|
/**
|
|
@@ -1603,8 +1850,9 @@ declare const Write: {
|
|
|
1603
1850
|
writes: (write: AnyWrite) => ReadonlyArray<AnyField | OneRelation>;
|
|
1604
1851
|
/**
|
|
1605
1852
|
* The fields a write reads from the row it writes: those its `when` reads,
|
|
1606
|
-
* each it increments, and the revision it
|
|
1607
|
-
* must read, and what a startup check judges
|
|
1853
|
+
* each it increments, each its assignments read, and the revision it
|
|
1854
|
+
* expects. What an interpreter must read, and what a startup check judges
|
|
1855
|
+
* it could disclose.
|
|
1608
1856
|
*/
|
|
1609
1857
|
reads: (write: AnyWrite) => ReadonlyArray<AnyField>;
|
|
1610
1858
|
/**
|
|
@@ -1614,6 +1862,26 @@ declare const Write: {
|
|
|
1614
1862
|
* the input is still the whole, validated value.
|
|
1615
1863
|
*/
|
|
1616
1864
|
bind: <Fields extends Schema.Struct.Fields>(write: Write<AnyEntity, Fields>, value: Schema.Struct.Type<Fields>, keys?: ReadonlyArray<string>) => BoundWrite;
|
|
1865
|
+
/**
|
|
1866
|
+
* The fields of the row before it that a bound write's amounts and
|
|
1867
|
+
* assignments read: what to read to work out the row it leaves.
|
|
1868
|
+
*/
|
|
1869
|
+
boundReads: (bound: Pick<BoundWrite, 'increments' | 'assignments'>) => ReadonlyArray<string>;
|
|
1870
|
+
/**
|
|
1871
|
+
* The row a bound write leaves over `row`, the row before it: its values
|
|
1872
|
+
* set, each amount added (a null stays null, as in SQL), and each
|
|
1873
|
+
* assignment computed by `operators` over the row before. `unknown` names
|
|
1874
|
+
* each field it could not work out: one `row` lacks, or holds as no number
|
|
1875
|
+
* for an amount, or an assignment calling an operator the table lacks. That
|
|
1876
|
+
* field keeps what `row` holds. The one computation of this row: a guard
|
|
1877
|
+
* judges it, a writer explains a miss with it, a client predicts it.
|
|
1878
|
+
*/
|
|
1879
|
+
apply: (row: Readonly<Record<string, unknown>>, bound: Pick<BoundWrite, 'values' | 'increments' | 'assignments'>, options: {
|
|
1880
|
+
readonly operators: MemoryOperators;
|
|
1881
|
+
}) => {
|
|
1882
|
+
readonly row: Readonly<Record<string, unknown>>;
|
|
1883
|
+
readonly unknown: ReadonlyArray<string>;
|
|
1884
|
+
};
|
|
1617
1885
|
};
|
|
1618
1886
|
declare const EntityTypeId: unique symbol;
|
|
1619
1887
|
type EntityTypeId = typeof EntityTypeId;
|
|
@@ -1956,5 +2224,5 @@ declare const Relation: {
|
|
|
1956
2224
|
declare const Derived: {
|
|
1957
2225
|
make: <S extends Schema.Constraint>(schema: S) => DerivedSpec<S>;
|
|
1958
2226
|
};
|
|
1959
|
-
export {
|
|
1960
|
-
//# sourceMappingURL=index-
|
|
2227
|
+
export { Text as $, Operator as $t, SelectionPage as A, AnyQuery as At, Computation as B, EqPredicate as Bt, Relation as C, Law as Cn, MemoryOperators as Ct, RelationSpecs as D, TestedEvidence as Dt, RelationSpec as E, Collation as En, Operators as Et, WrittenAs as F, ChosenSort as Ft, WriteCondition as G, InputExpr as Gt, Write as H, FieldDependency as Ht, WrittenKey as I, CompareOperator as It, WriteSet as J, NextExpr as Jt, WriteIncrement as K, Invalid as Kt, WrittenSpec as L, ComparePredicate as Lt, SelectionTypeId as M, CallExpr as Mt, TargetKey as N, CallOptions as Nt, Selected as O, AndPredicate as Ot, Unmapped as P, ChosenOrder as Pt, ReadFilter as Q, Operation as Qt, AnyWrite as R, ContainsPredicate as Rt, RelatedSpecs as S, noOperators as Sn, MemoryImplementation as St, RelationMap as T, Side as Tn, OperatorDescription as Tt, WriteAssignment as U, FieldExpr as Ut, ConditionedWrite as V, Expr as Vt, WriteComputations as W, InPredicate as Wt, SchemaWords as X, NullPredicate as Xt, SchemaShape as Y, NotPredicate as Yt, Words as Z, Operandish as Zt, IdSchemaOf as _, ValueOf as _n, supported as _t, DerivedSpecs as a, OrderedOperand as an, Judgement as at, PageWindow as b, maxQueryNodes as bn, Evidence as bt, EntityDerived as c, Placement as cn, PredicateTruth as ct, EntityInput as d, QueryDependencies as dn, applyOperator as dt, OperatorDescriptor as en, AfterRow as et, EntityMember as f, Reads as fn, assertSupported as ft, IdOf as g, TextOperand as gn, evaluateEach as gt, EntityTypeId as h, TestPredicate as hn, evaluate as ht, DerivedSpec as i, OrderTerm as in, Invariant as it, SelectionPageTypeId as j, ArgumentOf as jt, Selection as k, AnyExpr as kt, EntityField as l, Predicate as ln, QueryEvaluateError as lt, EntityRelation as m, TermOptions as mn, decided as mt, Cardinality as n, OrPredicate as nn, Change as nt, Entities as o, Ordering as on, Evaluated as ot, EntityRef as p, ReadsOf as pn, compareRows as pt, WriteLink as q, LiteralExpr as qt, Derived as r, Order as rn, DeclaredInvariant as rt, Entity as s, ParameterOf as sn, OperatorMissingError as st, AnyEntity as t, OperatorTable as tn, BeforeRow as tt, EntityIdentity as u, Query as un, Row as ut, InputMember as v, dependenciesOf as vn, truthOver as vt, RelationInput as w, LawDescription as wn, OperatorContext as wt, Related as x, missingName as xn, ImplementedOperator as xt, NestedInput as y, isPredicate as yn, valueOfOperand as yt, BoundWrite as z, Dependencies as zt };
|
|
2228
|
+
//# sourceMappingURL=index-hu8IYlNc.d.mts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"index-hu8IYlNc.d.mts","names":["Arr","StoredOf","_$__expr_js0.Operator"],"sources":["../src/collation.ts","../src/law.ts","../src/expr.ts","../src/tested.ts","../src/operators.ts","../src/evaluate.ts","../src/invariant.ts","../src/text.ts","../src/readFilter.ts","../src/words.ts","../src/shape.ts","../src/write.ts","../src/index.ts"],"mappings":";;KAeY;;;WAEG;;;;WAEA;;;;WAEA;WAAyB;;cAW3B;EACX,QAA6C;EAC7C,WAAmD;EACnD,SAAM,mBAAoB;;EAQ1B,KAAE,WAAc,cAAY;;EAG5B,WAAQ,UAAa,aAAW,OAAO,OAAO;;;;;;;EAS9C,YAAS;;;KC5CN,cAAc,SAAS,cAAc,OAAO,MAAM,OAAO;;KAGlD;;;;;KAMA,MAAM,KAAK;;EAErB;aAAwB,QAAQ,OAAO,OAAO,OAAO;;;EAErD;aAAwB,QAAQ,OAAO,OAAO,OAAO;;;EAErD;aAAuB,QAAQ,OAAO,OAAO,OAAO;;;EAEpD;aACW,QAAQ,OAAO,OAAO,OAAO;aAC7B;aACA,MAAM;;;EAGjB;aACW,QAAQ,OAAO,OAAO,OAAO;aAC7B;aACA,MAAM;;;EAGjB;aACW,QAAQ,OAAO,OAAO,OAAO;aAC7B,OAAO;aACP;;;EAGX;aAAwB,QAAQ,OAAO,OAAO,OAAO;aAAe,MAAM;;;EAE1E;aACW,QAAQ,OAAO,OAAO,OAAO;aAC7B;aACA;;;EAGX;aAA+B,QAAQ,OAAO,OAAO,OAAO;;;;;;;;cAWjD,gBAAc,OAAA;;;;;KAKf,wBAAwB,eAAe;cAQtC;EACX;;aAzDgC,QAAA,OAAO,OAAO,OAAO;;EA0DrD;;aAxDgC,QAAA,OAAO,OAAO,OAAO;;EAyDrD;;aAvD+B,QAAA,OAAO,OAAO,OAAO;;EAwDpD;;aA5BuC,QAAA,OAAO,OAAO,OAAO;;;EA8B5D,WAAQ,gBAAiB,OAAQ,SAAgB;;EAGjD,YAAS,gBAAiB,OAAQ,SAAgB;;EAGlD,UAAU,WAAW,cAAc,OAAO,MAAM,YAAY,OAAO,KAAG,OAC7D,SAAS,IAAI,MAAI,sBAEvB;;EAEH,cAAc,WAAW,cAAc,OAAO,MAAM,YAAY,OAAO,KAAG,MAClE,SAAS,IAAI,SAClB;;EAEH,YAAS,wCAAyC,qBAAqB;;;;;;EAOvE,SAAM,KAAQ,KAAG,QAAU,OAAO,QAAM;EAGxC;;;eA1EmB,QAAA,OAAO,OAAO,OAAO;eACtB;eACD,MAAA;;;eAfe,QAAA,OAAO,OAAO,OAAO;;;eAErB,QAAA,OAAO,OAAO,OAAO;;;eAsBrB,QAAA,OAAO,OAAO,OAAO;eAAqB,MAAA;;;eApB3C,QAAA,OAAO,OAAO,OAAO;;;eAGjC,QAAA,OAAO,OAAO,OAAO;eACtB;eACD,MAAA;;;eAUE,QAAA,OAAO,OAAO,OAAO;eACtB,OAAA;eACG;;;eAMF,QAAA,OAAO,OAAO,OAAO;eAClB;eACD;;;eAGkB,QAAA,OAAO,OAAO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAnBzC,QAAA,OAAO,OAAO,OAAO;eACtB;eACD,MAAA;;;eAfe,QAAA,OAAO,OAAO,OAAO;;;eAErB,QAAA,OAAO,OAAO,OAAO;;;eAsBrB,QAAA,OAAO,OAAO,OAAO;eAAqB,MAAA;;;eApB3C,QAAA,OAAO,OAAO,OAAO;;;eAGjC,QAAA,OAAO,OAAO,OAAO;eACtB;eACD,MAAA;;;eAUE,QAAA,OAAO,OAAO,OAAO;eACtB,OAAA;eACG;;;eAMF,QAAA,OAAO,OAAO,OAAO;eAClB;eACD;;;eAGkB,QAAA,OAAO,OAAO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8D5D,iBAAc,KAAQ,mBAAiB;;EAMvC,WAAQ,KAAQ,QAAM;;;UCrGP,YAAY;WAClB;WACA,OAAO;;;;;;UAOD,UAAU;WAChB;WACA,OAAO;WACP;WACA,QAAQ,OAAO,MAAM;;;;;;WAMrB,WAAW,OAAO,OAAO;;;;;;;;UASnB,UAAU;WAChB;WACA;WACA,QAAQ,OAAO,MAAM;;;;;;;UAQf,SAAS;WACf;WACA,OAAO,UAAU;;;;;;;;UASX;WACN;WACA;WACA;WACA,aAAa,OAAO;;WAEpB,OAAO,cAAc,OAAO;WAC5B,QAAQ,OAAO;;;;;;WAMf,WAAW,OAAO,WAAW,MAAM,cAAc,gBAAgB;;;;;;WAMjE;;;;;;;WAOA;;WAEA,MAAM,cAAc;;;UAId;;WAEN,MAAM,UAAU;;;;;;WAMhB,WAAW,eAAe;;;cAIxB,aAAa;;;;;cAMb,cAAW,UAAc,oBAAkB,WAAa;;;;;;UAmBpD,SAAS;WACf;WACA,UAAU;WACV,MAAM,cAAc;WACpB,WAAW,OAAO,OAAO,KAAK;;WAE9B,WAAW,OAAO,OAAO;;;KAIxB,KAAK,KAAK,YAAY,KAAK,UAAU,KAAK,UAAU,KAAK,SAAS,KAAK,SAAS;;KAGhF,UAAU;;;;;;;;;KAUV,YACR,cACA,gBACA,oBACA,cACA,eACA,cACA,eACA,mBACA;;UAGa;WACN;WACA,MAAM;WACN,OAAO;;;;;;;UAQD;WACN;WACA,SAAS;WACT;;;;;;;UAQM;WACN;WACA,OAAO;WACP,QAAQ;;;;;;;;UASF;WACN;WACA,OAAO;WACP,OAAO;;;;;;;UAQD;WACN;WACA,UAAUA,MAAI,sBAAsB;;;UAI9B;WACN;WACA,UAAUA,MAAI,sBAAsB;;;;;;;UAQ9B;WACN;WACA,SAAS;;;KAIR;;;;;;UAOK;WACN;WACA,UAAU;WACV,MAAM;WACN,OAAO;WACP,WAAW,OAAO,OAAO;;;;;;;UAQnB;WACN;WACA,UAAU;WACV,MAAM,cAAc;WACpB,WAAW,OAAO,OAAO;;WAEzB,WAAW,OAAO,OAAO;;;;;;;;KASxB,aAAa,UAAU;;KAG9B,QAAQ,KAAK,4BAA4B,OAAO,cAAc,KAAK,KAAK;;;;;;;UAQ5D,MAAM;WACZ,WAAW;;;;;;;KAQV,QAAQ,KAClB,UAAU,kBAAkB,cAAc,OAAO,cAC7C,OACA,UAAU;WAAwB;YAEhC;WAAqB,iBAAiB;oBACpB,iBAEd,uBACE;;;;;KAQT,WACH,sBACA,qBACA,sCACiB,mBAEd,gBAAgB,kBAEf,2BAA2B,cAAc,QAAQ,OAAO,gCAAgC;;KAGzF;;UAGY,QAAQ;WACd,YAAY;;;KAIX,QAAQ,KAClB,UAAU,kCAAkC,KACxC,OAAO,OAAO,KAAK,KACnB,UAAU,sBAER,UAAU,WAAW,KACnB;;;;;;;;;;;;;;;;;;;;;KAuBE,cACR,4BAA4B,OAAO,aAAa,OAAO,uCACvD,eACA;cAmBE,UAAW,GAAC,OAAS,MAAI,YAAY;;cA0B9B,cAAW,mBAAqB,SAAS;;;;;;KA6C1C;;UAaK;;WAEN;WACA;;WAEA,OAAO;;;UAID;;WAEN,QAAQ,cAAc;;WAEtB,MAAM,cAAc;;WAEpB,QAAQ;;WAER,YAAY,cAAc;;WAE1B,WAAW,cAAc;;;;;;;UAQnB,0BAA0B;WAChC,WAAW,cAAc;WACzB,OAAO,cAAc;;;;;;;;KASpB,iBACR,4BAGE,OAAO,aAAa,OAAO,wBAAwB,+BAErD,eACA,sBACA,eACA,sBACA,KAAK,QACL,KAAK;;UA4KC,WAAW,aAAa;GAC/B,UAAU,WAAW,MAAM,IAAI;GAC/B,UAAU,WAAW,UAAU,WAAW,aAAa,cAAc,YACpE,OAAO,GACP,QAAQ,MACL,MAAM,OACR,OAAO,MAAM,QAAQ,KAAK,QAAQ,KAAK,QAAQ;MAC9C,UAAUA,MAAI,sBAAsB,aAAa;;;KAWlDC,WAAS,UAAU,OAAO,OAAO,OAAO,MAAM,QAAQ;;;;;KAM/C,WAAW,UAAU,OAAO,OACpC,4BAA4B,OAAO,aAAa,OAAO,WAAWA,WAAS,iBAC3E,KAAKA,WAAS,uBACGA,WAAS,KAAK,qBAC/BA,WAAS;;KAGD,YAAY,UAAU,OAAO,OACrC,KAAKA,WAAS,uBACGA,WAAS,KAAK;;KAG9B,OAAO,YAAY,OAAO,QAAQA,WAAS,0BAC5C,gBACA,SAASA,WAAS;;KAGjB,OAAO,YAAY,OAAO,QAAQA,WAAS,0BAC5C,YACA,KAAKA,WAAS;;;;;UAMD,SAAS,WAAW,cAAc,OAAO,MAAM,YAAY,OAAO;SAC1E,sBAAsB,WAAW,KAAK,WAAW,GAAG,WACtD,MAAM,IACR,OAAO,OAAO,MAAM,QAAQ;;;;;;SAMxB,sBAAsB,WAAW,KAAK,WAAW,GAAG,WACtD,UAAU,GAAG,eACf,OAAO,OAAO,MAAM,QAAQ;WACtB,YAAY;;;UAIN;;WAEN,WAAW;;cAyaT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCA,iBAAM,WAAW,cAAc,OAAO,MAAM,YAAY,OAAO,KAAG,YACjE;aAEC,OAAO;aACP,QAAQ;aACR;aACA;;aAEA,OAAO,cAAc;;aAGjB,eACJ,kBAAkB,WAAW,KAAK,YAAY,GAAG,WACjD,OAAO;aACH;aACA;;aAGA;aACA,QAAQ;aACR,YAAY;SAG1B,SAAS,IAAI;;;;;;;;;;;;;EAeK,cAAA,OAAA,cAAc,UAAU;EAelC,WAAA,UAAU,YAAY,SAAO,MAAQ,MAAI,UAAU,YAAY,YAAY;;;;;;;;EAW7E,cAAA,OAAA,cAAc,UAAU,YAAY,WAAS;aAEzC,YAAY,cAAc;aAC1B,WAAW;QAErB;;;;;;;EASK,QAAA,GAAC,aAAa,QAAU,OAAO,MAAM,gBAAc,UAAU;;;;;EAO9D,OAAA,qBAAqB,oBAAoB,UAAU,OAAO,YAAU,OAClE,YAAY,MAAM,KAAK,OAC7B,SAAS,OAAO,OAAO,KAAK,MAAM,MAAM;;EAInC,QAAA,qBAAqB,oBAAoB,UAAU,OAAO,YAAU,OACnE,YAAY,MAAM,KAAK,OAC7B,UAAU,OAAO,OAAO,KAAK,MAAM,MAAM;;;;;;;;;;;EAc1C,KAAA,UAAU,eAAe,YACzB,WAAW,UAAU,aACjB,4FACA,QAAQ,KAAK,KAAK,QAAQ,uBAAuB,QAAQ,KAAK,qBAAmB,MAE/E,GAAC,OAGA,MACN,cAAc,MAAM,QAAQ,KAAK,QAAQ;;;;;;EAQnC,SAAA,UAAU,cAAY,SAAW,MAAI,gBAAgB,MAAM,QAAQ;;EAIhE,YAAA,UAAU,cAAY,SAAW,MAAI,gBAAgB,MAAM,QAAQ;;;;;;;;;;;;;;;;;EAmBpE,WAAA,UAAU,aAAW,OACvB,GAAC,iBACS,sBAAsB,oBAAoB,6BAC1D,oBAAoB,MAAM,QAAQ;;;;;;;;;;;;;;EAyBhC,KAAA,UAAU,cAAY,OAClB,GAAC,OACD,cAAc,QAAQ,MAAM,KAAK,cAAc,QAAQ,SAC7D,cAAc,MAAM,QAAQ;;;;;;;;;;;;;;EAxvB9B,KAAA,UAAU,gBAAgB,UAAU,QAAQ,KAAK,KAAK,QAAQ,KAAG,MAC1D,GAAC,OACA,GAAC;aACY,YAAY;QAC/B,mBAAmB,MAAM,QAAQ,KAAK,QAAQ;;;;;;;;;;;;;;;;;;;;EAuxBF,KAAA,WAAW;;;;;;;;;;;EAYf,IAAA,WAAW;;;;;;;;EAShD,MAAA,UAAU,WAAS,SAAW,MAAI,eAAe,MAAM,QAAQ;;;;;;;;;;;;;;EAsBzD,YAAA,GAAG,UAAU,WAAS,OACzB,UAAU,IAAE,QACX,OAAO,UAAU,YAAY,QAAQ,MAC5C,YAAY,MAAM,QAAQ;;EAMhB,OAAA,MAAA;;;;;;;EAQe,iBAAA,WAAA,WAAS,QAAU,SAAS,6BAA2B;;;UA4EpE;WACN;WACA;WACA,MAAM;;;;;;;WAON;;;;;WAKA,WAAW,OAAO,OAAO;;;UAInB;WACN;;WAEA,YAAY;;;KA2DX,WAAW;WACZ,IAAI;WACJ;;;;;;;UAQM;WACN;WACA,MAAM,UAAU;WAChB,SAAS,SAAS,eAAe,qBAAqB;;;KAIrD,WAAW,YAAY;cAEtB;;EAEX,MAAM,UAAU,cAAY,MAAQ,GAAC,UAAY,gBAAc,YAAY,MAAM,QAAQ;;EAGzF,OAAO,UAAU,cAAY,MAAQ,GAAC,UAAY,gBAAc,YAAY,MAAM,QAAQ;;;;;;;;;;;EAa1F,SAAS,yBAAyB,4BAA4B,KAAK,KAAK,iBAAc,MAC9E,UAAU,WAAW,MAAI,SACtB,YACR,cAAc,MAAM,QAAQ,cAAc;;;;;;KAuBnC;WACG;;WACA;WAA+B;;;;;;;cAyMjC,oBAAc,OACf,cAAc,UAAU,YAAY,cAC7C;;;;;;;;;;;;UAgCc,MAAM,UAAU,mBAAmB,SAAS;WAClD;WACA,QAAQ;;;;;;;WAOR,OAAO,cAAc;;WAErB,SAAS,cAAc;;;KAItB,WAAW,MAAM;;;;;;;;cA4FhB;cA4FA;;EAEX,OAAO,UAAU,WAAS,QAAU,MAAI,MAAM;;;;;;;;;;;EAY9C,cACS,UAAU,cAAc,eAAU,YAAiB,OACzD,UAAU,WAAS,MACZ,MAAM,KAAK,WAAW,QAAQ,YAAY,8BAC/C,MAAM;;;;;;EAaX,gBACS,UAAU,cAAc,cAAS,OAAY,OACnD,UAAU,WAAS,MACZ,MAAM,KAAK,WAAW,QAAQ,YAAY,mCAC/C,MAAM;;;;;;;;EAeX,WAAQ,MACA,UAAQ,OACP,SAAS,6BACf,cAAc;;;;;;;;EAsBjB,YAAS,MACD,UAAQ,OACP,SAAS,0BAAwB;aACpB,YAAY;QAC/B;;;;;;EAiBH,YAAS,MAAS,aAAW;;;;;;EAQ7B,eAAY,MAAS,aAAW;;;;;;;;;;;;;;;;;;;;EAyBhC,cAAW,MACH,UAAQ,WACH,cAAc,YAAU,YACxB,kBACV;;;;;;;;;;;;;;;EAgBH,OAAI,MAAS;;cC3tEF,iBAAc,QAAY;;UCVtB;;WAEN,WAAW,OAAO,OAAO;;;UAInB;WACN,UAAU;WACV,MAAM,MAAM,wBAAwB,SAAS;;;;;;;;KAS5C,WAAW,KAAK;EAC1B;aACW;aACA,KAAK;aACL;aACA;aACA;;EAEX;aACW;aACA,KAAK;aACL;aACA,aAAa;;;cAGb;;;aANU;aACL,KAAA;aACM;aACE,aAAA;;;;;aAVH;aACL,KAAA;aACW;aACT;aACD;;;;;;;eAGI;eACL,KAAA;eACM;eACE,aAAA;;;eAVH;eACL,KAAA;eACW;eACT;eACD;;;;;;;;;;;;;;;;;;;eAGI;eACL,KAAA;eACM;eACE,aAAA;;;eAVH;eACL,KAAA;eACW;eACT;eACD;;;;;;;;;;;;;;;;;;;;aAGI;aACL,KAAA;aACM;aACE,aAAA;;;;aAVH;aACL,KAAA;aACW;aACT;aACD;;;;KAYP,iBAAiB,QAAQ;WAAqB;;;;;;;;cAW7C,qBAAmB,OAAA;;;;;;;;;;;;;;;;;KAapB,6BAA6B,oBAAoB;;UAG5C,4BAA4B;WAClC,UAAU,cAAc;;;UAiBlB,wBAAwB;WAC9B;WACA,MAAM,UAAU,uBAAuB,OAAO,OAAO;;;;;WAKrD,QAAQ,iBAAiB,OAAO,OAAO;;WAEvC;WACA,iBAAiB,cAAc;;WAE/B,UAAU,cAAc;;KAG9B,SAAS,UAAU,OAAO,OAAO,OAAO,MAAM,QAAQ;cAkF9C;;;;;;;;;;EAUC,YAAA,WAAW,cAAc,OAAO,MAAM,YAAY,OAAO,KAAG,UAC5D,SAAS,IAAI,MAAI,SAEtB,sBAAsB,WAAW,KAAK,YAAY,SAAS,GAAG,SAAQ,qBACtE,SAAS,SACb;;;;;EAWsB,yBAAA,WAAW,cAAc,OAAO,MAAM,YAAY,OAAO,KAAG,UACzE,SAAS,IAAI,MAAI,SAEtB,sBAAsB,WAAW,KAAK,SAAS,GAAG,QAAO,qBACzD,SAAS,gBACb;;EAQ0B,YAAA,iBAAA,cAAc,0BAAwB;;EAIrD,QAAA,MAAA,iBAAe,OAAS,oBAAkB;;;;;;EAoBhD,WAAA,MAAA,oBAAe,iBACD,cAAc,0BACjC;;;;;;;;EAwBkB,eAAA,MAAA,iBAAe,UAAY,cAAc,cAAY;;;;;EA0BvD,WAAA,QAAA,aAAW,OAAO,OAAO;;;;;;;;;;;;EActB,gBAAA,MAAA,oBAAkB,cAAc;;;;;;;;EAajC,WAAA;aAAW,YAAY;QAAuB;;;;;;EAQnD,UAAA,MAAA,oBAAkB;;;;;KC3SxB,MAAM,SAAS;cAEd,2BAA2B;EACtC,YAAY;;;;;;;cAWD,6BAA6B;WAC/B,UAAU;;WAEV;;EAET,YAAY,UAAU,oBAAoB,YAAW;;;;;;;cA4H1C,gBAAa,UACd,oBAAkB,QACpB,wBAAsB;WAEnB,WAAW,OAAO,OAAO;WACzB,WAAW;;;KA8BnB;;;;;;;;cAyBQ,iBAAc,MACnB,YAAU;WAEL,QAAQ;WACR,YAAY;;;KAyJb,iBAAiB;;;;;;;cAWhB,UAAO,MACZ,WAAS,OACR,KAAG,YACC,oBACV,OAAO,OAAO;;cAYJ,YAAS,MACd,WAAS,KACV,KAAG,QACD,KAAG,OACJ,KAAG,YACE,oBACV;;;;;;;;;;cA0IU,cAAW,OACf,cAAc,YAAU,MACzB,KAAG,OACF,KAAG,eACG;WAEF,QAAQ;WACR,YAAY;;;;;;;;cAeZ,WAAW,cAAc;;;;;;cAiBzB,kBAAe,MACpB,UAAQ,YACH;;;;;;;;;cAkBA,WAAQ,MACb,UAAQ,OACP,KAAG,MACJ,cAAc,MAAI;WACJ,YAAY;MAC/B,cAAc;;UAYA;WACN,SAAS,cAAc;WACvB,SAAS,cAAc;;;;;;;;;;;;;cAcrB,eAAY,MACjB,UAAQ,OACP,KAAG,MACJ,cAAc,MAAI;WACJ,YAAY;MAC/B;;UC5nBc;;WAEN;WACA,WAAW;;WAEX;;WAEA,MAAM;;WAEN,QAAQ;;WAER,OAAO;;;KAIN,UAAU,UAAU,yBACpB,WAAW,uBAAuB,UAC1C,OAAO,OAAO,KAAK,YAAY,iBAE/B,MAAM;;KAIE,SAAS,UAAU,yBACnB,WAAW,uBAAuB,SAC1C,OAAO,OAAO,KAAK,YAAY,iBAE/B,MAAM;;UAIO;WACN,OAAO;;WAEP,SAAS;;;KAUR;WACG;;WACA;WAA0B,UAAU,cAAc;;;;;;;WAMlD;WACA,QAAQ;WACR,WAAW;;;cAIb,cAAW,MAAU;;;;;;UAOjB,kBAAkB,UAAU;GAC1C,QAAQ,IAAI;WACJ;;cAOE,YAAa,UAAU,WAAS,YACjC,QACF;WACG,QAAQ,UAAU;WAClB,OAAO,SAAS;MACrB,YAAY,MAAM,YAAU;WAEvB;WACA,OAAO,oBAAoB;MAErC,kBAAkB;cAuDR,eAAY,QAAY,cAAY,cAAc;;cAIlD,eAAY,YACX,cAAc,YAAU,QAC5B,QAAM,YACH,oBACV;;;;;;;;cAyCU,QAAK,QACR,WAAS,QACT,QAAM,YACH,oBACV;;;;;;;;cASU,aAAU,OACd,YAAY,sBAAoB,OAChC,SAAS,0BAAwB,YAC7B,oBACV;;;;;;cA8BU,QAAS,UAAU,WAAS,QAC/B,GAAC;WACW,YAAY;MAC/B,UAAU,OAAO,OAAO,OAAO,KAAK;cC1Q1B;;;;;;;;;;;;;;;;;;;;;EAqBX,YAAUC,mBAAA,OAAA,OAAA,OAAA,SAAA,OAAA,OAAA,OAAA,UAAA,OAAA;;cCZC;;EAEX,KAAE,SAAY,0BAAwB;;EAGtC,UAAO,UAAa,aAAW;;;UClBhB;WACN,OAAO,OAAO;WACd,aAAa,OAAO;;cAMlB;;;;;;;;EAQX,KAAE,QAAW,OAAO,QAAM;;cCjBtB,YAAS,KAAS,UAAU;cAG5B,SAAM,KAAS,UAAU;;cAkBlB;;;;;;;EAQI,UAAA,KAAA,UAAU,QAAM,cAAc,UAAU;;;;;;;;EAWlC,gBAAA,KAAA,UAAU;;KCA5B,WAAW,4BAA4B,OAAO;KAC9C,cAAc,+BAA+B;;UAGjC;WACN;WACA,OAAO;;;;;;;UAQD,uBAAuB;WAC7B;;;;;;;UAQM;WACN,OAAO;WACP,MAAM;;;;;;;;;KAUL,cAAc,KAAK;EAC7B;aAAkB;;EAClB;aAAkB;;EAClB;aACW;aACA,MAAM,cAAc;aACpB,WAAW;;;cAGX;;;aALU;aACJ,MAAA,cAAc;aACT,WAAA;;;;;aALC;;;;;aACE;;;;;;;eAEJ;eACJ,MAAA,cAAc;eACT,WAAA;;;eALC;;;eACE;;;;;;;;;;;;;;;;;eAEJ;eACJ,MAAA,cAAc;eACT,WAAA;;;eALC;;;eACE;;;;;;;;;;;;;;;;;;aAEJ;aACJ,MAAA,cAAc;aACT,WAAA;;;;aALC;;;;aACE;;;;UAUV;WACN;WACA,UAAU;;;;;;UAOJ,MAAM,UAAU,WAAW,eAAe,OAAO,OAAO;WAC9D;WACA,OAAO,YAAY,GAAG;;WAEtB,IAAI;aAAsB,WAAW;;;;;;WAKrC,SAAS;aAAsB,WAAW;;;;;;;WAM1C,MAAM,OAAO,OAAO;;WAEpB,MAAM,cAAc;;;;;WAKpB,YAAY,cAAc;;WAE1B,aAAa,cAAc;;WAE3B,OAAO,cAAc;;KAGpB,WAAW,MAAM;;KAGjB,iBAAiB,UAAU,WAAW,eAAe,OAAO,OAAO,UAAU,MACvF,GACA;WACa,MAAM,OAAO,KAAK;;UAEvB,WAAW,eAAe,OAAO,OAAO;WACvC,UAAU;WACV,eAAe;;;KAIrB,WAAW,aACb,WAAW,kBAAkB,OAAO,WAAW,OAAO,MACnD,OAAO,OAAO,KAAK,OAAO,qBACxB,2BAGA;;KAGI,gBAAgB,UAAU,WAAW,eAAe,OAAO,OAAO,sBAE1E,KAAK,cAAc,WAAW,cAAc,YAAY,oBACtD,WAAW;;;;;;KAQL,kBAAkB,UAAU,WAAW,eAAe,OAAO,OAAO,sBACpE,WAAW,yBAAyB;WACnC,KAAK,UAAU;WACf,mBACG,WAAW,kBAAkB,UAAU,OAAO,OAAO,KAAK,OAAO;MAEzE;;KAIH,cACH,UAAU,WACV,eAAe,OAAO,OAAO,UAC3B,WAAW;WACJ,YAAY,gBAAgB,GAAG;WAC/B,UAAU,kBAAkB,GAAG;;;UAIhC;GACP,UAAU,WAAW,eAAe,OAAO,OAAO,QACjD,OAAO,YAAY,GAAG,cACtB,SAAS,cAAc,GAAG;aAAqB,MAAM,eAAe,GAAG;MACtE,iBAAiB,GAAG;GAEtB,UAAU,WAAW,eAAe,OAAO,OAAO,QACjD,OAAO,YAAY,GAAG,cACtB,SAAS,cAAc,GAAG;aAAqB;MAC9C,MAAM,GAAG;;;UAIJ;GACP,UAAU,WAAW,eAAe,OAAO,OAAO,QACjD,OAAO,YAAY,GAAG,cACtB,SAAS,WAAW;aAAqB,MAAM,eAAe,GAAG;MAChE,iBAAiB,GAAG;GACtB,UAAU,WAAW,eAAe,OAAO,OAAO,QACjD,OAAO,YAAY,GAAG,cACtB,SAAS,WAAW;aAAqB;MACxC,MAAM,GAAG;;;;;;;KAqBF,eAAe,UAAU,WAAW,eAAe,OAAO,OAAO,WAAW;WAC7E,mBACG,WAAW,kBAAkB,UAAU,OAAO,OAAO,KAAK,OAAO;MAEzE,YAAY,MAAM;;UAGP;WACN;WACA;WACA,QAAQ,SAAS;;;;;;WAMjB,OAAO,SAAS,eAAe,OAAO,OAAO;;WAE7C,YAAY,SAAS;;WAErB,aAAa,SAAS,eAAe;;cAkWnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCF,SAAA,UAAU,WAAW,eAAe,OAAO,OAAO,QAAM,OACxD,YAAY,GAAG,cAAY;aACd,UAAU;QAC7B,MAAM,GAAG;;;;;;;;;;;;;EAiBD,WAAA,eAAe,OAAO,OAAO,QAAM,OACrC,MAAM,WAAW,SAAO,OACxB,OAAO,OAAO,KAAK,YACzB,OAAO;aAAkB;aAAwB;;;EAOpC,SAAA,OAAA,aAAW,cAAc,WAAW;;;;;;;EAarC,QAAA,OAAA,aAAW,cAAc;;;;;;;EAoBjC,OAAA,eAAe,OAAO,OAAO,QAAM,OACjC,MAAM,WAAW,SAAO,OACxB,OAAO,OAAO,KAAK,SAAO,OAC1B,0BACN;;;;;EAiDiB,aAAA,OAAA,KAAK,8CAA4C;;;;;;;;;;EAsB9D,QAAA,KAAA,SAAS,0BAAwB,OAC/B,KAAK,sDAAoD;aAC5C,WAAW;;aAEtB,KAAK,SAAS;aACd,SAAS;;;cC9uBT;KACD,sBAAsB;;;;;UAMjB,eAAe;WACrB,MAAM;;WAEN;;;UAIM,YAAY,qBAAqB,oBAAoB,UAAU,OAAO;WAC5E;WACA,OAAO,eAAe;WACtB,KAAK;WACL,QAAQ;WACR,UAAU;;KAGT;;UAGK,aACf,eAAe,WACf,UAAU,aACV;WAES,QAAQ;WACR,aAAa;WACb,UAAU;;;;;;;UAQJ,eACf,qBACA,oBACA,eAAe,WACf,UAAU,aACV;WAES;WACA,OAAO,eAAe;WACtB,KAAK;;WAEL,cAAc;WACd,aAAa;WACb,UAAU;WACV,UAAU;;;UAIJ,YAAY,UAAU,OAAO;WACnC,QAAQ;;;;;;UAOF,cACf,qBACA,oBACA,UAAU,OAAO;WAER;WACA,OAAO,eAAe;WACtB,KAAK;WACL,QAAQ;WACR,UAAU;;KAGT,eACR,4BAA4B,OAAO,cACnC,+BAA+B,WAAW,wBAC1C,8BAA8B,OAAO;KAE7B,gBAAgB,SAAS,eAAe,aAAa,WAAW;KAChE,eAAe,SAAS,eAAe,YAAY,OAAO;KAEjE,SAAS,qBAAqB,eAAe,OAAO,OAAO,sBACpD,WAAW,kBAAkB,YAAY,MAAM,GAAG,OAAO;KAEhE,YAAY,qBAAqB,kBAAkB,6BAC5C,WAAW,qBAAqB,UAAU,WAAW,mBACvD,cACA,SACA,YAEJ,eAAe,MAAM,GAAG,QAAQ,GAAG;KAGpC,UAAU,qBAAqB,gBAAgB,4BACxC,WAAW,mBAAmB,cAAc,MAAM,GAAG,QAAQ;UAGxD,OACf,qBACA,eAAe,OAAO,OAAO,QAC7B,kBAAkB,oBAClB,gBAAgB,2BAER,SAAS;YACP,eAAe;WAChB,UAAU,eAAe;WACzB,MAAM;;WAEN,QAAQ,OAAO,OAAO;WACtB,QAAQ,SAAS,MAAM;WACvB,WAAW,YAAY,MAAM;WAC7B,SAAS,UAAU,MAAM;;WAEzB,SAAS,SAAS,MAAM,UAAU,YAAY,MAAM,aAAa,UAAU,MAAM;WACjF,UAAU;;KAGT,YAAY;;KAGnB,KAAK,UAAU,WAAW,aAAa,YAAY;WAEzC,sBAAsB,YAAY;;KAE5C,YAAY,GAAG,YAAY,gBAC9B,UAAU,aAAa,YAAY,cAAc,SAAS,KACtD,OAAO,MAAM,QAAQ,GAAG,IAAI;KAGtB,WAAW,SAAS,eAAe;KACnC,YAAY,WAAW,wBAAwB,WAAW,MAAM;;KAGhE,UAAU,WAAW,UAAU,eAAe,gBACvD,WAAW,MAAM,GAAG,YAAY,yBAAyB,gBAAgB,GAAG,cACzE,mBAEE;KAEI,aAAa,WAAW,UAAU,WAAW,YAAY,KAAK,gBAAgB,kBAC9E,WAAW,GAAG,KAAK,GAAG,GAAG,WAAW,mBAAmB,cAAc,SAAS,YACpF,aAAa,QAAQ,IAAI,IAAI,UAAU,IAAI,UAAU,GAAG;;;;;;KASlD,QAAQ,WAAW,UAAU,WAAW,YAAY,KAAK,gBAAgB,MACnF,GAAG,WAAW,aAAa,YAAY,cAAc,SAAS,KAC1D,OAAO,MAAM,QAAQ,IAAI,aAAa,IAAI,IAAI,IAAI;;KAInD,eAAe,WAAW,UAAU,kBAC7B,WAAW,KAAK,gBAAgB,iBAE1B,WAAW,GAAG,KAAK,gBAAgB,GAAG,oBACxC,sCAAsC,GAAG,eAC7C,GAAG,GAAG;cAKL;KACD,yBAAyB;;;;;;;KAQzB,WAAW,KAAK;WACjB;aAAmB;eAAe,cAAc;;;IAEvD,UAAU,OAAO,cACd,8BACC,IACA,OAAO,SACT,OAAO,SACT,OAAO;;KAGC,KAAK,KAAK,WAAW;;;;;UAMhB,UAAU,8BAA8B;WAC9C,QAAQ;WACR,IAAI;;KAGV,UAAU,eAAe,aAAa,OAAO;WACvC,QAAQ,OAAO,QAAQ;WACvB,IAAI,WAAW;;;;;;UAOT,UACf,qBACA,SACA,UAAU,OAAO,YACjB;YAEU,kBAAkB;;WAEnB,KAAK;WACL,QAAQ,OAAO;;WAEf,SAAS;WACT,QAAQ;;KAGd,aAAa,gCAAgC,UAAU;;KAGhD,SAAS,UAAU,2BAA2B,OAAO,eAAe;;;;;;;UAQ/D;WACN;WACA;WACA;WACA;;cAGE;KACD,6BAA6B;;UAGxB,cAAc,qBAAqB,UAAU,OAAO;YACzD,sBAAsB;WACvB,WAAW,UAAU,WAAW;WAChC,QAAQ;;KAGd,WAAW,UAAU,OAAO,cAAc,OAAO;WAC3C,OAAO,OAAO,OAAO;WACrB,SAAS,OAAO;WAChB,aAAa,OAAO;;KAG1B,cAAc,UAAU,WAAW,oBAC5B,WAAW,OAAO,gBAAgB,iBACxC,eAAe,WAAW,+BAA+B,cAAc,iBAGjE,aAAa,mBAEZ,mBAAmB,cAAc,wCAExC,gBAAgB,0BAEV,kCAAkC;KAGzC,cACH,UAAU,aACV,0BACA,UAAU,OAAO,cACf,mBAAmB,OAAO,OAAO,KAAK,wBAAwB,OAAO,OAAO,KAAK;KAEhF,eAAe,QAAQ,YAAY,eACpC,4BAA4B,KAC5B,8BAA8B,KAC9B,IACA,eAAe,+BAA+B,cAAc,SAAS,YACnE,iBAAiB,yBAAyB,KACxC,WAAW,KACX,cACE,GACA,UACA,iBAAiB,0BAA0B,KAAK,IAAI,UAAU;KAInE,gBAAgB,UAAU,WAAW,QAAQ,OAAO,mBAC7C,WAAW,aAAa,eAAe,eAAe,aAAa,IAAI,KAAK;;UAmBvE,cAAc,UAAU;WAC9B;WACA,UAAU;;;;;;;UAQJ,YACf,UAAU,yCACV,UAAU;WAED;WACA,UAAU;WACV,OAAO;;;UAID;WACN;;;KAIC,cACR,4BAA4B,OAAO,cACnC,cAAc,+BAA+B,WAAW,yBACxD,YACE,+BAA+B,WAAW,uBAC1C,YAAY,wBAEd;;KAGC,YAAY,KACf,UAAU,+BAA+B,cAAc,SAAS,YAC5D,mBACE,cAAc,KAAK,WACnB,wBACE,KAAK,iBACL,KAAK;;KAIV,aAAa,GAAG,KACnB,UAAU,uBAAuB,eAC7B,UAAU,6CACR,cAAc,OAAO,OAAO,KAAK,WACjC,OAAO,OAAO,KAAK;KAGtB,QAAQ,KAAK,QAAQ;;KAErB,KAAK,KACR,UAAU,OAAO,WAAW,KAAK,QAAQ,KAAK,UAAU,OAAO,oBAAoB,QAAQ;;;;;;;;KAQxF,KAAK,OAAO,UAAU,QAAQ,iBAAiB,iBAE/C,KAAK,iBAAiB;KAItB,WAAW,qBAAqB,OAAO,KAAK,UAAU,WACvD,IACA,UACM,kBAAkB,mBAClB,cAAc,qBAAqB,8BACnC,YAAY,qBAAqB,oCACpC,gBAAgB,QACf,UAAU,4BAA4B,KACpC,KAAK,OAAO,OAAO,OAAO,KAAK,mBAC7B,gDAEF,UAAU,oBAAoB,KAC5B,QAAQ,eAAe,YAAY,KACjC,6DAEF,UAAU,kBAAkB,SAAS,KACnC,UAAU,+BAA+B,oBACvC,UAAU,kBAAkB,iBACzB,qBAAqB,kBACpB,QAAQ,eAAe,aAAa,GAAG,KACrC,uFAEwB,mBAAmB,qEAI/B;;KAI7B,WAAW,UAAU,WAAW,eAAe,OAAO,OAAO,aAC/D,WAAW,SAAS,gBAAgB,cACjC,KAAK,OAAO,OAAO,KAAK,OAAO,KAAK,OAAO,OAAO,KAAK,YAAY,8BACjE,2BAGA;;;;;;KAOH,MAAM,UAAU,WAAW,KAAK,mBACjC,gBAAgB,cACd,YAAY,KACZ,gBAAgB,iBACd,cAAc,eAAe,UACzB,oCAAoC,cAC5C;KAEC,aAAa,UAAU,WAAW,eAAe,OAAO,OAAO,QAAQ,uBAChE,KAAK,cAAc,QAAQ,WAAW,GAAG,oCAEzC,WAAW,UAAU,gBAAgB,SAC3C,MAAM,GAAG,QAAQ,mBAAkB,UACjC,wBACE,SACA,WAAW,WAAW,OAAO,OAAO,KAAK,OAAO,KAAK,gBAAgB,SACnE,QAAQ,KACR,WAAW,WAAW,OAAO,OAAO,KAAK,OAAO,KAAK,sBAEvD;KAGL,aAAa,UAAU,WAAW,eAAe,OAAO,OAAO,QAAQ,uBAChE,WAAW,SAAS,gBAAgB,UAC1C,MAAM,GAAG,QAAQ,MACjB,gBAAgB,cACd,YAAY;;;;;;UASH,YAAY,UAAU,WAAW,eAAe,OAAO,OAAO,QAAQ;WAC5E,QAAQ;WACR,QAAQ,OAAO,OAAO;WACtB,SAAS;;;KAIR,WAAW,KACrB,UAAU,uBAAuB,YAC7B,MACA,UACM,cAAc,0BAA0B,uBACxC,YAAY,0BAA0B,4BAC1C;;KAII,UAAU,KACpB,UAAU,iBAAiB,kBAAkB,eAAe,YACxD,UAAU,YAAY,YAAY,UAAU,gBAAgB,IAAI,YAAY;;KAItE,YAAY,uBACZ,WAAW,WAAW,WAAW,QAAQ,MAAM,UAAU,QAAQ;cAgCvE,eAAY,MAAU,WAAS,OAAS;cAOxC,WAAQ,mBAAqB,SAAS;cA0B/B;;EAEF,eAAM,qBAAqB,eAAe,OAAO,OAAO,QAAM,MAC/D,MAAI,QACF,OAAO,OAAO,YACrB,OAAO,MAAM;;;;;;EAyBP,eAAM,WAAW,gBAAgB,WAAW,YAAY,KAAG,UACxD,IAAE,WACD,KAAK,eAAe,IAAI,oBACtB,WAAW,KAAK,QAAQ,IAAI,IAAI;;;;;;;EAmDtC,SAAA,UAAU,iBAAiB,MAAI,QAC9B,GAAC,MACH,OAAO,cAAc,GAAG,UAC7B,UAAU,WAAW,MAAM,gBAAgB,GAAG,OAAO,KAAK;;;;;;EAuDtD,OAAA,qBAAqB,UAAU,OAAO,YAAU,WAC1C,UAAU,WAAW,IAAE,QAC1B,eACP,cAAc,MAAM;;EAuBpB,gBAAM,YAAY,cAAY,OAAS,SACvC,UAAU,WAAS,QAAU,IAAI,KAAK,GAAG,SAAO,YAAY,GAAG;;EAgBrD,WAAA,UAAA,cACV,UAAU,WAAS,QAAU,MAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CjC,kBAAA,UAAU,WAAS,sBAAwB,WAAW,gBAAgB,iBAAU,QACxE,MAAI;;;;;;;EA2Bb,QAAA,UAAU,WACV,eAAe,OAAO,OAAO,cAEvB,cAAY,QAEV,GAAC,QACD,OAAO,OAAO,YAAO,eACX,aAAa,GAAG,QAAQ,0BACrC,UAAU,UAAU,aAAa,GAAG,QAAQ,aAC5C,SAAS,UAAU,aAAa,GAAG,QAAQ,cAC/C,YAAY,GAAG,QAAQ,aAAa,GAAG,QAAQ;;;;;;;;EAiEzC,SAAA,UAAU,iBAAiB,aAAa,oBAAoB,uBAAqB,QAChF,MAAC,MACA,qBACI,KAAK,eAAe,YAAY;;;;;EAkBnC,YAAA,UAAU,WAAW,eAAe,OAAO,OAAO,QAAQ,SAAO,OACpE,YAAY,GAAG,QAAQ,aAC7B,UACD,WACA,YAAY,UACZ,gBAAgB,GAAG,YAAY,WAC/B,KAAK;;;;;;;EAwBK,YAAA,UAAU,WAAW,eAAe,OAAO,OAAO,QAAQ,SAAO,OACpE,YAAY,GAAG,QAAQ,UAAQ,OAC/B,SAAS,6BACf,QAAQ,OAAO,OAAO,KAAK;;;;;iBA2CvB,IAAI,eAAe,WAAW,QAAQ,SAAS,aAAa;iBAC5D,IAAI,eAAe,iBAAiB,0BAC3C,QAAQ,QACR;WAAoB,UAAU;IAC7B,aAAa,eAAe;;cASlB;;;EAIH,QAAA,UAAU,yCAAuC,UAAY,MAAI,cAAc;;;;;EAO9E,SAAA,UAAU,yCAAyC,UAAU,4BAA0B,UACpF,GAAC,OACJ,MACN,YAAY,GAAG;EAEX,OAAA,eAAe,WAAS,QAAU,WAAS,aAAa;;cAOpD;EACX,OAAO,UAAU,OAAO,YAAU,QAAU,MAAI,YAAY"}
|
package/dist/index.d.mts
CHANGED
|
@@ -1,2 +1,2 @@
|
|
|
1
|
-
import { $ as
|
|
2
|
-
export { type AfterRow, AndPredicate, AnyEntity, AnyExpr, AnyQuery, type AnyWrite, ArgumentOf, type BeforeRow, type BoundWrite, CallExpr, CallOptions, Cardinality, type Change, ChosenOrder, ChosenSort, Collation, CompareOperator, ComparePredicate, type ConditionedWrite, ContainsPredicate, type DeclaredInvariant, Dependencies, Derived, DerivedSpec, DerivedSpecs, Entities, Entity, EntityDerived, EntityField, EntityIdentity, EntityInput, EntityMember, EntityRef, EntityRelation, EntityTypeId, EqPredicate, Evidence, Expr, FieldDependency, FieldExpr, IdOf, IdSchemaOf, ImplementedOperator, InPredicate, InputExpr, InputMember, Invalid, type Invariant, type Judgement, Law, LawDescription, LiteralExpr, MemoryImplementation, MemoryOperators, NestedInput, NextExpr, NotPredicate, NullPredicate, Operandish, Operation, Operator, OperatorContext, OperatorDescriptor, OperatorMissingError, OperatorTable, Operators, OrPredicate, Order, OrderTerm, OrderedOperand, Ordering, PageWindow, ParameterOf, Placement, Predicate, PredicateTruth, Query, QueryDependencies, QueryEvaluateError, ReadFilter, Reads, ReadsOf, Related, RelatedSpecs, Relation, RelationInput, RelationMap, RelationSpec, RelationSpecs, Row, SchemaShape, SchemaWords, Selected, Selection, SelectionPage, SelectionPageTypeId, SelectionTypeId, Side, TargetKey, TermOptions, TestPredicate, TestedEvidence, Text, TextOperand, Unmapped, ValueOf, Words, Write, type WriteCondition, type WriteIncrement, type WriteLink, type WriteSet, WrittenAs, WrittenKey, WrittenSpec, assertSupported, compareRows, decided, dependenciesOf, evaluate, isPredicate, maxQueryNodes, noOperators, supported, truthOver, valueOfOperand };
|
|
1
|
+
import { $ as Text, $t as Operator, A as SelectionPage, At as AnyQuery, B as Computation, Bt as EqPredicate, C as Relation, Cn as Law, Ct as MemoryOperators, D as RelationSpecs, Dt as TestedEvidence, E as RelationSpec, En as Collation, Et as Operators, F as WrittenAs, Ft as ChosenSort, G as WriteCondition, Gt as InputExpr, H as Write, Ht as FieldDependency, I as WrittenKey, It as CompareOperator, J as WriteSet, Jt as NextExpr, K as WriteIncrement, Kt as Invalid, L as WrittenSpec, Lt as ComparePredicate, M as SelectionTypeId, Mt as CallExpr, N as TargetKey, Nt as CallOptions, O as Selected, Ot as AndPredicate, P as Unmapped, Pt as ChosenOrder, Q as ReadFilter, Qt as Operation, R as AnyWrite, Rt as ContainsPredicate, S as RelatedSpecs, Sn as noOperators, St as MemoryImplementation, T as RelationMap, Tn as Side, Tt as OperatorDescription, U as WriteAssignment, Ut as FieldExpr, V as ConditionedWrite, Vt as Expr, W as WriteComputations, Wt as InPredicate, X as SchemaWords, Xt as NullPredicate, Y as SchemaShape, Yt as NotPredicate, Z as Words, Zt as Operandish, _ as IdSchemaOf, _n as ValueOf, _t as supported, a as DerivedSpecs, an as OrderedOperand, at as Judgement, b as PageWindow, bn as maxQueryNodes, bt as Evidence, c as EntityDerived, cn as Placement, ct as PredicateTruth, d as EntityInput, dn as QueryDependencies, dt as applyOperator, en as OperatorDescriptor, et as AfterRow, f as EntityMember, fn as Reads, ft as assertSupported, g as IdOf, gn as TextOperand, gt as evaluateEach, h as EntityTypeId, hn as TestPredicate, ht as evaluate, i as DerivedSpec, in as OrderTerm, it as Invariant, j as SelectionPageTypeId, jt as ArgumentOf, k as Selection, kt as AnyExpr, l as EntityField, ln as Predicate, lt as QueryEvaluateError, m as EntityRelation, mn as TermOptions, mt as decided, n as Cardinality, nn as OrPredicate, nt as Change, o as Entities, on as Ordering, ot as Evaluated, p as EntityRef, pn as ReadsOf, pt as compareRows, q as WriteLink, qt as LiteralExpr, r as Derived, rn as Order, rt as DeclaredInvariant, s as Entity, sn as ParameterOf, st as OperatorMissingError, t as AnyEntity, tn as OperatorTable, tt as BeforeRow, u as EntityIdentity, un as Query, ut as Row, v as InputMember, vn as dependenciesOf, vt as truthOver, w as RelationInput, wn as LawDescription, wt as OperatorContext, x as Related, xn as missingName, xt as ImplementedOperator, y as NestedInput, yn as isPredicate, yt as valueOfOperand, z as BoundWrite, zt as Dependencies } from "./index-hu8IYlNc.mjs";
|
|
2
|
+
export { type AfterRow, AndPredicate, AnyEntity, AnyExpr, AnyQuery, type AnyWrite, ArgumentOf, type BeforeRow, type BoundWrite, CallExpr, CallOptions, Cardinality, type Change, ChosenOrder, ChosenSort, Collation, CompareOperator, ComparePredicate, Computation, type ConditionedWrite, ContainsPredicate, type DeclaredInvariant, Dependencies, Derived, DerivedSpec, DerivedSpecs, Entities, Entity, EntityDerived, EntityField, EntityIdentity, EntityInput, EntityMember, EntityRef, EntityRelation, EntityTypeId, EqPredicate, Evaluated, Evidence, Expr, FieldDependency, FieldExpr, IdOf, IdSchemaOf, ImplementedOperator, InPredicate, InputExpr, InputMember, Invalid, type Invariant, type Judgement, Law, LawDescription, LiteralExpr, MemoryImplementation, MemoryOperators, NestedInput, NextExpr, NotPredicate, NullPredicate, Operandish, Operation, Operator, OperatorContext, OperatorDescription, OperatorDescriptor, OperatorMissingError, OperatorTable, Operators, OrPredicate, Order, OrderTerm, OrderedOperand, Ordering, PageWindow, ParameterOf, Placement, Predicate, PredicateTruth, Query, QueryDependencies, QueryEvaluateError, ReadFilter, Reads, ReadsOf, Related, RelatedSpecs, Relation, RelationInput, RelationMap, RelationSpec, RelationSpecs, Row, SchemaShape, SchemaWords, Selected, Selection, SelectionPage, SelectionPageTypeId, SelectionTypeId, Side, TargetKey, TermOptions, TestPredicate, TestedEvidence, Text, TextOperand, Unmapped, ValueOf, Words, Write, type WriteAssignment, type WriteComputations, type WriteCondition, type WriteIncrement, type WriteLink, type WriteSet, WrittenAs, WrittenKey, WrittenSpec, applyOperator, assertSupported, compareRows, decided, dependenciesOf, evaluate, evaluateEach, isPredicate, maxQueryNodes, missingName, noOperators, supported, truthOver, valueOfOperand };
|
package/dist/index.mjs
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
export {
|
|
1
|
+
export { z as Collation, s as Computation, t as Derived, n as Entity, r as EntityTypeId, S as Evidence, O as Expr, I as Law, L as LawDescription, C as OperatorDescription, d as OperatorMissingError, w as Operators, k as Order, A as Query, f as QueryEvaluateError, u as ReadFilter, i as Relation, R as SchemaShape, a as SelectionPageTypeId, o as SelectionTypeId, T as Text, l as Words, c as Write, p as applyOperator, m as assertSupported, h as compareRows, g as decided, j as dependenciesOf, _ as evaluate, v as evaluateEach, M as isPredicate, N as maxQueryNodes, P as missingName, F as noOperators, y as supported, b as truthOver, x as valueOfOperand } from "./src-DBAilaDV.mjs";
|