@omegup/msync 0.0.1 → 0.0.2

package/index.d.ts

@@ -1,4 +1,4 @@
-import { Timestamp, BSON, Db, Collection, MongoClient as MongoClient$1 } from 'mongodb';
+import { Timestamp, BSON, Db, Collection, IndexSpecification, CreateIndexesOptions, MongoClient as MongoClient$1 } from 'mongodb';
 export { Collection, Timestamp } from 'mongodb';
 import * as bson from 'bson';
 
@@ -135,6 +135,7 @@ type BoolExpr<in D1, in D2, in Ctx = unknown> = {
     };
 };
 
+type ExactPart<T, F extends HKT<T[StrKey<T>]>> = MapOPart<T, MappedHKT<T, F>>;
 type ExactKeys<K extends string> = Exact<RORec<K, 1>, IdHKT>;
 type MapO<T, F extends HKT<StrKey<T>>> = MapOPart<T, F> & {
     readonly [P: string]: readonly [StrKey<T>, unknown];
@@ -146,6 +147,9 @@ 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>]>;
 }
+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 AccumulatorRaw: unique symbol;
 interface AccumulatorRaw<in Doc, out T, in C = unknown> extends RawObj {
@@ -172,10 +176,28 @@ type DeltaAccumulator<in out Doc, in out T, in out Ctx = unknown> = {
     merge: <D, C = Ctx>(a: Expr<T | N, D, C>, b: Expr<T, D, C>) => Expr<T, D, C>;
 };
 
+declare const concat: <D, C>(...expr: Expr<string, D, C>[]) => Expr<string, D, C>;
+declare const str: <D, C>(expr: Expr<unknown, D, C>) => Expr<string, D, C>;
+declare const toInt: <D, C>(expr: Expr<unknown, D, C>) => Expr<number, D, C>;
+declare const fieldM: <M extends RORec<Dom, Ref>, T extends RORec<Ref, unknown>, D, Dom extends string = StrKey<M>, Ref extends string = StrKey<T>, C = unknown>(expr: { readonly [K in Ref]: Expr<T[K], D, C>; }, m: Pick<M, Dom>) => Expr<O<{ readonly [K in Dom]: T[M[K]]; }>, D, C>;
+type Exprs<out T, in D, in C = unknown> = {
+    readonly [K in StrKey<T>]: Expr<T[K], D, C>;
+};
+declare const mergeExact: <T1, T2, F extends HKT<T1[StrKey<T1>] | T2[StrKey<T2>]>, E = unknown>(exprsExact1: Exact<Omit<T1, keyof T2>, F>, exprsExact2: Exact<T2, F>) => Exact<T2 & Omit<T1, keyof T2> & Pick<E, symbol & keyof E>, F>;
+type MergeMapOArgs<T1, T2, F1 extends HKT<StrKey<Omit<T1, StrKey<T2>>>>, F2 extends HKT<StrKey<T2>>> = readonly [MapO<Omit<T1, StrKey<T2>>, F1>, MapO<T2, F2>];
+declare const mergeExact0: <T1, T2, F1 extends HKT<StrKey<Omit<T1, StrKey<T2>>>>, F2 extends HKT<StrKey<T2>>, E = unknown>(exprsExact1: MapO<Omit<T1, StrKey<T2>>, F1>, exprsExact2: MapO<T2, F2>) => MapO<T2 & Omit<T1, StrKey<T2>> & Pick<E, symbol & keyof E>, MergeHKT<T1, T2, F1, F2, StrKey<T2>>>;
+declare const mergeExpr: <T1, T2, D, C = unknown, E = unknown>(exprs_0: Exact<Omit<T1, keyof T2>, ExprHKT<D, C, IdHKT<unknown>>>, exprs_1: Exact<T2, ExprHKT<D, C, IdHKT<unknown>>>) => ExprsExact<T2 & Omit<T1, keyof T2> & Pick<E, symbol & keyof E>, D, C>;
+type ExprsPart<T, D, C> = ExactPart<T, ExprHKT<D, C>>;
 interface ExprHKT<D, C = unknown, F extends HKT = IdHKT> extends HKT<unknown> {
     readonly out: Expr<App<F, I<unknown, this>>, D, C>;
 }
 type ExprsExact<T, D, C = unknown, F extends HKT = IdHKT> = Exact<T, ExprHKT<D, C, F>>;
+interface ExprsExactHKT<E, D, C = unknown, F extends HKT = IdHKT> extends HKT {
+    readonly out: ExprsExact<E & I<unknown, this>, D, C, F>;
+}
+declare const pair: <T, D, C, P extends StrKey<T>>(k: P, v: Expr<T[P], D, C>) => ExprsExact<T, D, C>[P];
+declare const fieldF: <F extends HKT>() => <T extends object, D, C = unknown>(exprs: ExprsExact<T, D, C, F>) => Expr<O<{ [K in keyof T]: App<F, T[K]>; }>, D, C>;
+declare const field: <T extends object, D, C = unknown>(exprs: ExprsExact<T, D, C>) => Expr<O<T>, D, C>;
 
 declare const Type: unique symbol;
 
@@ -432,6 +454,8 @@ interface UpdaterHKT<R, Old, V, C, K extends keyof Old = keyof Old, V2 extends V
     readonly out: Updater<R, Get<Old, I<StrKey<V>, this>, K>, V2[I<StrKey<V>, this>], C>;
 }
 type Get<T, P extends string, K extends keyof T = never> = P extends K ? T[P] : P extends keyof T ? T[P] : undefined;
