foldkit-remote 0.20.0 → 0.22.0

package/dist/matching.js

@@ -0,0 +1,172 @@
+import { holderOf } from "./held.js";
+import { Option, Schema } from "effect";
+import { Held, Judge, Query, QueryEvaluateError, evaluateEach } from "foldkit-entity";
+// src/matching.ts
+/**
+* Running a query body against the rows the client already holds.
+*
+* local-execution-DESIGN phase 3. A connection's rows are edges the server
+* delivered, and until now nothing on the client ever evaluated a body — which
+* is why an optimistic insert has to guess between `prepend` and `append`, and
+* why `LivePolicy` exists to be told in advance what to do with a row nobody
+* could judge.
+*
+* This judges them. It is pure, it performs no I/O, and it reuses the reference
+* interpreter in `foldkit-entity` rather than reimplementing the semantics —
+* so a body means here exactly what it means on the server, checked by the same
+* conformance suite.
+*
+* **It answers "which of the rows I hold match", never "which rows match".**
+* Those are different questions and the difference is not recoverable from the
+* result, so it is in the shape: `matched` is what satisfied the body, and
+* `skipped` is what was held but could not be judged. A caller that knows it
+* holds the whole population — a connection terminal at both ends — is the one
+* that can turn this into a complete answer. Nothing here can.
+*
+* **It is not authorization.** On the server a compiled `where` is conjoined
+* with the binding's `visible` rule. There is no `visible` here, and this is
+* safe only because the client holds only rows the server already released to
+* it. A local filter is not an access decision.
+*/
+/**
+* The fields of the body's own Entity that a row must have for the body to be
+* decidable about it — its predicates and its ordering terms.
+*
+* `id` is never among them: it is the key, so it is known for every row in the
+* store whether or not anything fetched it as a field.
+*/
+const decidableOn = (body) => Query.dependencies(body).fields.filter((field) => field.entity === body.entity.name && field.key !== "id").map((field) => field.key);
+/**
+* The rows of `descriptor`'s Entity that the store holds and the body matches.
+*
+* The input is given **decoded**, as an application writes it, and encoded here
+* through the descriptor's own `Input` codec. That is deliberate and is the
+* whole reason this takes a descriptor rather than a bare body: a store holds
+* wire values, so an input has to be in that space to be compared against them,
+* and handing an interpreter a decoded value is a mistake **no runtime error
+* catches** — the reference interpreter answers "no rows", which reads exactly
+* like a correct answer. Doing it here means a caller cannot get it wrong.
+*
+* Literals in the body are deliberately *not* encoded. A literal written in
+* domain terms is already broken against the server, which binds it to a column
+* the same way; accepting it here would make the client quietly more permissive
+* than the thing it has to agree with.
+*/
+const matching = (store, descriptor, input, options = {}) => matchingEncoded(store, descriptor, Schema.encodeSync(descriptor.Input)(input), options);
+/**
+* As `matching`, for the callers in this module that already hold the input
+* **encoded**. Not exported: `matching` is the way in, and it cannot be given
+* the wrong space.
+*/
+const matchingEncoded = (store, descriptor, encoded, options = {}) => {
+	const body = descriptor.body;
+	if (body === void 0) throw new Error(`[foldkit-remote] Remote.matching: query "${descriptor.name}" carries no body, so there is nothing to judge rows against. Declare it with Query.define.`);
+	const prefix = `${body.entity.name}:`;
+	const needed = decidableOn(body);
+	const candidates = options.among ?? Object.keys(store).filter((key) => key.startsWith(prefix));
+	const rows = [];
+	const skipped = [];
+	for (const key of candidates) {
+		if (!key.startsWith(prefix)) continue;
+		const entry = store[key];
+		if (entry === void 0) {
+			skipped.push(key);
+			continue;
+		}
+		if (entry.tombstone) continue;
+		if (needed.some((field) => !entry.present.has(field))) {
+			skipped.push(key);
+			continue;
+		}
+		const values = Held.fromRefs(body, entry.values);
+		rows.push("id" in values ? {
+			...values,
+			__key: key
+		} : {
+			...values,
+			id: key.slice(prefix.length),
+			__key: key
+		});
+	}
+	const reaching = reachesOtherRows(body);
+	const holder = reaching ? holderOf(store) : void 0;
+	const admitted = holder === void 0 ? rows : rows.filter((row) => Option.match(judgedOver(holder, body, encoded, row.__key, prefix, options), {
+		onSome: (matched) => matched,
+		onNone: () => {
+			skipped.push(row.__key);
+			return false;
+		}
+	}));
+	const judged = evaluateEach(reaching ? orderOnly(body) : body, encoded, admitted, {
+		operators: options.operators,
+		context: options.context
+	});
+	const keyOf = (row) => row.__key;
+	return {
+		matched: judged.matched.map(keyOf),
+		skipped: [...skipped, ...judged.refused.map(keyOf)]
+	};
+};
+const reachingBodies = /* @__PURE__ */ new WeakMap();
+/** Whether a body's predicates read other rows: a path, an exists, a path from the viewer. */
+const reachesOtherRows = (body) => {
+	const known = reachingBodies.get(body);
+	if (known !== void 0) return known;
+	const reaching = Query.dependencies(body).reaches.length > 0;
+	reachingBodies.set(body, reaching);
+	return reaching;
+};
+const ordersOf = /* @__PURE__ */ new WeakMap();
+/** `body`'s order without its predicates, to put rows it admitted in order. */
+const orderOnly = (body) => {
+	const known = ordersOf.get(body);
+	if (known !== void 0) return known;
+	const ordered = Query.from(body.entity).pipe(Query.orderBy(...body.orderBy));
+	ordersOf.set(body, ordered);
+	return ordered;
+};
+/**
+* Whether the held row under `key` is in `body`'s result, judged over the
+* whole store: none where the answer rests on what the store lacks.
+*/
+const judgedOver = (holder, body, encoded, key, prefix, options) => Option.flatMap(holder.rows.row(body.entity, key.slice(prefix.length)), (row) => Judge.match(Judge.query(body, encoded, row, {
+	operators: options.operators,
+	context: options.context,
+	rows: holder.rows
+}), {
+	onKnown: Option.some,
+	onUnknown: () => Option.none()
+}));
+/**
+* Takes the input **encoded**, because its one caller holds it that way: a
+* connection identity carries the canonical encoded input, and making it decode
+* only for this to encode again would be a round trip that can fail.
+*
+* A decoded-input sibling was written first and deleted: nothing called it. The
+* asymmetry with `matching`, which takes a decoded input, is the shape of the
+* two real callers rather than an oversight.
+*/
+const belongsEncoded = (store, descriptor, encoded, key, operators, context) => {
+	const entry = store[key];
+	if (entry === void 0) return "unknown";
+	if (entry.tombstone) return "no";
+	const body = descriptor.body;
+	if (body !== void 0 && decidableOn(body).some((field) => entry.stale.has(field))) return "unknown";
+	let judged;
+	try {
+		judged = matchingEncoded(store, descriptor, encoded, {
+			among: [key],
+			operators,
+			context
+		});
+	} catch (error) {
+		if (error instanceof QueryEvaluateError) return "unknown";
+		throw error;
+	}
+	if (judged.matched.includes(key)) return "yes";
+	if (judged.skipped.includes(key)) return "unknown";
+	return "no";
+};
+export { belongsEncoded, matching };
+
+//# sourceMappingURL=matching.js.map

