@gaganref/confect-server 0.0.0-stage → 10.3.1-fork.10

package/src/QueryStreamCursor.ts

@@ -0,0 +1,99 @@
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as QueryStreamKey from "./QueryStreamKey.js";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as Match from "effect/Match";
+import * as Schema from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as QueryStreamKeyLayout from "./QueryStreamKeyLayout.js";
+import * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
+
+// Serialized labels are a cursor boundary representation. They include every
+// runtime position but do not preserve implicitness.
+const RuntimeLabels = Schema.Array(Schema.String);
+const RuntimeLabelsEquivalence = Schema.toEquivalence(RuntimeLabels);
+const positionRuntimeLabel = Match.type<QueryStreamKeyLayout.Position>().pipe(
+  Match.tagsExhaustive({
+    Visible: ({ label }) => label,
+    ImplicitId: () => "_id",
+  }),
+);
+
+/**
+ * @experimental
+ */
+export const QueryStreamCursor = Schema.Struct({
+  runtimeLabels: RuntimeLabels,
+  keyValues: QueryStreamKeyValues.QueryStreamKeyValues,
+}).check(
+  Schema.makeFilter(
+    (cursor) => cursor.keyValues.length === cursor.runtimeLabels.length,
+    { message: "key values and runtime labels must have the same length" },
+  ),
+);
+
+/**
+ * @experimental
+ */
+export interface QueryStreamCursor extends Schema.Schema.Type<
+  typeof QueryStreamCursor
+> {}
+
+/**
+ * @experimental
+ */
+export const END_CURSOR = "[]";
+
+/**
+ * Bind cursor string encoding and decoding to a layout.
+ *
+ * @experimental
+ */
+export const fromKeyLayout = (
+  keyLayout: QueryStreamKeyLayout.QueryStreamKeyLayout,
+) => {
+  const runtimeLabels = Array.map(
+    QueryStreamKeyLayout.positions(keyLayout),
+    positionRuntimeLabel,
+  );
+  return Schema.fromJsonString(QueryStreamCursor)
+    .check(
+      Schema.makeFilter(
+        (cursor) =>
+          RuntimeLabelsEquivalence(cursor.runtimeLabels, runtimeLabels),
+        { message: "Cursor runtime labels do not match the stream" },
+      ),
+    )
+    .pipe(
+      Schema.decodeTo(
+        Schema.declare(QueryStreamKey.isComplete).check(
+          Schema.makeFilter(
+            (key) => QueryStreamKeyLayout.Equivalence(key.layout, keyLayout),
+            { message: "Cursor key does not belong to the stream layout" },
+          ),
+        ),
+        {
+          decode: SchemaGetter.transformEffect((cursor, options) =>
+            Effect.fromResult(
+              QueryStreamKey.complete(keyLayout, cursor.keyValues),
+            ).pipe(
+              Effect.mapError(
+                (error) =>
+                  new SchemaIssue.InvalidValue(
+                    { message: error.message },
+                    cursor.keyValues,
+                    options,
+                  ),
+              ),
+            ),
+          ),
+          encode: SchemaGetter.transformEffect((key) =>
+            QueryStreamCursor.makeEffect({
+              runtimeLabels,
+              keyValues: key.values,
+            }),
+          ),
+        },
+      ),
+    );
+};

package/src/QueryStreamIndexPrefix.ts