+declare const set: <V>() => <R, Old extends notArr, C = unknown, K extends keyof Old = never>(fields: MapO<V, UpdaterHKT<R, Old, V, C, K>>) => Updater<R, Old, O & Omit<Old, StrKey<V>> & V, C> & Updater<R, Arr<Old>, Arr<Omit<Old, StrKey<V>> & V>, C>;
+declare const to: <R, V, C = unknown, T = unknown>(expr: Expr<V, R, C>) => Updater<R, T, V, C>;
 
 declare const $set: <V extends O>() => <R extends O, C = unknown>(fields: MapO<V, UpdaterHKT<R, R, V, C>>) => DeltaStages<O, R, Replace<R, V>, C> & LinStages<O, R, Replace<R, V>, C>;
 declare const $replaceWith: <T extends O, V extends O>(expr: Expr<V, T>) => DeltaStages<O, T, V> & LinStages<O, T, V>;
@@ -518,7 +542,7 @@ declare const sortArray: <T, D, C, K extends keyof T>({ sortBy, expr, order, }:
 }) => Expr<Arr<T>, D, C>;
 declare const isArray: <T extends notArr, D, C, F extends HKT<T | Arr<T>>>(expr: Expr<T | Arr<T>, D & (App<F, T> | App<F, Arr<T>>), C>) => BoolExpr<D & App<F, Arr<T>>, D & App<F, T>, C>;
 declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
-declare const concat: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
+declare const concatArray: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
 declare const first: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
 declare const firstSure: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T, D, C>;
 declare const last: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
@@ -599,7 +623,18 @@ declare const $and: Combiner;
 declare const $nor: Combiner;
 declare const $or: Combiner;
 
+declare const log: (...args: unknown[]) => void;
+
+declare const createIndex: (collection: {
+    readonly createIndex: Collection["createIndex"];
+}, indexSpec: IndexSpecification, options?: 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 enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Promise<bson.Document>;
 declare const prepare: (testName?: string) => Promise<MongoClient$1>;
 
-export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $sum, $unwind, $unwindDelta, $upsert, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, Expr, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type Model, type N, type NoRaw, type O, type OPick, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, array, ceil, comp, concat, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, filter, filterDefined, first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, lt, lte, mapVal, max, maxDate, mergeObjects, minDate, monthPart, multiply, ne, nil, type notArr, notNull, now, prepare, rand, range, root, setField, size, slice, sortArray, staging, startOf, sub, subtract, val, wrap };
+export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $sum, $unwind, $unwindDelta, $upsert, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, Expr, type ExprHKT, type Exprs, type ExprsExact, type ExprsExactHKT, type ExprsPart, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type MergeMapOArgs, type Model, type N, type NoRaw, type O, type OPick, type OPickD, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, type notArr, notNull, now, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, wrap };