package/dist/matching.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matching.js","names":["Relational"],"sources":["../src/matching.ts"],"sourcesContent":["/**\n * Running a query body against the rows the client already holds.\n *\n * local-execution-DESIGN phase 3. A connection's rows are edges the server\n * delivered, and until now nothing on the client ever evaluated a body — which\n * is why an optimistic insert has to guess between `prepend` and `append`, and\n * why `LivePolicy` exists to be told in advance what to do with a row nobody\n * could judge.\n *\n * This judges them. It is pure, it performs no I/O, and it reuses the reference\n * interpreter in `foldkit-entity` rather than reimplementing the semantics —\n * so a body means here exactly what it means on the server, checked by the same\n * conformance suite.\n *\n * **It answers \"which of the rows I hold match\", never \"which rows match\".**\n * Those are different questions and the difference is not recoverable from the\n * result, so it is in the shape: `matched` is what satisfied the body, and\n * `skipped` is what was held but could not be judged. A caller that knows it\n * holds the whole population — a connection terminal at both ends — is the one\n * that can turn this into a complete answer. Nothing here can.\n *\n * **It is not authorization.** On the server a compiled `where` is conjoined\n * with the binding's `visible` rule. There is no `visible` here, and this is\n * safe only because the client holds only rows the server already released to\n * it. A local filter is not an access decision.\n */\nimport { Option, Schema } from 'effect'\nimport { Query as Relational } from 'foldkit-entity'\nimport {\n  Held,\n  Judge,\n  QueryEvaluateError,\n  evaluateEach,\n  type AnyQuery,\n  type ExprContext,\n  type MemoryOperators,\n  type Row,\n} from 'foldkit-entity'\nimport { holderOf, type StoreHolder } from './held.js'\nimport type { QueryDescriptor } from './query.js'\nimport type { EntityKey, EntityStore } from './store.js'\n\n/**\n * An answer over the rows the client holds — never over the rows that exist.\n *\n * `complete` is the whole reason this is its own type rather than a `Page`. A\n * `Page` carries `hasNext`/`hasPrevious`, which are facts the *server* stated\n * about rows beyond the ones it delivered; a local answer has no such facts and\n * cannot invent them. What it can say is whether the population it judged was\n * all of it, which is decidable: a connection terminal at both ends is wholly\n * held, and nothing was skipped for a missing field.\n *\n * An incomplete answer is not wrong — it is an answer about less than the\n * caller may have meant, and the flag is what lets a view say \"3 so far\" rather\n * than \"3\", or a caller decide to ask the server.\n */\nexport interface Matched<A> {\n  readonly items: ReadonlyArray<A>\n  /** Whether every row the answer is about was judged. */\n  readonly complete: boolean\n}\n\n/**\n * What the rows the client holds had to say about a body.\n *\n * `skipped` is the honest half. A row missing a field the body reads cannot be\n * judged — it is neither a match nor a non-match — and dropping it silently\n * would turn \"I could not tell\" into \"no\". Naming it lets a caller decide:\n * fetch the field, ask the server, or say the answer is partial.\n */\nexport interface Judged {\n  /** Keys of the rows that satisfy the body, in the order the body asks for. */\n  readonly matched: ReadonlyArray<EntityKey>\n  /**\n   * Keys of rows held but not judged either way: missing a field the body\n   * reads, or holding a value the interpreter refuses (text with a NUL).\n   */\n  readonly skipped: ReadonlyArray<EntityKey>\n}\n\n/**\n * The fields of the body's own Entity that a row must have for the body to be\n * decidable about it — its predicates and its ordering terms.\n *\n * `id` is never among them: it is the key, so it is known for every row in the\n * store whether or not anything fetched it as a field.\n */\nconst decidableOn = (body: Parameters<typeof Relational.dependencies>[0]): ReadonlyArray<string> =>\n  Relational.dependencies(body)\n    .fields.filter(field => field.entity === body.entity.name && field.key !== 'id')\n    .map(field => field.key)\n\nexport interface MatchingOptions {\n  /**\n   * Judge only these keys. Without it every row of the body's Entity in the\n   * store is a candidate, which is what a filter over a loaded list wants; with\n   * it, a caller narrows to a connection's own edges.\n   */\n  readonly among?: ReadonlyArray<EntityKey> | undefined\n  /** How the body's primitive operators are run: `Remote.make`'s `operators`. */\n  readonly operators?: MemoryOperators | undefined\n  /**\n   * What the body's `Expr.viewer` and `Expr.now` read: `Remote.make`'s\n   * `viewer`. Without it, or without a reading of the time, a body reading\n   * one cannot be judged here.\n   */\n  readonly context?: ExprContext | undefined\n}\n\n/**\n * The rows of `descriptor`'s Entity that the store holds and the body matches.\n *\n * The input is given **decoded**, as an application writes it, and encoded here\n * through the descriptor's own `Input` codec. That is deliberate and is the\n * whole reason this takes a descriptor rather than a bare body: a store holds\n * wire values, so an input has to be in that space to be compared against them,\n * and handing an interpreter a decoded value is a mistake **no runtime error\n * catches** — the reference interpreter answers \"no rows\", which reads exactly\n * like a correct answer. Doing it here means a caller cannot get it wrong.\n *\n * Literals in the body are deliberately *not* encoded. A literal written in\n * domain terms is already broken against the server, which binds it to a column\n * the same way; accepting it here would make the client quietly more permissive\n * than the thing it has to agree with.\n */\nexport const matching = <Name extends string, Input>(\n  store: EntityStore,\n  descriptor: QueryDescriptor<Name, Input, unknown>,\n  input: Input,\n  options: MatchingOptions = {},\n): Judged =>\n  matchingEncoded(\n    store,\n    descriptor,\n    Schema.encodeSync(descriptor.Input)(input) as Readonly<Record<string, unknown>>,\n    options,\n  )\n\n/**\n * As `matching`, for the callers in this module that already hold the input\n * **encoded**. Not exported: `matching` is the way in, and it cannot be given\n * the wrong space.\n */\nconst matchingEncoded = <Name extends string, Input>(\n  store: EntityStore,\n  descriptor: QueryDescriptor<Name, Input, unknown>,\n  encoded: Readonly<Record<string, unknown>>,\n  options: MatchingOptions = {},\n): Judged => {\n  const body = descriptor.body\n  if (body === undefined) {\n    throw new Error(\n      `[foldkit-remote] Remote.matching: query \"${descriptor.name}\" carries no body, so there is nothing to judge rows against. Declare it with Query.define.`,\n    )\n  }\n\n  const entity = body.entity.name\n  const prefix = `${entity}:`\n  const needed = decidableOn(body)\n\n  const candidates = options.among ?? Object.keys(store).filter(key => key.startsWith(prefix))\n\n  const rows: Array<Row & { readonly __key: EntityKey }> = []\n  const skipped: EntityKey[] = []\n\n  for (const key of candidates) {\n    if (!key.startsWith(prefix)) continue\n    const entry = store[key]\n    // Not held at all: nothing to judge. Reachable only through `among`, where\n    // a caller named a key the store does not have — and a key nobody could\n    // judge belongs in `skipped`, not in silence, or an answer built from it\n    // would claim to have considered it.\n    if (entry === undefined) {\n      skipped.push(key)\n      continue\n    }\n    // A tombstone is not a row. Known absent is an answer, not an absence of\n    // one, so it is neither matched nor skipped.\n    if (entry.tombstone) continue\n    if (needed.some(field => !entry.present.has(field))) {\n      skipped.push(key)\n      continue\n    }\n    // The key's id is a **fallback**, not the truth: `Entity.ref` stringifies\n    // ids, so a numeric id is `7` in the store and `\"7\"` in the key. Overwriting\n    // the encoded value with the key's makes `eq(id, 7)` false and sorts ids\n    // lexicographically — both silently.\n    // The store keeps a link as its ref key; the body reads the id it points at.\n    const values = Held.fromRefs(body, entry.values)\n    rows.push(\n      'id' in values\n        ? { ...values, __key: key }\n        : { ...values, id: key.slice(prefix.length), __key: key },\n    )\n  }\n\n  // A body reading other rows is judged over the store as a holder, three\n  // valued: a row whose answer rests on what the store lacks is skipped.\n  // What it admits is then put in order by its terms alone.\n  const reaching = reachesOtherRows(body)\n  const holder = reaching ? holderOf(store) : undefined\n  const admitted =\n    holder === undefined\n      ? rows\n      : rows.filter(row =>\n          Option.match(judgedOver(holder, body, encoded, row.__key, prefix, options), {\n            onSome: matched => matched,\n            onNone: () => {\n              skipped.push(row.__key)\n              return false\n            },\n          }),\n        )\n\n  // Each row judged alone: a refused row is one more that could not be told,\n  // not a reason to answer nothing about the others.\n  const judged = evaluateEach(reaching ? orderOnly(body) : body, encoded, admitted, {\n    operators: options.operators,\n    context: options.context,\n  })\n  const keyOf = (row: Row) => (row as { readonly __key: EntityKey }).__key\n\n  return { matched: judged.matched.map(keyOf), skipped: [...skipped, ...judged.refused.map(keyOf)] }\n}\n\nconst reachingBodies = new WeakMap<AnyQuery, boolean>()\n\n/** Whether a body's predicates read other rows: a path, an exists, a path from the viewer. */\nconst reachesOtherRows = (body: AnyQuery): boolean => {\n  const known = reachingBodies.get(body)\n  if (known !== undefined) return known\n  const reaching = Relational.dependencies(body).reaches.length > 0\n  reachingBodies.set(body, reaching)\n  return reaching\n}\n\nconst ordersOf = new WeakMap<AnyQuery, AnyQuery>()\n\n/** `body`'s order without its predicates, to put rows it admitted in order. */\nconst orderOnly = (body: AnyQuery): AnyQuery => {\n  const known = ordersOf.get(body)\n  if (known !== undefined) return known\n  const ordered = Relational.from(body.entity).pipe(Relational.orderBy(...body.orderBy))\n  ordersOf.set(body, ordered)\n  return ordered\n}\n\n/**\n * Whether the held row under `key` is in `body`'s result, judged over the\n * whole store: none where the answer rests on what the store lacks.\n */\nconst judgedOver = (\n  holder: StoreHolder,\n  body: AnyQuery,\n  encoded: Readonly<Record<string, unknown>>,\n  key: EntityKey,\n  prefix: string,\n  options: MatchingOptions,\n): Option.Option<boolean> =>\n  Option.flatMap(holder.rows.row(body.entity, key.slice(prefix.length)), row =>\n    Judge.match(\n      Judge.query(body, encoded, row, {\n        operators: options.operators,\n        context: options.context,\n        rows: holder.rows,\n      }),\n      { onKnown: Option.some, onUnknown: () => Option.none() },\n    ),\n  )\n\n/**\n * Whether one row belongs to a query, as far as the client can tell.\n *\n * Three answers, and the third is the one that makes this usable. `'unknown'`\n * is a row the store never fetched, or holds without a field the body reads —\n * a caller that collapses it into `'no'` has turned \"I could not tell\" into an\n * answer, which is the mistake this whole module is shaped against.\n *\n * **Membership is decidable where position is not.** Whether a row satisfies\n * `eq`, `isNull` or `contains` needs no collation: equality on text is exact\n * and `contains` folds ASCII, both stated in §6.0.1. *Where* a row sorts needs\n * text collation, which is the backend's and deliberately outside the\n * conformant subset — so this answers the half that is always answerable, and\n * ordering stays the server's until a query can declare its collation.\n */\nexport type Belongs = 'yes' | 'no' | 'unknown'\n\n/**\n * Takes the input **encoded**, because its one caller holds it that way: a\n * connection identity carries the canonical encoded input, and making it decode\n * only for this to encode again would be a round trip that can fail.\n *\n * A decoded-input sibling was written first and deleted: nothing called it. The\n * asymmetry with `matching`, which takes a decoded input, is the shape of the\n * two real callers rather than an oversight.\n */\nexport const belongsEncoded = <Name extends string, Input>(\n  store: EntityStore,\n  descriptor: QueryDescriptor<Name, Input, unknown>,\n  encoded: Readonly<Record<string, unknown>>,\n  key: EntityKey,\n  operators?: MemoryOperators | undefined,\n  context?: ExprContext | undefined,\n): Belongs => {\n  const entry = store[key]\n  // Never fetched: nothing to judge, and silence is the honest answer.\n  if (entry === undefined) return 'unknown'\n  // Known absent. Not \"does not match\" — but it definitely does not belong in\n  // a list, which is what a caller is asking.\n  if (entry.tombstone) return 'no'\n\n  // A value the store itself calls outdated cannot settle a question about new\n  // information. `matching` still judges on a stale value — that is what is on\n  // screen — but this is used to *decide*, and deciding \"does not belong\" from\n  // a field the store says may be behind would suppress a live insert on the\n  // strength of the very fact the insert contradicts.\n  const body = descriptor.body\n  if (body !== undefined && decidableOn(body).some(field => entry.stale.has(field))) {\n    return 'unknown'\n  }\n\n  let judged: Judged\n  try {\n    judged = matchingEncoded(store, descriptor, encoded, { among: [key], operators, context })\n  } catch (error) {\n    // A body the reference interpreter refuses for this input (text holding\n    // NUL) cannot settle membership; the server refuses it too.\n    if (error instanceof QueryEvaluateError) return 'unknown'\n    throw error\n  }\n  if (judged.matched.includes(key)) return 'yes'\n  // Held, but missing a field the body reads.\n  if (judged.skipped.includes(key)) return 'unknown'\n  // Judged and did not match — or is a row of another Entity entirely, which\n  // cannot belong to a connection over this one.\n  return 'no'\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuFA,MAAM,eAAe,SACnBA,MAAW,aAAa,IAAI,CAAC,CAC1B,OAAO,QAAO,UAAS,MAAM,WAAW,KAAK,OAAO,QAAQ,MAAM,QAAQ,IAAI,CAAC,CAC/E,KAAI,UAAS,MAAM,GAAG;;;;;;;;;;;;;;;;;AAmC3B,MAAa,YACX,OACA,YACA,OACA,UAA2B,CAAC,MAE5B,gBACE,OACA,YACA,OAAO,WAAW,WAAW,KAAK,CAAC,CAAC,KAAK,GACzC,OACF;;;;;;AAOF,MAAM,mBACJ,OACA,YACA,SACA,UAA2B,CAAC,MACjB;CACX,MAAM,OAAO,WAAW;CACxB,IAAI,SAAS,KAAA,GACX,MAAM,IAAI,MACR,4CAA4C,WAAW,KAAK,4FAC9D;CAIF,MAAM,SAAS,GADA,KAAK,OAAO,KACF;CACzB,MAAM,SAAS,YAAY,IAAI;CAE/B,MAAM,aAAa,QAAQ,SAAS,OAAO,KAAK,KAAK,CAAC,CAAC,QAAO,QAAO,IAAI,WAAW,MAAM,CAAC;CAE3F,MAAM,OAAmD,CAAC;CAC1D,MAAM,UAAuB,CAAC;CAE9B,KAAK,MAAM,OAAO,YAAY;EAC5B,IAAI,CAAC,IAAI,WAAW,MAAM,GAAG;EAC7B,MAAM,QAAQ,MAAM;EAKpB,IAAI,UAAU,KAAA,GAAW;GACvB,QAAQ,KAAK,GAAG;GAChB;EACF;EAGA,IAAI,MAAM,WAAW;EACrB,IAAI,OAAO,MAAK,UAAS,CAAC,MAAM,QAAQ,IAAI,KAAK,CAAC,GAAG;GACnD,QAAQ,KAAK,GAAG;GAChB;EACF;EAMA,MAAM,SAAS,KAAK,SAAS,MAAM,MAAM,MAAM;EAC/C,KAAK,KACH,QAAQ,SACJ;GAAE,GAAG;GAAQ,OAAO;EAAI,IACxB;GAAE,GAAG;GAAQ,IAAI,IAAI,MAAM,OAAO,MAAM;GAAG,OAAO;EAAI,CAC5D;CACF;CAKA,MAAM,WAAW,iBAAiB,IAAI;CACtC,MAAM,SAAS,WAAW,SAAS,KAAK,IAAI,KAAA;CAC5C,MAAM,WACJ,WAAW,KAAA,IACP,OACA,KAAK,QAAO,QACV,OAAO,MAAM,WAAW,QAAQ,MAAM,SAAS,IAAI,OAAO,QAAQ,OAAO,GAAG;EAC1E,SAAQ,YAAW;EACnB,cAAc;GACZ,QAAQ,KAAK,IAAI,KAAK;GACtB,OAAO;EACT;CACF,CAAC,CACH;CAIN,MAAM,SAAS,aAAa,WAAW,UAAU,IAAI,IAAI,MAAM,SAAS,UAAU;EAChF,WAAW,QAAQ;EACnB,SAAS,QAAQ;CACnB,CAAC;CACD,MAAM,SAAS,QAAc,IAAsC;CAEnE,OAAO;EAAE,SAAS,OAAO,QAAQ,IAAI,KAAK;EAAG,SAAS,CAAC,GAAG,SAAS,GAAG,OAAO,QAAQ,IAAI,KAAK,CAAC;CAAE;AACnG;AAEA,MAAM,iCAAiB,IAAI,QAA2B;;AAGtD,MAAM,oBAAoB,SAA4B;CACpD,MAAM,QAAQ,eAAe,IAAI,IAAI;CACrC,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,MAAM,WAAWA,MAAW,aAAa,IAAI,CAAC,CAAC,QAAQ,SAAS;CAChE,eAAe,IAAI,MAAM,QAAQ;CACjC,OAAO;AACT;AAEA,MAAM,2BAAW,IAAI,QAA4B;;AAGjD,MAAM,aAAa,SAA6B;CAC9C,MAAM,QAAQ,SAAS,IAAI,IAAI;CAC/B,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,MAAM,UAAUA,MAAW,KAAK,KAAK,MAAM,CAAC,CAAC,KAAKA,MAAW,QAAQ,GAAG,KAAK,OAAO,CAAC;CACrF,SAAS,IAAI,MAAM,OAAO;CAC1B,OAAO;AACT;;;;;AAMA,MAAM,cACJ,QACA,MACA,SACA,KACA,QACA,YAEA,OAAO,QAAQ,OAAO,KAAK,IAAI,KAAK,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC,IAAG,QACrE,MAAM,MACJ,MAAM,MAAM,MAAM,SAAS,KAAK;CAC9B,WAAW,QAAQ;CACnB,SAAS,QAAQ;CACjB,MAAM,OAAO;AACf,CAAC,GACD;CAAE,SAAS,OAAO;CAAM,iBAAiB,OAAO,KAAK;AAAE,CACzD,CACF;;;;;;;;;;AA4BF,MAAa,kBACX,OACA,YACA,SACA,KACA,WACA,YACY;CACZ,MAAM,QAAQ,MAAM;CAEpB,IAAI,UAAU,KAAA,GAAW,OAAO;CAGhC,IAAI,MAAM,WAAW,OAAO;CAO5B,MAAM,OAAO,WAAW;CACxB,IAAI,SAAS,KAAA,KAAa,YAAY,IAAI,CAAC,CAAC,MAAK,UAAS,MAAM,MAAM,IAAI,KAAK,CAAC,GAC9E,OAAO;CAGT,IAAI;CACJ,IAAI;EACF,SAAS,gBAAgB,OAAO,YAAY,SAAS;GAAE,OAAO,CAAC,GAAG;GAAG;GAAW;EAAQ,CAAC;CAC3F,SAAS,OAAO;EAGd,IAAI,iBAAiB,oBAAoB,OAAO;EAChD,MAAM;CACR;CACA,IAAI,OAAO,QAAQ,SAAS,GAAG,GAAG,OAAO;CAEzC,IAAI,OAAO,QAAQ,SAAS,GAAG,GAAG,OAAO;CAGzC,OAAO;AACT"}