@omegup/msync 0.1.48 → 0.1.50

package/index.d.ts

@@ -26,6 +26,12 @@ type O<T = unknown> = Obj & T;
 type RORec<K extends keyof never, T = unknown> = {
     readonly [P in K]: T;
 };
+type PRRec<K extends keyof never, T = unknown> = {
+    [P in K]?: T;
+};
+type Par$1<K extends string, V extends Rec<K, jsonItem>> = {
+    readonly [k in K]?: V[k] | N;
+};
 type Rec<K extends string, T = unknown> = O<RORec<K, T>>;
 type O2 = readonly [O, O];
 type O3 = readonly [O, O, O];
@@ -205,21 +211,45 @@ type BoolExpr<in D1, in D2, in Ctx = unknown> = {
     };
 };
 
+declare const map: <T, K extends string & keyof T, V extends RORec<K, unknown>>(x: Pick<T, K>, f: <P extends K>(v: T[P], k: P) => V[P]) => V;
 type ExactPart<T, F extends HKT<T[StrKey<T>]>> = MapOPart<T, MappedHKT<T, F>>;
+type ExactPart1<T, F extends HKT<StrKey<T>>> = {
+    readonly [K in StrKey<T>]: App<F, K>;
+};
+type s$3 = string;
+type MapKDom<RK extends MapKDom<RK, F>, F extends HKT<StrKey<RK>>> = MapO<RK, F> & {
+    readonly [P in s$3]?: readonly [keyof RK, unknown];
+};
 type ExactKeys<K extends string> = Exact<RORec<K, 1>, IdHKT>;
 type MapO<T, F extends HKT<K>, K extends StrKey<T> = StrKey<T>> = MapOPart<T, F, K> & {
     readonly [P: string]: readonly [K, unknown];
 };
+type MapK<K extends s$3, F extends HKT<K>> = MapO<RORec<K>, F>;
 type MapOPart<T, F extends HKT<K>, K extends keyof T = StrKey<T>> = {
     readonly [P in K]: readonly [P, App<F, P & string>];
 };
+type MapKPart1<T, F extends HKT<K>, K extends StrKey<T> = StrKey<T>> = {
+    readonly [P in K]: App<F, P>;
+};
 type Exact<T, F extends HKT<T[StrKey<T>]>> = MapO<T, MappedHKT<T, F>>;
 interface MappedHKT<T, F extends HKT<T[StrKey<T>]>> extends HKT<StrKey<T>> {
     readonly out: App<F, T[I<StrKey<T>, this>]>;
 }
+declare const mapExactToObject0: <T, F extends HKT<K>, G extends HKT<K>, K extends StrKey<T> = StrKey<T>>(x: MapO<T, F, K>, f: <P extends K>(v: App<F, P>, k: P) => App<G, P>) => MapKPart1<T, G, K>;
+declare const mapExactToObject1: <K extends string, F extends HKT<K>, G extends HKT<K>>(x: MapK<K, F>, f: <P extends K>(v: App<F, P>, k: P) => App<G, P>) => MapKPart1<RORec<K>, G>;
+interface WithKey1<K extends string, G extends HKT<K>> extends HKT<K> {
+    readonly out: readonly [I<K, this>, App<G, I<K, this>>];
+}
+declare const mapExact0: <T, F extends HKT<StrKey<T>>, G extends HKT<StrKey<T>>>(x: MapO<T, F>, f: <P extends StrKey<T>>(v: App<F, P>, k: P) => App<G, P>) => MapO<T, G>;
+declare const mapExact1: <K extends s$3, F extends HKT<K>, G extends HKT<K>>(x: MapK<K, F>, f: <P extends K>(v: App<F, P>, k: P) => App<G, P>) => MapK<K, G>;
+declare const mapExactToObject: <T, F extends HKT<T[StrKey<T>]>, G extends HKT<StrKey<T>>>(x: Exact<T, F>, f: <P extends StrKey<T>>(v: App<F, T[P]>, k: P) => App<G, P>) => ExactPart1<T, G>;
+declare const mapExact: <T, F extends HKT<T[StrKey<T>]>, G extends HKT<T[StrKey<T>]>>(x: Exact<T, F>, f: <P extends StrKey<T>>(v: App<F, T[P]>, k: P) => App<G, T[P]>) => Exact<T, G>;
+type Dom$1<T, V> = HKT<T[StrKey<T>] | V[StrKey<V>]>;
+declare const spread: <T, V, F extends Dom$1<T, V>, E = unknown, No extends keyof V = never>(a: Exact<Omit<T, No>, F>, b: Exact<V, F>) => Exact<V & Omit<T, keyof V> & Pick<E, symbol & keyof E>, F>;
 interface MergeHKT<T, V, F1 extends HKT<StrKey<Omit<T, No>>>, F2 extends HKT<StrKey<V>>, No extends keyof V = never> extends HKT<StrKey<V & Omit<T, No>>> {
     readonly out: I<StrKey<V & Omit<T, No>>, this> extends StrKey<V> ? App<F2, I<StrKey<V>, this>> : App<F1, I<StrKey<Omit<T, No>>, this>>;
 }