@@ -0,0 +1,79 @@
+import * as Array from "effect/Array";
+import * as Data from "effect/Data";
+import * as Result from "effect/Result";
+import type * as QueryStreamKey from "./QueryStreamKey.js";
+import type * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
+
+const TypeId = "~@confect/server/QueryStreamIndexPrefix";
+
+/**
+ * @experimental
+ */
+export type IndexEntries = ReadonlyArray<
+  readonly [string, QueryStreamKeyValues.QueryStreamKeyValues[number]]
+>;
+
+/**
+ * Index coordinates retain the field path belonging to each value.
+ *
+ * @experimental
+ */
+export interface QueryStreamIndexPrefix {
+  readonly [TypeId]: IndexEntries;
+}
+
+/**
+ * @experimental
+ */
+export class IndexPrefixWidthMismatchError extends Data.TaggedError(
+  "IndexPrefixWidthMismatchError",
+)<{
+  readonly width: number;
+  readonly actual: number;
+}> {
+  override get message(): string {
+    return `Invalid index prefix key width (${this.actual}); expected at most ${this.width}`;
+  }
+}
+
+/**
+ * @experimental
+ */
+export const make = (
+  fieldPaths: ReadonlyArray<string>,
+  keyValues: QueryStreamKeyValues.QueryStreamKeyValues,
+): Result.Result<QueryStreamIndexPrefix, IndexPrefixWidthMismatchError> =>
+  keyValues.length <= fieldPaths.length
+    ? Result.succeed({ [TypeId]: Array.zip(fieldPaths, keyValues) })
+    : Result.fail(
+        new IndexPrefixWidthMismatchError({
+          width: fieldPaths.length,
+          actual: keyValues.length,
+        }),
+      );
+
+/**
+ * @experimental
+ */
+export const entries = (self: QueryStreamIndexPrefix): IndexEntries =>
+  self[TypeId];
+
+/**
+ * @experimental
+ */
+export const keyValues = (
+  self: QueryStreamIndexPrefix,
+): QueryStreamKeyValues.QueryStreamKeyValues =>
+  Array.map(entries(self), ([, value]) => value);
+
+/**
+ * Restore equality values when crossing into index coordinates.
+ *
+ * @experimental
+ */
+export const fromStreamKey = (
+  fieldPaths: ReadonlyArray<string>,
+  equalityKeyValues: QueryStreamKeyValues.QueryStreamKeyValues,
+  self: QueryStreamKey.QueryStreamKey,
+): Result.Result<QueryStreamIndexPrefix, IndexPrefixWidthMismatchError> =>
+  make(fieldPaths, Array.appendAll(equalityKeyValues, self.values));

package/src/QueryStreamIndexRange.ts