package/index.esm.js

@@ -54,6 +54,7 @@ function ceil(expr) {
 
 const id$1 = (x) => x;
 const defined = (x) => x != null;
+const noop = () => { };
 const map1 = (k, to) => {
     const k2 = k;
     return { [k]: [k2, to] };
@@ -71,6 +72,7 @@ const mapExact1 = (x, f) => mapExactToObject1(x, (v, k) => [k, f(v, k)]);
 const mapExactToObject = (x, f) => mapExactToObject0(x, f);
 const mapExact = (x, f) => mapExactToObject(x, (v, k) => [k, f(v, k)]);
 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') || (typeof val === 'string' && val[0] === '$')
@@ -285,9 +287,15 @@ const $entries = (expr) => func(function (obj) {
     return Object.entries({ ...obj }).flatMap(([k, v]) => v[0].map(v => ({ k, v })));
 }, expr);
 
-const concat$2 = (...expr) => asExpr({
+const concat$1 = (...expr) => asExpr({
     raw: f => asExprRaw({ $concat: expr.map(e => e.raw(f).get()) }),
 });
+const str = (expr) => asExpr({
+    raw: f => asExprRaw({ $toString: expr.raw(f).get() }),
+});
+const toInt = (expr) => asExpr({
+    raw: f => asExprRaw({ $toInt: expr.raw(f).get() }),
+});
 const fieldM = (expr, m) => asExpr({
     raw: (f) => asExprRaw(Object.fromEntries(Object.entries(m).map(([dom, ref]) => [
         dom,
@@ -295,7 +303,10 @@ const fieldM = (expr, m) => asExpr({
     ]))),
 });
 const mergeExact = (...[exprsExact1, exprsExact2]) => spread(exprsExact1, exprsExact2);
+const mergeExact0 = (...[exprsExact1, exprsExact2]) => spread0(exprsExact1, exprsExact2);
 const mergeExpr = (...exprs) => mergeExact(...exprs);
+const asIntersect = (x) => x;
+const pair = (k, v) => asIntersect([k, v]);
 const fieldF = () => (exprs) => Object.keys(exprs).length
     ? asExpr({
         raw: f => asExprRaw(mapExactToObject(exprs, e => e.raw(f).get())),
@@ -327,12 +338,12 @@ const pipe = (stream, s, concat, empty) => {
     };
     return acc;
 };
-const concat$1 = (stages) => ({
-    with: extra => concat$1(concatStages(stages, extra)),
+const concat = (stages) => ({
+    with: extra => concat(concatStages(stages, extra)),
     stages,
 });
 const link = () => ({
-    with: extra => concat$1(extra),
+    with: extra => concat(extra),
     stages: asStages([]),
 });
 const emptyDelta = () => ({
@@ -368,7 +379,7 @@ const isArray = (expr) => asBoolExpr({
 const array = (...exprs) => asExpr({
     raw: f => asExprRaw(exprs.map(x => x.raw(f).get())),
 });
-const concat = (...exprs) => asExpr({
+const concatArray = (...exprs) => asExpr({
     raw: f => asExprRaw({ $concatArrays: exprs.map(x => x.raw(f).get()) }),
 });
 const first$1 = (expr) => asExpr({
@@ -418,10 +429,10 @@ const except = (a, b) => {
                 out: ['out', out],
                 except: [
                     'except',
-                    concat(ite(eq(indexInExcept)(val(0)), array(), slice(except, val(0), indexInExcept)), slice(except, add(indexInExcept, val(1)), size(except))),
+                    concatArray(ite(eq(indexInExcept)(val(0)), array(), slice(except, val(0), indexInExcept)), slice(except, add(indexInExcept, val(1)), size(except))),
                 ],
             }), field({
-                out: ['out', concat(out, array(curr))],
+                out: ['out', concatArray(out, array(curr))],
                 except: ['except', except],
             })))),
         ],
@@ -541,7 +552,7 @@ const subMerge = (args, out, gid, extra, idPrefix) => {
     const gidPath = root().of(gid).expr();
     const mapId = (k, v) => map1(k, v);
     const F1 = {
-        _id: ['_id', to(idPrefix ? concat$2(val(idPrefix), $rand) : $rand)],
+        _id: ['_id', to(idPrefix ? concat$1(val(idPrefix), $rand) : $rand)],
         touchedAt: ['touchedAt', to(current)],
     };
     const F2 = mapId(gid, to(gidPath));
@@ -1580,4 +1591,4 @@ const prepare = async (testName) => {
     return client;
 };
 
-export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $sum, $unwind, $unwindDelta, $upsert, Field, Machine, add, and, array, ceil, comp, concat, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, filter, filterDefined, first$1 as first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, lt, lte, mapVal, max, maxDate, mergeObjects, minDate, monthPart, multiply, ne, nil, notNull, now, prepare, rand, range, root, setField, size, slice, sortArray, staging, startOf, sub, subtract, val, wrap };
+export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $sum, $unwind, $unwindDelta, $upsert, Field, Machine, add, and, array, ceil, comp, concat$1 as concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, notNull, now, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, wrap };

package/index.js

@@ -56,6 +56,7 @@ function ceil(expr) {
 
 const id$1 = (x) => x;
 const defined = (x) => x != null;
+const noop = () => { };
 const map1 = (k, to) => {
     const k2 = k;
     return { [k]: [k2, to] };
@@ -73,6 +74,7 @@ const mapExact1 = (x, f) => mapExactToObject1(x, (v, k) => [k, f(v, k)]);
 const mapExactToObject = (x, f) => mapExactToObject0(x, f);
 const mapExact = (x, f) => mapExactToObject(x, (v, k) => [k, f(v, k)]);
 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') || (typeof val === 'string' && val[0] === '$')
@@ -287,9 +289,15 @@ const $entries = (expr) => func(function (obj) {
     return Object.entries({ ...obj }).flatMap(([k, v]) => v[0].map(v => ({ k, v })));
 }, expr);
 
-const concat$2 = (...expr) => asExpr({
+const concat$1 = (...expr) => asExpr({
     raw: f => asExprRaw({ $concat: expr.map(e => e.raw(f).get()) }),
 });
+const str = (expr) => asExpr({
+    raw: f => asExprRaw({ $toString: expr.raw(f).get() }),
+});
+const toInt = (expr) => asExpr({
+    raw: f => asExprRaw({ $toInt: expr.raw(f).get() }),
+});
 const fieldM = (expr, m) => asExpr({
     raw: (f) => asExprRaw(Object.fromEntries(Object.entries(m).map(([dom, ref]) => [
         dom,
@@ -297,7 +305,10 @@ const fieldM = (expr, m) => asExpr({
     ]))),
 });
 const mergeExact = (...[exprsExact1, exprsExact2]) => spread(exprsExact1, exprsExact2);
+const mergeExact0 = (...[exprsExact1, exprsExact2]) => spread0(exprsExact1, exprsExact2);
 const mergeExpr = (...exprs) => mergeExact(...exprs);
+const asIntersect = (x) => x;
+const pair = (k, v) => asIntersect([k, v]);
 const fieldF = () => (exprs) => Object.keys(exprs).length
     ? asExpr({
         raw: f => asExprRaw(mapExactToObject(exprs, e => e.raw(f).get())),
@@ -329,12 +340,12 @@ const pipe = (stream, s, concat, empty) => {
     };
     return acc;
 };
-const concat$1 = (stages) => ({
-    with: extra => concat$1(concatStages(stages, extra)),
+const concat = (stages) => ({
+    with: extra => concat(concatStages(stages, extra)),
     stages,
 });
 const link = () => ({
-    with: extra => concat$1(extra),
+    with: extra => concat(extra),
     stages: asStages([]),
 });
 const emptyDelta = () => ({
@@ -370,7 +381,7 @@ const isArray = (expr) => asBoolExpr({
 const array = (...exprs) => asExpr({
     raw: f => asExprRaw(exprs.map(x => x.raw(f).get())),
 });
-const concat = (...exprs) => asExpr({
+const concatArray = (...exprs) => asExpr({
     raw: f => asExprRaw({ $concatArrays: exprs.map(x => x.raw(f).get()) }),
 });
 const first$1 = (expr) => asExpr({
@@ -420,10 +431,10 @@ const except = (a, b) => {
                 out: ['out', out],
                 except: [
                     'except',
-                    concat(ite(eq(indexInExcept)(val(0)), array(), slice(except, val(0), indexInExcept)), slice(except, add(indexInExcept, val(1)), size(except))),
+                    concatArray(ite(eq(indexInExcept)(val(0)), array(), slice(except, val(0), indexInExcept)), slice(except, add(indexInExcept, val(1)), size(except))),
                 ],
             }), field({
-                out: ['out', concat(out, array(curr))],
+                out: ['out', concatArray(out, array(curr))],
                 except: ['except', except],
             })))),
         ],
@@ -543,7 +554,7 @@ const subMerge = (args, out, gid, extra, idPrefix) => {
     const gidPath = root().of(gid).expr();
     const mapId = (k, v) => map1(k, v);
     const F1 = {
-        _id: ['_id', to(idPrefix ? concat$2(val(idPrefix), $rand) : $rand)],
+        _id: ['_id', to(idPrefix ? concat$1(val(idPrefix), $rand) : $rand)],
         touchedAt: ['touchedAt', to(current)],
     };
     const F2 = mapId(gid, to(gidPath));
@@ -1628,7 +1639,9 @@ exports.and = and;
 exports.array = array;
 exports.ceil = ceil;
 exports.comp = comp;
-exports.concat = concat;
+exports.concat = concat$1;
+exports.concatArray = concatArray;
+exports.createIndex = createIndex;
 exports.ctx = ctx;
 exports.current = current;
 exports.dateAdd = dateAdd;
@@ -1642,6 +1655,9 @@ exports.eq = eq;
 exports.eqTyped = eqTyped;
 exports.except = except;
 exports.exprMapVal = exprMapVal;
+exports.field = field;
+exports.fieldF = fieldF;
+exports.fieldM = fieldM;
 exports.filter = filter;
 exports.filterDefined = filterDefined;
 exports.first = first$1;
@@ -1655,30 +1671,41 @@ exports.inArray = inArray;
 exports.isArray = isArray;
 exports.ite = ite;
 exports.last = last;
+exports.log = log;
 exports.lt = lt;
 exports.lte = lte;
+exports.map1 = map1;
 exports.mapVal = mapVal;
 exports.max = max;
 exports.maxDate = maxDate;
+exports.mergeExact = mergeExact;
+exports.mergeExact0 = mergeExact0;
+exports.mergeExpr = mergeExpr;
 exports.mergeObjects = mergeObjects;
 exports.minDate = minDate;
 exports.monthPart = monthPart;
 exports.multiply = multiply;
 exports.ne = ne;
 exports.nil = nil;
+exports.noop = noop;
 exports.notNull = notNull;
 exports.now = now;
+exports.pair = pair;
 exports.prepare = prepare;
 exports.rand = rand;
 exports.range = range;
 exports.root = root;
+exports.set = set;
 exports.setField = setField;
 exports.size = size;
 exports.slice = slice;
 exports.sortArray = sortArray;
 exports.staging = staging;
 exports.startOf = startOf;
+exports.str = str;
 exports.sub = sub;
 exports.subtract = subtract;
+exports.to = to;
+exports.toInt = toInt;
 exports.val = val;
 exports.wrap = wrap;

package/package.json

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