+declare const spread0: <T, V, F1 extends HKT<StrKey<Omit<T, No>>>, F2 extends HKT<StrKey<V>>, E = unknown, No extends keyof V = never>(a: MapO<Omit<T, No>, F1>, b: MapO<V, F2>) => MapO<V & Omit<T, No> & Pick<E, symbol & keyof E>, MergeHKT<T, V, F1, F2, No>>;
 
 declare const AccumulatorRaw: unique symbol;
 interface AccumulatorRaw<in Doc, out T, in C = unknown> extends RawObj {
@@ -288,6 +318,9 @@ type I<Dom, F extends HKT<Dom>> = F['in'] extends (x: infer X extends Dom) => vo
 interface IdHKT<Dom = unknown> extends HKT<Dom> {
     readonly out: I<Dom, this>;
 }
+interface ConstHKT<Im, Dom = unknown> extends HKT<Dom, Im> {
+    readonly out: Im;
+}
 type AppMap<F extends HKT<Dom>, X extends readonly Dom[], Dom = unknown> = readonly App<F, Dom>[] & {
     [I in keyof X]: App<F, X[I]>;
 };
@@ -352,27 +385,50 @@ declare const $getField: {
     <T, K extends StrKey<T>, D, C = unknown>(expr: Expr<T, D, C>, field: K): Expr<T[K], D, C>;
     <T, K extends StrKey<T>, D, C = unknown>(expr: Expr<T | N, D, C>, field: K): Expr<T[K] | null, D, C>;
 };
-type NoRaw<T> = T extends Arr<infer U> ? NoRaw<U>[] : T extends readonly unknown[] ? {
-    [K in keyof T]: NoRaw<T[K]>;
-} : T extends O ? {
-    [K in StrKey<T>]: NoRaw<T[K]>;
-} : T;
-type RONoRaw<T> = T extends Arr<infer U> ? readonly RONoRaw<U>[] : T extends readonly unknown[] ? {
-    readonly [K in keyof T]: RONoRaw<T[K]>;
-} : T extends O ? {
-    readonly [K in StrKey<T>]: RONoRaw<T[K]>;
-} : T;
-declare const func: <T extends jsonItem, A extends readonly jsonItem[], D, C = unknown>(f: (...args: NoRaw<A>) => RONoRaw<T>, ...args: { [X in keyof A]: Expr<A[X], D, C>; }) => Expr<T, D, C>;
+type AddO<T> = T extends notObj ? T : T extends Array<infer U> ? Arr<AddO<U>> : O<T>;
+declare const func: <T extends jsonItem, A extends readonly jsonItem[], D, C = unknown>(f: (...args: A) => T, ...args: { [X in keyof A]: Expr<AddO<A[X]>, D, C>; }) => Expr<AddO<T>, D, C>;
 declare const rand: () => string;
 declare const $rand: Expr<string, unknown, unknown>;
 
+type AddOs<A extends readonly unknown[]> = {
+    [K in keyof A]: AddO<A[K]>;
+};
+type PushSides<V> = {
+    0: V[];
+    1: V[];
+};
+type PushDict<V> = PRRec<string, PushSides<V>>;
 declare const $sum: <D extends O, C = unknown>(expr: Expr<number | N, D, C>) => DeltaAccumulator<D, number, C>;
-declare const $accumulator: <D, T, Ctx, A extends readonly unknown[]>(init: () => NoRaw<T>, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, A>, accumulate: (a: NoRaw<T>, ...args: NoRaw<A>) => NoRaw<T>, merge: (...args: NoRaw<[T | N, T]>) => NoRaw<T>) => DeltaAccumulator<D, T, Ctx>;
-declare const $countDict: <D extends O, C = unknown>(expr: Expr<string, D, C>) => DeltaAccumulator<D, Rec<string, number>, C>;
-declare const $countDictArray: <D extends O, C = unknown>(expr: Expr<Arr<string>, D, C>) => DeltaAccumulator<D, Rec<string, number>, C>;
-declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<V, D, C>) => DeltaAccumulator<D, Rec<string, Rec<"0" | "1", Arr<V>>>, C>;
-declare const $keys: <D extends O, C = unknown>(expr: Expr<Rec<string, number>, D, C>) => Expr<Arr<string>, D, C>;
-declare const $entries: <D extends O, V, C = unknown>(expr: Expr<Rec<string, Rec<"1" | "0", Arr<V>>>, D, C>) => Expr<Arr<Rec<"k", string> & Rec<"v", V>>, D, C>;
+declare const $accumulator: <D, T, Ctx, A extends readonly unknown[]>(init: () => T, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, AddOs<A>>, accumulate: (a: T, ...args: A) => T, merge: (...args: [T | N, T]) => T) => DeltaAccumulator<D, AddO<T>, Ctx>;
+declare const $countDict: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<K>, D, C>) => DeltaAccumulator<D, AddO<PRRec<K, number>>, C>;
+declare const $countDictArray: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<K[]>, D, C>) => DeltaAccumulator<D, AddO<PRRec<K, number>>, C>;
+declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<AddO<V>, D, C>) => DeltaAccumulator<D, O<PushDict<V>>, C>;
+declare const $keys: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<PRRec<K, number>>, D, C>) => Expr<AddO<K[]>, D, C>;
+declare const $entries: <D extends O, V, C = unknown>(expr: Expr<AddO<PushDict<V>>, D, C>) => Expr<AddO<{
+    k: string;
+    v: V;
+}[]>, D, C>;
+
+type Equal<Dom, T extends Dom, V extends Dom> = {
+    forward: <F extends HKT<Dom>>(x: App<F, T>) => App<F, V>;
+    forward1: (x: T) => V;
+    backward: <F extends HKT<Dom>>(x: App<F, V>) => App<F, T>;
+    backward1: (x: V) => T;
+};
+declare const sym: <Dom, T extends Dom, V extends Dom>(eq: Equal<Dom, T, V>) => Equal<Dom, V, T>;
+declare const reflex: <Dom, T extends Dom>() => Equal<Dom, T, T>;
+declare const eqExtends: <Im, T, U, F extends HKT<T, Im>, G extends HKT<T, Im>, H extends HKT<T, Im>, M extends Im>(_1: Equal<Im, App<F, T & U>, M | App<G, T & U>>, _2: Equal<Im, App<F, Exclude<T, U>>, M | App<H, Exclude<T, U>>>) => Equal<Im, App<F, T>, T | M extends U ? App<G, T> : App<H, T>>;
+declare const fromEq: <Dom, T extends Dom, V extends Dom>(eq: Pick<Equal<Dom, T, V>, "forward" | "backward">) => Equal<Dom, T, V>;
+declare const literalsEqaul: <T extends keyof any | boolean | N, V extends T>(_: AsLiteral<T> & V) => Equal<T, T, V>;
+declare const omitRORec: <K extends string, E extends string, R extends string, T extends unknown>() => Equal<unknown, RORec<Exclude<K, E | R>, T>, Omit<RORec<Exclude<K, E | R>, T>, R>>;
+type s$2 = keyof any;
+declare const omitPick: <K extends s$2, E extends s$2, R extends s$2, T extends RORec<Exclude<K, E | R>, unknown>>() => Equal<unknown, Pick<T, Exclude<K, E | R>>, Omit<Pick<T, Exclude<K, E | R>>, R>>;
+declare const omitExclude: <K extends s$2, E extends s$2, R extends s$2, T extends RORec<Exclude<K, E | R>, unknown>>() => Equal<unknown, Omit<T, E & Exclude<K, keyof T>>, Omit<Pick<T, Exclude<K, E | R>>, R>>;
+declare const renamedFields: <K extends s$2, F extends HKT<K, s$2>, G extends HKT<App<F, K>>>() => Equal<string | number | symbol, keyof { [P in K as App<F, P>]: App<G, P>; }, App<F, K>>;
+declare const translateOmit: <T, K extends string, Q extends string, P extends string>() => Equal<unknown, Omit<Omit<T, K | Q>, P>, Omit<Omit<T, K | Q>, Q | P>>;
+declare const excludeIdem: <K extends s$2, E extends s$2, S extends E = E>() => Equal<Exclude<K, E>, Exclude<K, E>, Exclude<Exclude<K, E>, S>>;
+declare const eqPar: <K extends string, T extends Rec<K, jsonItem>, K2 extends K>() => Equal<unknown, Par$1<K2, T>, Par$1<K, T>>;
+declare const notExtendExcluded: <Key extends keyof any, Others extends keyof any, Source extends keyof any, Denied extends keyof any, F extends HKT<Others | Exclude<Source, Denied | Key>, Dom>, Else extends Dom, Dom = unknown>() => Equal<Dom, Key extends Others | Exclude<Source, Key | Denied> ? App<F, Key> : Else, Key extends Others ? App<F, Key> : Else>;
 
 type DeltaPipe<Q extends O, T extends Q, F extends HKT<O2>, G extends HKT<O3>> = {
     with: <Q2 extends O, V extends Q2>(map: (a: Stream<Q, T, F, G>) => Stream<Q | Q2, V, F, G>) => DeltaPipe<Q | Q2, V, F, G>;
@@ -543,9 +599,7 @@ declare const createIndex: (collection: {
 }, indexSpec: IndexSpecification, op?: CreateIndexesOptions) => Promise<void>;
 
 declare const noop: () => void;
-declare const map1: <K extends string, Im>(k: AsLiteral<K>, to: Im) => { readonly [P in K]: [P, Im]; } & {
-    readonly [_: string]: [K, Im];
-};
+declare const map1: <K extends string, Im>(k: AsLiteral<K>, to: Im) => MapO<RORec<K, Im>, ConstHKT<Im>, K>;
 
 declare const $group_: <V extends O>() => <ID, T extends O, C = unknown>(id: Expr<ID, T, C>, args: Accumulators<T, V, C>) => RawStages<O, T, Rec<"_id", ID> & V, C, 1>;
 
@@ -737,5 +791,5 @@ declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Pr
 declare const prepare: (testName?: string) => Promise<MongoClient$1>;
 declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;
 
-export { $accumulator, $and, $countDict, $countDictArray, $entries, $eq, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $substr, $sum, $type, $unwind, $unwindDelta, Expr, Field, Machine, Type, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, emptyDelta, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, log, lt, lte, makeCol, map1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, or, padLeft, pair, prepare, rand, range, regex, root, set, setField, single, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
-export type { Accumulators, Arr, AsLiteral, Delta, DeltaAccumulator, DeltaAccumulators, DeltaStages, ExactKeys, ExprHKT, Exprs, ExprsExact, ExprsExactHKT, ExprsPart, ID, JoinId, Loose, Merge, MergeArgs, MergeInto, MergeMapOArgs, Model, MongoTypeNames, N, NoRaw, NullToOBJ, O, OPick, OPickD, Patch, RONoRaw, RORec, RawStages, Rec, Replace, SnapshotStreamExecutionResult, StrKey, Strict, TS, WriteonlyCollection, doc, jsonPrim, notArr };
+export { $accumulator, $and, $countDict, $countDictArray, $entries, $eq, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $substr, $sum, $type, $unwind, $unwindDelta, Expr, Field, Machine, Type, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, emptyDelta, enablePreAndPostImages, eq, eqExtends, eqPar, eqTyped, except, excludeIdem, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, fromEq, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, literalsEqaul, log, lt, lte, makeCol, map, map1, mapExact, mapExact0, mapExact1, mapExactToObject, mapExactToObject0, mapExactToObject1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notExtendExcluded, notNull, now, omitExclude, omitPick, omitRORec, or, padLeft, pair, prepare, rand, range, reflex, regex, renamedFields, root, set, setField, single, size, slice, sortArray, spread, spread0, staging, startOf, str, sub, subtract, sym, to, toInt, translateOmit, val, weekPart, wrap, year };
+export type { Accumulators, AddO, Arr, AsLiteral, Delta, DeltaAccumulator, DeltaAccumulators, DeltaStages, Equal, Exact, ExactKeys, ExactPart, ExactPart1, ExprHKT, Exprs, ExprsExact, ExprsExactHKT, ExprsPart, ID, JoinId, Loose, MapK, MapKDom, MapKPart1, MapO, MapOPart, MappedHKT, Merge, MergeArgs, MergeHKT, MergeInto, MergeMapOArgs, Model, MongoTypeNames, N, NullToOBJ, O, OPick, OPickD, Patch, RORec, RawStages, Rec, Replace, SnapshotStreamExecutionResult, StrKey, Strict, TS, WithKey1, WriteonlyCollection, doc, jsonPrim, notArr };

package/index.esm.js

@@ -76,7 +76,8 @@ const spread = (a, b) => ({ ...a, ...mapExact(b, id$1) });
 const spread0 = (a, b) => ({ ...a, ...mapExact0(b, id$1) });
 
 const val = (val) => asExpr({
-    raw: () => asExprRaw((val && typeof val === 'object' && !(val instanceof Date)) || (typeof val === 'string' && val[0] === '$')
+    raw: () => asExprRaw((val && typeof val === 'object' && !(val instanceof Date)) ||
+        (typeof val === 'string' && val[0] === '$')
         ? { $literal: val }
         : val),
 });
@@ -408,17 +409,35 @@ const fieldF = () => (exprs) => Object.keys(exprs).length
     : val({});
 const field = fieldF();
 
-const id = (x) => x;
-const assertEqual = () => ({
-    forward: id,
+const sym = (eq) => ({
+    backward: eq.forward,
+    forward: eq.backward,
+    backward1: eq.forward1,
+    forward1: eq.backward1,
+});
+const reflex = () => ({
     backward: id,
-    forward1: id,
+    forward: id,
     backward1: id,
+    forward1: id,
+});
+const id = (x) => x;
+const assertEqual = () => reflex();
+const eqExtends = (_1, _2) => assertEqual();
+const fromEq = (eq) => ({
+    ...eq,
+    backward1: (eq.backward),
+    forward1: (eq.forward),
 });
 const literalsEqaul = (_) => assertEqual();
 const omitRORec = () => assertEqual();
 const omitPick = () => assertEqual();
+const omitExclude = () => assertEqual();
+const renamedFields = () => assertEqual();
 const translateOmit = () => assertEqual();
+const excludeIdem = () => assertEqual();
+const eqPar = () => assertEqual();
+const notExtendExcluded = () => assertEqual();
 
 const size = (expr) => asExpr({
     raw: f => asExprRaw({ $size: expr.raw(f).get() }),
@@ -2455,4 +2474,4 @@ const makeCol = async (docs, database, name) => {
     }
 };
 
-export { $accumulator, $and, $countDict, $countDictArray, $entries, $eq, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $substr, $sum, $type, $unwind, $unwindDelta, Field, Machine, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, emptyDelta, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, log, lt, lte, makeCol, map1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, or, padLeft, pair, prepare, rand, range, regex, root, set, setField, single, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
+export { $accumulator, $and, $countDict, $countDictArray, $entries, $eq, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $substr, $sum, $type, $unwind, $unwindDelta, Field, Machine, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, emptyDelta, enablePreAndPostImages, eq, eqExtends, eqPar, eqTyped, except, excludeIdem, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, fromEq, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, literalsEqaul, log, lt, lte, makeCol, map, map1, mapExact, mapExact0, mapExact1, mapExactToObject, mapExactToObject0, mapExactToObject1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notExtendExcluded, notNull, now, omitExclude, omitPick, omitRORec, or, padLeft, pair, prepare, rand, range, reflex, regex, renamedFields, root, set, setField, single, size, slice, sortArray, spread, spread0, staging, startOf, str, sub, subtract, sym, to, toInt, translateOmit, val, weekPart, wrap, year };

package/index.js

@@ -78,7 +78,8 @@ const spread = (a, b) => ({ ...a, ...mapExact(b, id$1) });
 const spread0 = (a, b) => ({ ...a, ...mapExact0(b, id$1) });
 
 const val = (val) => asExpr({
-    raw: () => asExprRaw((val && typeof val === 'object' && !(val instanceof Date)) || (typeof val === 'string' && val[0] === '$')
+    raw: () => asExprRaw((val && typeof val === 'object' && !(val instanceof Date)) ||
+        (typeof val === 'string' && val[0] === '$')
         ? { $literal: val }
         : val),
 });
@@ -410,17 +411,35 @@ const fieldF = () => (exprs) => Object.keys(exprs).length
     : val({});
 const field = fieldF();
 
-const id = (x) => x;
-const assertEqual = () => ({
-    forward: id,
+const sym = (eq) => ({
+    backward: eq.forward,
+    forward: eq.backward,
+    backward1: eq.forward1,
+    forward1: eq.backward1,
+});
+const reflex = () => ({
     backward: id,
-    forward1: id,
+    forward: id,
     backward1: id,
+    forward1: id,
+});
+const id = (x) => x;
+const assertEqual = () => reflex();
+const eqExtends = (_1, _2) => assertEqual();
+const fromEq = (eq) => ({
+    ...eq,
+    backward1: (eq.backward),
+    forward1: (eq.forward),
 });
 const literalsEqaul = (_) => assertEqual();
 const omitRORec = () => assertEqual();
 const omitPick = () => assertEqual();
+const omitExclude = () => assertEqual();
+const renamedFields = () => assertEqual();
 const translateOmit = () => assertEqual();
+const excludeIdem = () => assertEqual();
+const eqPar = () => assertEqual();
+const notExtendExcluded = () => assertEqual();
 
 const size = (expr) => asExpr({
     raw: f => asExprRaw({ $size: expr.raw(f).get() }),
@@ -2534,8 +2553,11 @@ exports.divide = divide;
 exports.emptyDelta = emptyDelta;
 exports.enablePreAndPostImages = enablePreAndPostImages;
 exports.eq = eq;
+exports.eqExtends = eqExtends;
+exports.eqPar = eqPar;
 exports.eqTyped = eqTyped;
 exports.except = except;
+exports.excludeIdem = excludeIdem;
 exports.exprMapVal = exprMapVal;
 exports.field = field;
 exports.fieldF = fieldF;
@@ -2546,6 +2568,7 @@ exports.first = first$1;
 exports.firstSure = firstSure;
 exports.floor = floor;
 exports.from = from;
+exports.fromEq = fromEq;
 exports.func = func;
 exports.getWhenMatched = getWhenMatched;
 exports.getWhenMatchedForMerge = getWhenMatchedForMerge;
@@ -2556,11 +2579,19 @@ exports.isArray = isArray;
 exports.ite = ite;
 exports.joinIdOf = joinIdOf;
 exports.last = last;
+exports.literalsEqaul = literalsEqaul;
 exports.log = log;
 exports.lt = lt;
 exports.lte = lte;
 exports.makeCol = makeCol;
+exports.map = map;
 exports.map1 = map1;
+exports.mapExact = mapExact;
+exports.mapExact0 = mapExact0;
+exports.mapExact1 = mapExact1;
+exports.mapExactToObject = mapExactToObject;
+exports.mapExactToObject0 = mapExactToObject0;
+exports.mapExactToObject1 = mapExactToObject1;
 exports.mapFromPlainDateTime = mapFromPlainDateTime;
 exports.mapToPlainDateTime = mapToPlainDateTime;
 exports.mapVal = mapVal;
@@ -2578,15 +2609,21 @@ exports.ne = ne;
 exports.nil = nil;
 exports.noop = noop;
 exports.not = not;
+exports.notExtendExcluded = notExtendExcluded;
 exports.notNull = notNull;
 exports.now = now;
+exports.omitExclude = omitExclude;
+exports.omitPick = omitPick;
+exports.omitRORec = omitRORec;
 exports.or = or;
 exports.padLeft = padLeft;
 exports.pair = pair;
 exports.prepare = prepare;
 exports.rand = rand;
 exports.range = range;
+exports.reflex = reflex;
 exports.regex = regex;
+exports.renamedFields = renamedFields;
 exports.root = root;
 exports.set = set;
 exports.setField = setField;
@@ -2594,13 +2631,17 @@ exports.single = single;
 exports.size = size;
 exports.slice = slice;
 exports.sortArray = sortArray;
+exports.spread = spread;
+exports.spread0 = spread0;
 exports.staging = staging;
 exports.startOf = startOf;
 exports.str = str;
 exports.sub = sub;
 exports.subtract = subtract;
+exports.sym = sym;
 exports.to = to;
 exports.toInt = toInt;
+exports.translateOmit = translateOmit;
 exports.val = val;
 exports.weekPart = weekPart;
 exports.wrap = wrap;

package/package.json

@@ -3,7 +3,7 @@
     "module": "index.esm.js",
     "typings": "index.d.ts",
     "name": "@omegup/msync",
-    "version": "0.1.48",
+    "version": "0.1.50",
     "dependencies": {
         "dayjs": "^1.11.9",
         "dotenv": "^16.3.1",