@@ -0,0 +1,489 @@
+import type {
+  GenericDocument,
+  FieldTypeFromFieldPath,
+  IndexRange as ConvexIndexRange,
+  IndexRangeBuilder as ConvexIndexRangeBuilder,
+} from "convex/server";
+import * as Array from "effect/Array";
+import * as Data from "effect/Data";
+import { identity, pipe } from "effect/Function";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import type * as Types from "effect/Types";
+import * as QueryStreamIndexPrefix from "./QueryStreamIndexPrefix.js";
+import * as QueryStreamKeyBounds from "./QueryStreamKeyBounds.js";
+import * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
+import type * as QueryStreamOrderDirection from "./QueryStreamOrderDirection.js";
+
+type Head<FieldPaths extends ReadonlyArray<string>> =
+  FieldPaths extends readonly [infer H extends string, ...ReadonlyArray<string>]
+    ? H
+    : never;
+
+type Tail<FieldPaths extends ReadonlyArray<string>> =
+  FieldPaths extends readonly [
+    string,
+    ...infer Rest extends ReadonlyArray<string>,
+  ]
+    ? Rest
+    : ReadonlyArray<string>;
+
+// The range builder mirrors Convex's `IndexRangeBuilder`, but *consumes* the
+// index-field tuple at the type level as `eq` pins field paths. The remaining
+// tuple supplies the initial visible ordering labels of the resulting stream.
+
+const TypeId = "~@confect/server/QueryStreamIndexRange";
+
+interface Equality {
+  readonly fieldPath: string;
+  readonly value: QueryStreamKeyValues.KeyValue;
+}
+
+interface Endpoint {
+  readonly value: QueryStreamKeyValues.KeyValue;
+  readonly inclusive: boolean;
+}
+
+type Interval = Data.TaggedEnum<{
+  Lower: { readonly lower: Endpoint };
+  Upper: { readonly upper: Endpoint };
+  Between: { readonly lower: Endpoint; readonly upper: Endpoint };
+}>;
+const Interval = Data.taggedEnum<Interval>();
+
+interface Constraints {
+  readonly equalities: ReadonlyArray<Equality>;
+  readonly bounded: Option.Option<{
+    readonly fieldPath: string;
+    readonly interval: Interval;
+  }>;
+}
+
+/**
+ * The equality prefix followed by at most one bounded field.
+ *
+ * @experimental
+ */
+export interface QueryStreamIndexRange<
+  out RemainingFieldPaths extends ReadonlyArray<string> = ReadonlyArray<string>,
+> {
+  readonly [TypeId]: Constraints & {
+    readonly _Remaining: Types.Covariant<RemainingFieldPaths>;
+  };
+}
+
+/**
+ * @experimental
+ */
+export type Remaining<IndexRange> =
+  IndexRange extends QueryStreamIndexRange<infer RemainingFieldPaths>
+    ? RemainingFieldPaths
+    : never;
+
+/**
+ * A typed index-range builder. `eq` must target the next unpinned index field,
+ * and consumes it; `gt`/`gte`/`lt`/`lte` bound the next field without consuming
+ * it (bounded field paths still vary within the range).
+ *
+ * @experimental
+ */
+export interface Builder<
+  ConvexDoc extends GenericDocument,
+  FieldPaths extends ReadonlyArray<string>,
+> extends QueryStreamIndexRange<FieldPaths> {
+  readonly eq: (
+    fieldPath: Head<FieldPaths>,
+    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,
+  ) => Builder<ConvexDoc, Tail<FieldPaths>>;
+  readonly gt: (
+    fieldPath: Head<FieldPaths>,
+    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,
+  ) => LowerBoundedBuilder<ConvexDoc, FieldPaths>;
+  readonly gte: (
+    fieldPath: Head<FieldPaths>,
+    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,
+  ) => LowerBoundedBuilder<ConvexDoc, FieldPaths>;
+  readonly lt: (
+    fieldPath: Head<FieldPaths>,
+    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,
+  ) => QueryStreamIndexRange<FieldPaths>;
+  readonly lte: (
+    fieldPath: Head<FieldPaths>,
+    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,
+  ) => QueryStreamIndexRange<FieldPaths>;
+}
+
+/**
+ * After `gt`/`gte`, only an upper bound on the same field may follow.
+ *
+ * @experimental
+ */
+export interface LowerBoundedBuilder<
+  ConvexDoc extends GenericDocument,
+  FieldPaths extends ReadonlyArray<string>,
+> extends QueryStreamIndexRange<FieldPaths> {
+  readonly lt: (
+    fieldPath: Head<FieldPaths>,
+    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,
+  ) => QueryStreamIndexRange<FieldPaths>;
+  readonly lte: (
+    fieldPath: Head<FieldPaths>,
+    value: FieldTypeFromFieldPath<ConvexDoc, Head<FieldPaths>>,
+  ) => QueryStreamIndexRange<FieldPaths>;
+}
+
+const make = (constraints: Constraints): QueryStreamIndexRange => ({
+  [TypeId]: {
+    ...constraints,
+    _Remaining: identity as Types.Covariant<ReadonlyArray<string>>,
+  },
+});
+
+const makeBuilder = (
+  equalities: ReadonlyArray<Equality>,
+): Builder<GenericDocument, ReadonlyArray<string>> => {
+  const upper =
+    (inclusive: boolean) =>
+    (fieldPath: string, value: QueryStreamKeyValues.KeyValue) =>
+      make({
+        equalities,
+        bounded: Option.some({
+          fieldPath,
+          interval: Interval.Upper({ upper: { value, inclusive } }),
+        }),
+      });
+  const lower =
+    (inclusive: boolean) =>
+    (
+      fieldPath: string,
+      value: QueryStreamKeyValues.KeyValue,
+    ): LowerBoundedBuilder<GenericDocument, ReadonlyArray<string>> => {
+      const endpoint = { value, inclusive };
+      const finish =
+        (upperInclusive: boolean) =>
+        (_fieldPath: string, upperValue: QueryStreamKeyValues.KeyValue) =>
+          make({
+            equalities,
+            bounded: Option.some({
+              fieldPath,
+              interval: Interval.Between({
+                lower: endpoint,
+                upper: { value: upperValue, inclusive: upperInclusive },
+              }),
+            }),
+          });
+      return {
+        ...make({
+          equalities,
+          bounded: Option.some({
+            fieldPath,
+            interval: Interval.Lower({ lower: endpoint }),
+          }),
+        }),
+        lt: finish(false),
+        lte: finish(true),
+      };
+    };
+  return {
+    ...make({ equalities, bounded: Option.none() }),
+    eq: (fieldPath, value) =>
+      makeBuilder(Array.append(equalities, { fieldPath, value })),
+    gt: lower(false),
+    gte: lower(true),
+    lt: upper(false),
+    lte: upper(true),
+  };
+};
+
+/**
+ * The initial builder handed to a range callback.
+ *
+ * @experimental
+ */
+export const builder = <
+  ConvexDoc extends GenericDocument,
+  FieldPaths extends ReadonlyArray<string>,
+>(): Builder<ConvexDoc, FieldPaths> =>
+  makeBuilder([]) as unknown as Builder<ConvexDoc, FieldPaths>;
+
+/**
+ * Number of index fields pinned by equality constraints.
+ *
+ * @experimental
+ */
+export const equalityPrefixLength = (self: QueryStreamIndexRange): number =>
+  self[TypeId].equalities.length;
+
+interface ConvexUpperBoundBuilder extends ConvexIndexRange {
+  readonly lt: (
+    fieldPath: string,
+    value: QueryStreamKeyValues.KeyValue,
+  ) => ConvexIndexRange;
+  readonly lte: (
+    fieldPath: string,
+    value: QueryStreamKeyValues.KeyValue,
+  ) => ConvexIndexRange;
+}
+
+interface ConvexRangeBuilder extends ConvexUpperBoundBuilder {
+  readonly eq: (
+    fieldPath: string,
+    value: QueryStreamKeyValues.KeyValue,
+  ) => ConvexRangeBuilder;
+  readonly gt: (
+    fieldPath: string,
+    value: QueryStreamKeyValues.KeyValue,
+  ) => ConvexUpperBoundBuilder;
+  readonly gte: (
+    fieldPath: string,
+    value: QueryStreamKeyValues.KeyValue,
+  ) => ConvexUpperBoundBuilder;
+}
+
+/**
+ * Apply one range to Convex's index-range builder.
+ *
+ * @experimental
+ */
+export const apply = (
+  self: QueryStreamIndexRange,
+  q: ConvexIndexRangeBuilder<GenericDocument, string[]>,
+): ConvexIndexRange => {
+  const { equalities, bounded } = self[TypeId];
+  // Convex tracks equality progress through a static field tuple. These paths
+  // are runtime data; the range model owns their ordering. Its runtime builder
+  // supports further equality calls, even when the SDK type has lost the tuple.
+  const prefix = Array.reduce(
+    equalities,
+    q as ConvexRangeBuilder,
+    (target, { fieldPath, value }) => target.eq(fieldPath, value),
+  );
+  return Option.match(bounded, {
+    onNone: () => prefix,
+    onSome: ({ fieldPath, interval }) => {
+      const lower = (
+        target: ConvexRangeBuilder,
+        endpoint: Endpoint,
+      ): ConvexUpperBoundBuilder =>
+        target[endpoint.inclusive ? "gte" : "gt"](fieldPath, endpoint.value);
+      const upper = (
+        target: ConvexUpperBoundBuilder,
+        endpoint: Endpoint,
+      ): ConvexIndexRange =>
+        target[endpoint.inclusive ? "lte" : "lt"](fieldPath, endpoint.value);
+      return Interval.$match(interval, {
+        Lower: ({ lower: endpoint }) => lower(prefix, endpoint),
+        Upper: ({ upper: endpoint }) => upper(prefix, endpoint),
+        Between: (endpoints) =>
+          upper(lower(prefix, endpoints.lower), endpoints.upper),
+      });
+    },
+  });
+};
+
+// Convex index ranges have the shape `eq(f1) … eq(fn), gt/gte(fm)?,
+// lt/lte(fm)?`—every field path pinned except the last, which may carry two
+// inequalities. An arbitrary range between two index keys therefore
+// decomposes into a *sequence* of Convex-expressible ranges (the port of
+// `convex-helpers`' `splitRange`): e.g. `(1, 2, 3) < key <= (1, 3, 2)` over
+// field paths `(f1, f2, f3)` becomes
+//
+//   1. eq(f1, 1), eq(f2, 2), gt(f3, 3)
+//   2. eq(f1, 1), gt(f2, 2), lt(f2, 3)
+//   3. eq(f1, 1), eq(f2, 3), lte(f3, 2)
+
+type BoundTag = "gt" | "gte" | "lt" | "lte";
+
+class TaggedBound extends Data.Class<{
+  readonly indexEntries: QueryStreamIndexPrefix.IndexEntries;
+  readonly tag: BoundTag;
+}> {}
+
+/**
+ * Dropping a bound's last entry bounds the remaining prefix exclusively.
+ */
+const excludePrefix = (tag: BoundTag): BoundTag =>
+  Match.value(tag).pipe(
+    Match.whenOr("gt", "gte", () => "gt" as const),
+    Match.whenOr("lt", "lte", () => "lt" as const),
+    Match.exhaustive,
+  );
+
+/**
+ * Peel a bound down to the single entry that feeds the middle range.
+ */
+const peelBound = (
+  indexEntries: QueryStreamIndexPrefix.IndexEntries,
+  tag: BoundTag,
+): {
+  readonly peeled: ReadonlyArray<TaggedBound>;
+  readonly final: TaggedBound;
+} =>
+  indexEntries.length <= 1
+    ? { peeled: [], final: new TaggedBound({ indexEntries, tag }) }
+    : pipe(
+        peelBound(Array.dropRight(indexEntries, 1), excludePrefix(tag)),
+        ({ final, peeled }) => ({
+          peeled: Array.prepend(peeled, new TaggedBound({ indexEntries, tag })),
+          final,
+        }),
+      );
+
+/**
+ * Pin every entry but the last, which gets the bound tag.
+ */
+const rangeFor = (
+  prefix: ReadonlyArray<Equality>,
+  indexEntries: QueryStreamIndexPrefix.IndexEntries,
+  tag: BoundTag,
+): QueryStreamIndexRange =>
+  Option.match(Array.last(indexEntries), {
+    onNone: () => make({ equalities: prefix, bounded: Option.none() }),
+    onSome: ([fieldPath, value]) =>
+      make({
+        equalities: Array.appendAll(
+          prefix,
+          Array.map(Array.dropRight(indexEntries, 1), ([path, pinned]) => ({
+            fieldPath: path,
+            value: pinned,
+          })),
+        ),
+        bounded: Option.some({
+          fieldPath,
+          interval:
+            tag === "gt" || tag === "gte"
+              ? Interval.Lower({ lower: { value, inclusive: tag === "gte" } })
+              : Interval.Upper({ upper: { value, inclusive: tag === "lte" } }),
+        }),
+      }),
+  });
+
+/**
+ * Decompose the range between `indexBounds.lower` and `indexBounds.upper` (over
+ * the complete index `fieldPaths`, `_id` tiebreaker included) into a sequence
+ * of Convex-expressible ranges, ordered for the given direction.
+ *
+ * @experimental
+ */
+export const fromBounds = (
+  fieldPaths: ReadonlyArray<string>,
+  orderDirection: QueryStreamOrderDirection.QueryStreamOrderDirection,
+  indexBounds: QueryStreamKeyBounds.IndexBounds,
+): Result.Result<
+  ReadonlyArray<QueryStreamIndexRange>,
+  QueryStreamIndexPrefix.IndexPrefixWidthMismatchError
+> =>
+  Result.gen(function* () {
+    const lowerIndexEntries = QueryStreamIndexPrefix.entries(
+      yield* QueryStreamIndexPrefix.make(
+        fieldPaths,
+        indexBounds.lower.keyValues,
+      ),
+    );
+    const upperIndexEntries = QueryStreamIndexPrefix.entries(
+      yield* QueryStreamIndexPrefix.make(
+        fieldPaths,
+        indexBounds.upper.keyValues,
+      ),
+    );
+    // Equal cuts are an empty range too: e.g. lower exclusive at `k` and
+    // upper inclusive at `k`—the half-open (k, k]—both cut at
+    // successor(k).
+    if (QueryStreamKeyBounds.isEmpty(indexBounds)) {
+      return [];
+    }
+
+    const commonLength = pipe(
+      Array.zip(indexBounds.lower.keyValues, indexBounds.upper.keyValues),
+      Array.takeWhile(
+        ([lowerValue, upperValue]) =>
+          QueryStreamKeyValues.ValueOrder(lowerValue, upperValue) === 0,
+      ),
+      Array.length,
+    );
+    const equalities = pipe(
+      Array.take(lowerIndexEntries, commonLength),
+      Array.map(([fieldPath, value]) => ({ fieldPath, value })),
+    );
+
+    const lower = peelBound(
+      Array.drop(lowerIndexEntries, commonLength),
+      indexBounds.lower.inclusive ? "gte" : "gt",
+    );
+    const upper = peelBound(
+      Array.drop(upperIndexEntries, commonLength),
+      indexBounds.upper.inclusive ? "lte" : "lt",
+    );
+
+    const startIndexRanges = Array.map(lower.peeled, ({ indexEntries, tag }) =>
+      rangeFor(equalities, indexEntries, tag),
+    );
+    const endIndexRanges = Array.reverse(
+      Array.map(upper.peeled, ({ indexEntries, tag }) =>
+        rangeFor(equalities, indexEntries, tag),
+      ),
+    );
+
+    const { indexEntries: lowerFinalIndexEntries, tag: lowerFinalTag } =
+      lower.final;
+    const { indexEntries: upperFinalIndexEntries, tag: upperFinalTag } =
+      upper.final;
+    const middleIndexRange =
+      Array.isReadonlyArrayNonEmpty(lowerFinalIndexEntries) &&
+      Array.isReadonlyArrayNonEmpty(upperFinalIndexEntries)
+        ? make({
+            equalities,
+            bounded: Option.some({
+              fieldPath: Array.headNonEmpty(lowerFinalIndexEntries)[0],
+              interval: Interval.Between({
+                lower: {
+                  value: Array.headNonEmpty(lowerFinalIndexEntries)[1],
+                  inclusive: lowerFinalTag === "gte",
+                },
+                upper: {
+                  value: Array.headNonEmpty(upperFinalIndexEntries)[1],
+                  inclusive: upperFinalTag === "lte",
+                },
+              }),
+            }),
+          })
+        : Array.isReadonlyArrayNonEmpty(lowerFinalIndexEntries)
+          ? rangeFor(equalities, lowerFinalIndexEntries, lowerFinalTag)
+          : rangeFor(equalities, upperFinalIndexEntries, upperFinalTag);
+
+    const indexRanges = Array.appendAll(
+      Array.appendAll(startIndexRanges, Array.of(middleIndexRange)),
+      endIndexRanges,
+    );
+    return orderDirection === "desc" ? Array.reverse(indexRanges) : indexRanges;
+  });
+
+/**
+ * Derive full-index bounds directly from the structural range.
+ *
+ * @experimental
+ */
+export const toBounds = (
+  self: QueryStreamIndexRange,
+): QueryStreamKeyBounds.IndexBounds => {
+  const { equalities, bounded } = self[TypeId];
+  const keyValues = Array.map(equalities, (equality) => equality.value);
+  const unbounded = { keyValues, inclusive: true };
+  const endpoint = ({ value, inclusive }: Endpoint) => ({
+    keyValues: Array.append(keyValues, value),
+    inclusive,
+  });
+  return Option.match(bounded, {
+    onNone: () => ({ lower: unbounded, upper: unbounded }),
+    onSome: ({ interval }) =>
+      Interval.$match(interval, {
+        Lower: ({ lower }) => ({ lower: endpoint(lower), upper: unbounded }),
+        Upper: ({ upper }) => ({ lower: unbounded, upper: endpoint(upper) }),
+        Between: ({ lower, upper }) => ({
+          lower: endpoint(lower),
+          upper: endpoint(upper),
+        }),
+      }),
+  });
+};