Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

jet-miniapp

Package Overview
Dependencies
Maintainers
1
Versions
10
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

jet-miniapp - npm Package Compare versions

Comparing version 1.0.0 to 2.0.0

dist/my.d.ts
dist/my.js

24

dist/basic.js

@@ -58,10 +58,18 @@ "use strict";

let context = {};
//@ts-ignore
const _setContext = workbench && workbench.jetProxy && workbench.jetProxy.setContext;
//@ts-ignore
const _getContext = workbench && workbench.jetProxy && workbench.jetProxy.getContext;
//@ts-ignore
const _delContext = workbench && workbench.jetProxy && workbench.jetProxy.delContext;
//@ts-ignore
const _clearContext = workbench && workbench.jetProxy && workbench.jetProxy.clearContext;
let _setContext;
let _getContext;
let _delContext;
let _clearContext;
try {
//@ts-ignore
_setContext = workbench && workbench.jetProxy && workbench.jetProxy.setContext;
//@ts-ignore
_getContext = workbench && workbench.jetProxy && workbench.jetProxy.getContext;
//@ts-ignore
_delContext = workbench && workbench.jetProxy && workbench.jetProxy.delContext;
//@ts-ignore
_clearContext = workbench && workbench.jetProxy && workbench.jetProxy.clearContext;
}
catch (e) {
}
exports.SetContext = function (name, value) {

@@ -68,0 +76,0 @@ if (name && value) {

856

dist/index.d.ts

@@ -1,853 +0,5 @@

/// <reference types="_ts-toolbelt@4.10.21@ts-toolbelt" />
export * from './basic';
export * from './eventhub';
import * as R from 'ramda';
export * from './eventhub';
export * from './miniapp';
export * from './basic';
export declare const __: R.Placeholder, F: () => boolean, T: () => boolean, add: {
(a: number, b: number): number;
(a: string, b: string): string;
(a: number): (b: number) => number;
(a: string): (b: string) => string;
}, addIndex: {
<T, U>(fn: (f: (item: T) => U, list: readonly T[]) => U[]): import("Function/Curry").Curry<(a: (item: T, idx: number, list?: T[] | undefined) => U, b: readonly T[]) => U[]>;
<T_1>(fn: (f: (item: T_1) => void, list: readonly T_1[]) => T_1[]): import("Function/Curry").Curry<(a: (item: T_1, idx: number, list?: T_1[] | undefined) => void, b: readonly T_1[]) => T_1[]>;
<T_2, U_1>(fn: (f: (acc: U_1, item: T_2) => U_1, aci: U_1, list: readonly T_2[]) => U_1): import("Function/Curry").Curry<(a: (acc: U_1, item: T_2, idx: number, list?: T_2[] | undefined) => U_1, b: U_1, c: readonly T_2[]) => U_1>;
}, adjust: {
<T>(index: number, fn: (a: T) => T, list: readonly T[]): T[];
<T_1>(index: number, fn: (a: T_1) => T_1): (list: readonly T_1[]) => T_1[];
}, all: {
<T>(fn: (a: T) => boolean, list: readonly T[]): boolean;
<T_1>(fn: (a: T_1) => boolean): (list: readonly T_1[]) => boolean;
}, allPass: (preds: readonly R.Pred[]) => R.Pred, always: <T>(val: T) => () => T, and: {
<T extends string | number | boolean | {
and?: ((...a: readonly any[]) => any) | undefined;
} | null>(fn1: T, val2: any): boolean;
<T_1 extends string | number | boolean | {
and?: ((...a: readonly any[]) => any) | undefined;
} | null>(fn1: T_1): (val2: any) => boolean;
}, any: {
<T>(fn: (a: T) => boolean, list: readonly T[]): boolean;
<T_1>(fn: (a: T_1) => boolean): (list: readonly T_1[]) => boolean;
}, anyPass: <T>(preds: R.SafePred<T>[]) => R.SafePred<T>, ap: {
<T, U>(fns: ((a: T) => U)[], vs: readonly T[]): U[];
<T_1, U_1>(fns: ((a: T_1) => U_1)[]): (vs: readonly T_1[]) => U_1[];
<X0, X1, R>(fn: (x1: X1, x0: X0) => R, fn1: (x1: X1) => X0): (x1: X1) => R;
}, aperture: {
<T>(n: 1, list: readonly T[]): [T][];
<T_1>(n: 2, list: readonly T_1[]): [T_1, T_1][];
<T_2>(n: 3, list: readonly T_2[]): [T_2, T_2, T_2][];
<T_3>(n: 4, list: readonly T_3[]): [T_3, T_3, T_3, T_3][];
<T_4>(n: 5, list: readonly T_4[]): [T_4, T_4, T_4, T_4, T_4][];
<T_5>(n: 6, list: readonly T_5[]): [T_5, T_5, T_5, T_5, T_5, T_5][];
<T_6>(n: 7, list: readonly T_6[]): [T_6, T_6, T_6, T_6, T_6, T_6, T_6][];
<T_7>(n: 8, list: readonly T_7[]): [T_7, T_7, T_7, T_7, T_7, T_7, T_7, T_7][];
<T_8>(n: 9, list: readonly T_8[]): [T_8, T_8, T_8, T_8, T_8, T_8, T_8, T_8, T_8][];
<T_9>(n: 10, list: readonly T_9[]): [T_9, T_9, T_9, T_9, T_9, T_9, T_9, T_9, T_9, T_9][];
<T_10>(n: number, list: readonly T_10[]): T_10[][];
(n: number): <T_11>(list: readonly T_11[]) => T_11[][];
}, append: {
<T>(el: T, list: readonly T[]): T[];
<T_1>(el: T_1): <T_2>(list: readonly T_2[]) => T_2[];
}, apply: {
<T, U, TResult>(fn: (arg0: T, ...args: readonly T[]) => TResult, args: readonly U[]): TResult;
<T_1, TResult_1>(fn: (arg0: T_1, ...args: readonly T_1[]) => TResult_1): <U_1>(args: readonly U_1[]) => TResult_1;
}, applySpec: {
<Obj extends Record<string, (...args: readonly any[]) => any>>(obj: Obj): (...args: Parameters<Tools.ValueOfRecord<Obj>>) => { [Key in keyof Obj]: ReturnType<Obj[Key]>; };
<T>(obj: any): (...args: readonly any[]) => T;
}, applyTo: {
<T, U>(el: T, fn: (t: T) => U): U;
<T_1>(el: T_1): <U_1>(fn: (t: T_1) => U_1) => U_1;
}, ascend: {
<T>(fn: (obj: T) => any, a: T, b: T): number;
<T_1>(fn: (obj: T_1) => any): (a: T_1, b: T_1) => number;
}, assoc: {
<T, U>(__: R.Placeholder, val: T, obj: U): <K extends string>(prop: K) => Record<K, T> & U;
<U_1, K_1 extends string>(prop: K_1, __: R.Placeholder, obj: U_1): <T_1>(val: T_1) => Record<K_1, T_1> & U_1;
<T_2, U_2, K_2 extends string>(prop: K_2, val: T_2, obj: U_2): Record<K_2, T_2> & U_2;
<T_3, K_3 extends string>(prop: K_3, val: T_3): <U_3>(obj: U_3) => Record<K_3, T_3> & U_3;
<K_4 extends string>(prop: K_4): R.AssocPartialOne<K_4>;
}, assocPath: {
<T, U>(__: R.Placeholder, val: T, obj: U): (path: R.Path) => U;
<T_1, U_1>(path: R.Path, __: R.Placeholder, obj: U_1): (val: T_1) => U_1;
<T_2, U_2>(path: R.Path, val: T_2, obj: U_2): U_2;
<T_3, U_3>(path: R.Path, val: T_3): (obj: U_3) => U_3;
<T_4, U_4>(path: R.Path): import("Function/Curry").Curry<(a: T_4, b: U_4) => U_4>;
}, binary: (fn: (...args: readonly any[]) => any) => (...a: readonly any[]) => any, bind: <T>(fn: (...args: readonly any[]) => any, thisObj: T) => (...args: readonly any[]) => any, both: {
(pred1: R.Pred, pred2: R.Pred): R.Pred;
(pred1: R.Pred): (pred2: R.Pred) => R.Pred;
}, call: (fn: (...args: readonly any[]) => (...args: readonly any[]) => any, ...args: readonly any[]) => any, chain: {
<T, U>(fn: (n: T) => U[], list: readonly T[]): U[];
<T_1, U_1>(fn: (n: T_1) => U_1[]): (list: readonly T_1[]) => U_1[];
<X0, X1, R>(fn: (x0: X0, x1: X1) => R, fn1: (x1: X1) => X0): (x1: X1) => R;
}, clamp: {
<T>(min: T, max: T, value: T): T;
<T_1>(min: T_1, max: T_1): (value: T_1) => T_1;
<T_2>(min: T_2): (max: T_2, value: T_2) => T_2;
<T_3>(min: T_3): (max: T_3) => (value: T_3) => T_3;
}, clone: {
<T>(value: T): T;
<T_1>(value: readonly T_1[]): T_1[];
}, comparator: <T>(pred: (a: T, b: T) => boolean) => (x: T, y: T) => number, complement: (pred: (...args: readonly any[]) => boolean) => (...args: readonly any[]) => boolean, compose: {
<T1>(fn0: () => T1): () => T1;
<V0, T1_1>(fn0: (x0: V0) => T1_1): (x0: V0) => T1_1;
<V0_1, V1, T1_2>(fn0: (x0: V0_1, x1: V1) => T1_2): (x0: V0_1, x1: V1) => T1_2;
<V0_2, V1_1, V2, T1_3>(fn0: (x0: V0_2, x1: V1_1, x2: V2) => T1_3): (x0: V0_2, x1: V1_1, x2: V2) => T1_3;
<T1_4, T2>(fn1: (x: T1_4) => T2, fn0: () => T1_4): () => T2;
<V0_3, T1_5, T2_1>(fn1: (x: T1_5) => T2_1, fn0: (x0: V0_3) => T1_5): (x0: V0_3) => T2_1;
<V0_4, V1_2, T1_6, T2_2>(fn1: (x: T1_6) => T2_2, fn0: (x0: V0_4, x1: V1_2) => T1_6): (x0: V0_4, x1: V1_2) => T2_2;
<V0_5, V1_3, V2_1, T1_7, T2_3>(fn1: (x: T1_7) => T2_3, fn0: (x0: V0_5, x1: V1_3, x2: V2_1) => T1_7): (x0: V0_5, x1: V1_3, x2: V2_1) => T2_3;
<T1_8, T2_4, T3>(fn2: (x: T2_4) => T3, fn1: (x: T1_8) => T2_4, fn0: () => T1_8): () => T3;
<V0_6, T1_9, T2_5, T3_1>(fn2: (x: T2_5) => T3_1, fn1: (x: T1_9) => T2_5, fn0: (x: V0_6) => T1_9): (x: V0_6) => T3_1;
<V0_7, V1_4, T1_10, T2_6, T3_2>(fn2: (x: T2_6) => T3_2, fn1: (x: T1_10) => T2_6, fn0: (x0: V0_7, x1: V1_4) => T1_10): (x0: V0_7, x1: V1_4) => T3_2;
<V0_8, V1_5, V2_2, T1_11, T2_7, T3_3>(fn2: (x: T2_7) => T3_3, fn1: (x: T1_11) => T2_7, fn0: (x0: V0_8, x1: V1_5, x2: V2_2) => T1_11): (x0: V0_8, x1: V1_5, x2: V2_2) => T3_3;
<T1_12, T2_8, T3_4, T4>(fn3: (x: T3_4) => T4, fn2: (x: T2_8) => T3_4, fn1: (x: T1_12) => T2_8, fn0: () => T1_12): () => T4;
<V0_9, T1_13, T2_9, T3_5, T4_1>(fn3: (x: T3_5) => T4_1, fn2: (x: T2_9) => T3_5, fn1: (x: T1_13) => T2_9, fn0: (x: V0_9) => T1_13): (x: V0_9) => T4_1;
<V0_10, V1_6, T1_14, T2_10, T3_6, T4_2>(fn3: (x: T3_6) => T4_2, fn2: (x: T2_10) => T3_6, fn1: (x: T1_14) => T2_10, fn0: (x0: V0_10, x1: V1_6) => T1_14): (x0: V0_10, x1: V1_6) => T4_2;
<V0_11, V1_7, V2_3, T1_15, T2_11, T3_7, T4_3>(fn3: (x: T3_7) => T4_3, fn2: (x: T2_11) => T3_7, fn1: (x: T1_15) => T2_11, fn0: (x0: V0_11, x1: V1_7, x2: V2_3) => T1_15): (x0: V0_11, x1: V1_7, x2: V2_3) => T4_3;
<T1_16, T2_12, T3_8, T4_4, T5>(fn4: (x: T4_4) => T5, fn3: (x: T3_8) => T4_4, fn2: (x: T2_12) => T3_8, fn1: (x: T1_16) => T2_12, fn0: () => T1_16): () => T5;
<V0_12, T1_17, T2_13, T3_9, T4_5, T5_1>(fn4: (x: T4_5) => T5_1, fn3: (x: T3_9) => T4_5, fn2: (x: T2_13) => T3_9, fn1: (x: T1_17) => T2_13, fn0: (x: V0_12) => T1_17): (x: V0_12) => T5_1;
<V0_13, V1_8, T1_18, T2_14, T3_10, T4_6, T5_2>(fn4: (x: T4_6) => T5_2, fn3: (x: T3_10) => T4_6, fn2: (x: T2_14) => T3_10, fn1: (x: T1_18) => T2_14, fn0: (x0: V0_13, x1: V1_8) => T1_18): (x0: V0_13, x1: V1_8) => T5_2;
<V0_14, V1_9, V2_4, T1_19, T2_15, T3_11, T4_7, T5_3>(fn4: (x: T4_7) => T5_3, fn3: (x: T3_11) => T4_7, fn2: (x: T2_15) => T3_11, fn1: (x: T1_19) => T2_15, fn0: (x0: V0_14, x1: V1_9, x2: V2_4) => T1_19): (x0: V0_14, x1: V1_9, x2: V2_4) => T5_3;
<T1_20, T2_16, T3_12, T4_8, T5_4, T6>(fn5: (x: T5_4) => T6, fn4: (x: T4_8) => T5_4, fn3: (x: T3_12) => T4_8, fn2: (x: T2_16) => T3_12, fn1: (x: T1_20) => T2_16, fn0: () => T1_20): () => T6;
<V0_15, T1_21, T2_17, T3_13, T4_9, T5_5, T6_1>(fn5: (x: T5_5) => T6_1, fn4: (x: T4_9) => T5_5, fn3: (x: T3_13) => T4_9, fn2: (x: T2_17) => T3_13, fn1: (x: T1_21) => T2_17, fn0: (x: V0_15) => T1_21): (x: V0_15) => T6_1;
<V0_16, V1_10, T1_22, T2_18, T3_14, T4_10, T5_6, T6_2>(fn5: (x: T5_6) => T6_2, fn4: (x: T4_10) => T5_6, fn3: (x: T3_14) => T4_10, fn2: (x: T2_18) => T3_14, fn1: (x: T1_22) => T2_18, fn0: (x0: V0_16, x1: V1_10) => T1_22): (x0: V0_16, x1: V1_10) => T6_2;
<V0_17, V1_11, V2_5, T1_23, T2_19, T3_15, T4_11, T5_7, T6_3>(fn5: (x: T5_7) => T6_3, fn4: (x: T4_11) => T5_7, fn3: (x: T3_15) => T4_11, fn2: (x: T2_19) => T3_15, fn1: (x: T1_23) => T2_19, fn0: (x0: V0_17, x1: V1_11, x2: V2_5) => T1_23): (x0: V0_17, x1: V1_11, x2: V2_5) => T6_3;
}, composeWith: {
<V0, T>(composer: (a: any) => any, fns: R.ComposeWithFns<V0, T>): (x0: V0) => T;
(composer: (a: any) => any): <V0_1, T_1>(fns: R.ComposeWithFns<V0_1, T_1>) => (x: V0_1) => T_1;
}, concat: {
<T>(placeholder: R.Placeholder): (list2: readonly T[], list1: readonly T[]) => T[];
<T_1>(placeholder: R.Placeholder, list2: readonly T_1[]): (list1: readonly T_1[]) => T_1[];
<T_2>(list1: readonly T_2[], list2: readonly T_2[]): T_2[];
<T_3>(list1: readonly T_3[]): (list2: readonly T_3[]) => T_3[];
(list1: string, list2: string): string;
(list1: string): (list2: string) => string;
}, cond: {
(fns: [R.Pred, (...a: readonly any[]) => any][]): (...a: readonly any[]) => any;
<A, B>(fns: [R.SafePred<A>, (...a: readonly A[]) => B][]): (...a: readonly A[]) => B;
}, construct: <A extends any[], T>(constructor: (new (...a: A) => T) | ((...a: A) => T)) => (...a: A) => T, constructN: <A extends any[], T>(n: number, constructor: (new (...a: A) => T) | ((...a: A) => T)) => (...a: Partial<A>) => T, converge: (after: (...a: readonly any[]) => any, fns: ((...a: readonly any[]) => any)[]) => (...a: readonly any[]) => any, countBy: {
<T>(fn: (a: T) => string | number, list: readonly T[]): {
[index: string]: number;
};
<T_1>(fn: (a: T_1) => string | number): (list: readonly T_1[]) => {
[index: string]: number;
};
}, curry: <F extends (...args: any) => any>(f: F) => import("Function/Curry").Curry<F>, curryN: (length: number, fn: (...args: readonly any[]) => any) => (...a: readonly any[]) => any, dec: (n: number) => number, defaultTo: {
<T, U>(a: T, b: U | null | undefined): T | U;
<T_1>(a: T_1): <U_1>(b: U_1 | null | undefined) => T_1 | U_1;
}, descend: {
<T>(fn: (obj: T) => any, a: T, b: T): number;
<T_1>(fn: (obj: T_1) => any): (a: T_1, b: T_1) => number;
}, difference: {
<T>(list1: readonly T[], list2: readonly T[]): T[];
<T_1>(list1: readonly T_1[]): (list2: readonly T_1[]) => T_1[];
}, differenceWith: {
<T1, T2>(pred: (a: T1, b: T2) => boolean, list1: readonly T1[], list2: readonly T2[]): T1[];
<T1_1, T2_1>(pred: (a: T1_1, b: T2_1) => boolean): (list1: readonly T1_1[], list2: readonly T2_1[]) => T1_1[];
<T1_2, T2_2>(pred: (a: T1_2, b: T2_2) => boolean, list1: readonly T1_2[]): (list2: readonly T2_2[]) => T1_2[];
}, dissoc: {
<T>(prop: string, obj: any): T;
(prop: string): <U>(obj: any) => U;
}, dissocPath: {
<T>(path: R.Path, obj: any): T;
<T_1>(path: R.Path): (obj: any) => T_1;
}, divide: {
(__: R.Placeholder, b: number): (a: number) => number;
(__: R.Placeholder): (b: number, a: number) => number;
(a: number, b: number): number;
(a: number): (b: number) => number;
}, drop: {
<T>(n: number, xs: readonly T[]): T[];
(n: number, xs: string): string;
<T_1>(n: number): {
(xs: string): string;
(xs: readonly T_1[]): T_1[];
};
}, dropLast: {
<T>(n: number, xs: readonly T[]): T[];
(n: number, xs: string): string;
<T_1>(n: number): {
(xs: readonly T_1[]): T_1[];
(xs: string): string;
};
}, dropLastWhile: {
<T>(fn: (a: T) => boolean, list: readonly T[]): T[];
<T_1>(fn: (a: T_1) => boolean): (list: readonly T_1[]) => T_1[];
}, dropRepeats: <T>(list: readonly T[]) => T[], dropRepeatsWith: {
<T>(predicate: (left: T, right: T) => boolean, list: readonly T[]): T[];
<T_1>(predicate: (left: T_1, right: T_1) => boolean): (list: readonly T_1[]) => T_1[];
}, dropWhile: {
<T>(fn: (a: T) => boolean, list: readonly T[]): T[];
<T_1>(fn: (a: T_1) => boolean): (list: readonly T_1[]) => T_1[];
}, either: {
(pred1: R.Pred, pred2: R.Pred): R.Pred;
(pred1: R.Pred): (pred2: R.Pred) => R.Pred;
}, empty: <T>(x: T) => T, endsWith: {
(a: string, list: string): boolean;
(a: string): (list: string) => boolean;
<T>(a: T | readonly T[], list: readonly T[]): boolean;
<T_1>(a: T_1 | readonly T_1[]): (list: readonly T_1[]) => boolean;
}, eqBy: {
<T, U = T>(fn: (a: T) => U, a: T, b: T): boolean;
<T_1, U_1 = T_1>(fn: (a: T_1) => U_1, a: T_1): (b: T_1) => boolean;
<T_2, U_2 = T_2>(fn: (a: T_2) => U_2): import("Function/Curry").Curry<(a: T_2, b: T_2) => boolean>;
}, eqProps: {
<T, U>(prop: string, obj1: T, obj2: U): boolean;
<P extends string>(prop: P): <T_1, U_1>(obj1: Record<P, T_1>, obj2: Record<P, U_1>) => boolean;
<T_2>(prop: string, obj1: T_2): <U_2>(obj2: U_2) => boolean;
}, equals: {
<T>(a: T, b: T): boolean;
<T_1>(a: T_1): (b: T_1) => boolean;
}, evolve: {
<E extends R.Evolver, V extends R.Evolvable<E>>(transformations: E, obj: V): R.Evolve<V, E>;
<E_1 extends R.Evolver>(transformations: E_1): <V_1 extends R.Evolvable<E_1>>(obj: V_1) => R.Evolve<V_1, E_1>;
}, filter: R.Filter, find: {
<T>(fn: (a: T) => boolean, list: readonly T[]): T | undefined;
<T_1>(fn: (a: T_1) => boolean): (list: readonly T_1[]) => T_1 | undefined;
}, findIndex: {
<T>(fn: (a: T) => boolean, list: readonly T[]): number;
<T_1>(fn: (a: T_1) => boolean): (list: readonly T_1[]) => number;
}, findLast: {
<T>(fn: (a: T) => boolean, list: readonly T[]): T | undefined;
<T_1>(fn: (a: T_1) => boolean): (list: readonly T_1[]) => T_1 | undefined;
}, findLastIndex: {
<T>(fn: (a: T) => boolean, list: readonly T[]): number;
<T_1>(fn: (a: T_1) => boolean): (list: readonly T_1[]) => number;
}, flatten: <T extends readonly any[]>(list: T) => import("Tuple/Flatten").Flatten<T>, flip: {
<T, U, TResult>(fn: (arg0: T, arg1: U) => TResult): (arg1: U, arg0?: T | undefined) => TResult;
<F extends (...args: any) => any, P extends import("Function/Parameters").Parameters<F>>(fn: F): import("Function/Curry").Curry<(...args: import("Tuple/Merge").MergeFlat<[P[1], P[0]], P>) => import("Function/Return").Return<F>>;
}, forEach: {
<T>(fn: (x: T) => void, list: readonly T[]): T[];
<T_1>(fn: (x: T_1) => void): (list: readonly T_1[]) => T_1[];
<T_2>(fn: (x: T_2) => void, list: readonly T_2[]): T_2[];
<T_3>(fn: (x: T_3) => void): (list: readonly T_3[]) => T_3[];
}, forEachObjIndexed: {
<T>(fn: (value: T[keyof T], key: keyof T, obj: T) => void, obj: T): T;
<T_1>(fn: (value: T_1[keyof T_1], key: keyof T_1, obj: T_1) => void): (obj: T_1) => T_1;
}, fromPairs: {
<V>(pairs: R.KeyValuePair<string, V>[]): {
[index: string]: V;
};
<V_1>(pairs: R.KeyValuePair<number, V_1>[]): {
[index: number]: V_1;
};
}, groupBy: {
<T>(fn: (a: T) => string, list: readonly T[]): {
[index: string]: T[];
};
<T_1>(fn: (a: T_1) => string): (list: readonly T_1[]) => {
[index: string]: T_1[];
};
}, groupWith: {
<T>(fn: (x: T, y: T) => boolean): (list: readonly T[]) => T[][];
<T_1>(fn: (x: T_1, y: T_1) => boolean, list: readonly T_1[]): T_1[][];
<T_2>(fn: (x: T_2, y: T_2) => boolean, list: string): string[];
}, gt: {
(__: R.Placeholder, b: number): (a: number) => boolean;
(__: R.Placeholder): (b: number, a: number) => boolean;
(a: number, b: number): boolean;
(a: number): (b: number) => boolean;
}, gte: {
(__: R.Placeholder, b: number): (a: number) => boolean;
(__: R.Placeholder): (b: number, a: number) => boolean;
(a: number, b: number): boolean;
(a: number): (b: number) => boolean;
}, has: {
<T>(__: R.Placeholder, obj: T): (s: string) => boolean;
<T_1>(__: R.Placeholder): (obj: T_1, s: string) => boolean;
<T_2>(s: string, obj: T_2): boolean;
(s: string): <T_3>(obj: T_3) => boolean;
}, hasIn: {
<T>(s: string, obj: T): boolean;
(s: string): <T_1>(obj: T_1) => boolean;
}, hasPath: {
<T>(list: readonly string[], obj: T): boolean;
(list: readonly string[]): <T_1>(obj: T_1) => boolean;
}, head: {
(str: string): string;
(list: readonly []): undefined;
<T extends any>(list: readonly T[]): T | undefined;
}, identical: {
<T>(a: T, b: T): boolean;
<T_1>(a: T_1): (b: T_1) => boolean;
}, identity: <T>(a: T) => T, ifElse: {
(fn: R.Pred, onTrue: R.Arity1Fn, onFalse: R.Arity1Fn): R.Arity1Fn;
(fn: R.Pred, onTrue: R.Arity2Fn, onFalse: R.Arity2Fn): R.Arity2Fn;
}, inc: (n: number) => number, includes: {
(s: string, list: string | readonly string[]): boolean;
(s: string): (list: string | readonly string[]) => boolean;
<T>(target: T, list: readonly T[]): boolean;
<T_1>(target: T_1): (list: readonly T_1[]) => boolean;
}, indexBy: {
<T>(fn: (a: T) => string, list: readonly T[]): {
[key: string]: T;
};
<T_1>(fn: (a: T_1) => string): (list: readonly T_1[]) => {
[key: string]: T_1;
};
}, indexOf: {
<T>(target: T, list: readonly T[]): number;
<T_1>(target: T_1): (list: readonly T_1[]) => number;
}, init: {
<T>(list: readonly T[]): T[];
(list: string): string;
}, innerJoin: {
<T1, T2>(pred: (a: T1, b: T2) => boolean, list1: readonly T1[], list2: readonly T2[]): T1[];
<T1_1, T2_1>(pred: (a: T1_1, b: T2_1) => boolean): (list1: readonly T1_1[], list2: readonly T2_1[]) => T1_1[];
<T1_2, T2_2>(pred: (a: T1_2, b: T2_2) => boolean, list1: readonly T1_2[]): (list2: readonly T2_2[]) => T1_2[];
}, insert: {
<T>(index: number, elt: T, list: readonly T[]): T[];
<T_1>(index: number, elt: T_1): (list: readonly T_1[]) => T_1[];
(index: number): <T_2>(elt: T_2, list: readonly T_2[]) => T_2[];
}, insertAll: {
<T>(index: number, elts: readonly T[], list: readonly T[]): T[];
<T_1>(index: number, elts: readonly T_1[]): (list: readonly T_1[]) => T_1[];
(index: number): <T_2>(elts: readonly T_2[], list: readonly T_2[]) => T_2[];
}, intersection: {
<T>(list1: readonly T[], list2: readonly T[]): T[];
<T_1>(list1: readonly T_1[]): (list2: readonly T_1[]) => T_1[];
}, intersperse: {
<T>(separator: T, list: readonly T[]): T[];
<T_1>(separator: T_1): (list: readonly T_1[]) => T_1[];
}, into: {
<T>(acc: any, xf: (...a: readonly any[]) => any, list: readonly T[]): T[];
(acc: any, xf: (...a: readonly any[]) => any): <T_1>(list: readonly T_1[]) => T_1[];
(acc: any): <T_2>(xf: (...a: readonly any[]) => any, list: readonly T_2[]) => T_2[];
}, invert: <T>(obj: T) => {
[index: string]: string[];
}, invertObj: (obj: {
[index: string]: string;
} | {
[index: number]: string;
}) => {
[index: string]: string;
}, invoker: (arity: number, method: string) => (...a: readonly any[]) => any, is: {
(ctor: any, val: any): boolean;
(ctor: any): (val: any) => boolean;
}, isEmpty: (value: any) => boolean, isNil: (value: any) => value is null | undefined, join: {
(x: string, xs: readonly any[]): string;
(x: string): (xs: readonly any[]) => string;
}, juxt: {
<A extends any[], R1, R2>(fns: [(...a: A) => R1, (...a: A) => R2]): (...a: A) => [R1, R2];
<A_1 extends any[], R1_1, R2_1, R3>(fns: [(...a: A_1) => R1_1, (...a: A_1) => R2_1, (...a: A_1) => R3]): (...a: A_1) => [R1_1, R2_1, R3];
<A_2 extends any[], R1_2, R2_2, R3_1, R4>(fns: [(...a: A_2) => R1_2, (...a: A_2) => R2_2, (...a: A_2) => R3_1, (...a: A_2) => R4]): (...a: A_2) => [R1_2, R2_2, R3_1, R4];
<A_3 extends any[], R1_3, R2_3, R3_2, R4_1, R5>(fns: [(...a: A_3) => R1_3, (...a: A_3) => R2_3, (...a: A_3) => R3_2, (...a: A_3) => R4_1, (...a: A_3) => R5]): (...a: A_3) => [R1_3, R2_3, R3_2, R4_1, R5];
<A_4 extends any[], U>(fns: ((...args: A_4) => U)[]): (...args: A_4) => U[];
}, keys: {
<T extends object>(x: T): (keyof T)[];
<T_1>(x: T_1): string[];
}, keysIn: <T>(obj: T) => string[], last: {
(str: string): string;
(list: readonly []): undefined;
<T extends any>(list: readonly T[]): T | undefined;
}, lastIndexOf: <T>(target: T, list: readonly T[]) => number, length: <T>(list: readonly T[]) => number, lens: <T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V) => R.Lens, lensIndex: (n: number) => R.Lens, lensPath: (path: R.Path) => R.Lens, lensProp: (str: string) => {
<T, U>(obj: T): U;
set<T_1, U_1, V>(val: T_1, obj: U_1): V;
}, lift: (fn: (...a: readonly any[]) => any, ...args: readonly any[]) => any, liftN: (n: number, fn: (...a: readonly any[]) => any, ...args: readonly any[]) => any, lt: {
(__: R.Placeholder, b: number): (a: number) => boolean;
(__: R.Placeholder): (b: number, a: number) => boolean;
(a: number, b: number): boolean;
(a: number): (b: number) => boolean;
}, lte: {
(__: R.Placeholder, b: number): (a: number) => boolean;
(__: R.Placeholder): (b: number, a: number) => boolean;
(a: number, b: number): boolean;
(a: number): (b: number) => boolean;
}, map: {
<T, U>(fn: (x: T) => U, list: readonly T[]): U[];
<T_1, U_1>(fn: (x: T_1) => U_1): (list: readonly T_1[]) => U_1[];
<T_2, U_2>(fn: (x: T_2[keyof T_2 & keyof U_2]) => U_2[keyof T_2 & keyof U_2], list: T_2): U_2;
<T_3, U_3>(fn: (x: T_3[keyof T_3 & keyof U_3]) => U_3[keyof T_3 & keyof U_3]): (list: T_3) => U_3;
<T_4, U_4>(fn: (x: T_4) => U_4, obj: R.Functor<T_4>): R.Functor<U_4>;
<T_5, U_5>(fn: (x: T_5) => U_5): (obj: R.Functor<T_5>) => R.Functor<U_5>;
}, mapAccum: {
<T, U, TResult>(fn: (acc: U, value: T) => [U, TResult], acc: U, list: readonly T[]): [U, TResult[]];
<T_1, U_1, TResult_1>(fn: (acc: U_1, value: T_1) => [U_1, TResult_1]): (acc: U_1, list: readonly T_1[]) => [U_1, TResult_1[]];
<T_2, U_2, TResult_2>(fn: (acc: U_2, value: T_2) => [U_2, TResult_2], acc: U_2): (list: readonly T_2[]) => [U_2, TResult_2[]];
}, mapAccumRight: {
<T, U, TResult>(fn: (acc: U, value: T) => [U, TResult], acc: U, list: readonly T[]): [U, TResult[]];
<T_1, U_1, TResult_1>(fn: (acc: U_1, value: T_1) => [U_1, TResult_1]): (acc: U_1, list: readonly T_1[]) => [U_1, TResult_1[]];
<T_2, U_2, TResult_2>(fn: (acc: U_2, value: T_2) => [U_2, TResult_2], acc: U_2): (list: readonly T_2[]) => [U_2, TResult_2[]];
}, mapObjIndexed: {
<T, TResult, TKey extends string>(fn: (value: T, key: TKey, obj?: Record<TKey, T> | undefined) => TResult, obj: Record<TKey, T>): Record<TKey, TResult>;
<T_1, TResult_1, TKey_1 extends string>(fn: (value: T_1, key: TKey_1, obj?: Record<TKey_1, T_1> | undefined) => TResult_1): (obj: Record<TKey_1, T_1>) => Record<TKey_1, TResult_1>;
<T_2, TResult_2>(fn: (value: T_2, key: string, obj?: {
[key: string]: T_2;
} | undefined) => TResult_2, obj: {
[key: string]: T_2;
}): {
[key: string]: TResult_2;
};
<T_3, TResult_3>(fn: (value: T_3, key: string, obj?: any) => TResult_3, obj: any): {
[index: string]: TResult_3;
};
<T_4, TResult_4>(fn: (value: T_4, key: string, obj?: any) => TResult_4): (obj: any) => {
[index: string]: TResult_4;
};
}, match: {
(regexp: RegExp, str: string): any[];
(regexp: RegExp): (str: string) => any[];
}, mathMod: {
(__: R.Placeholder, b: number): (a: number) => number;
(__: R.Placeholder): (b: number, a: number) => number;
(a: number, b: number): number;
(a: number): (b: number) => number;
}, max: {
<T extends R.Ord>(a: T, b: T): T;
<T_1 extends R.Ord>(a: T_1): (b: T_1) => T_1;
}, maxBy: {
<T>(keyFn: (a: T) => R.Ord, a: T, b: T): T;
<T_1>(keyFn: (a: T_1) => R.Ord, a: T_1): (b: T_1) => T_1;
<T_2>(keyFn: (a: T_2) => R.Ord): import("Function/Curry").Curry<(a: T_2, b: T_2) => T_2>;
}, mean: (list: readonly number[]) => number, median: (list: readonly number[]) => number, memoizeWith: <T extends (...args: readonly any[]) => any>(keyFn: (...v: Parameters<T>) => string, fn: T) => T, mergeAll: <Os extends readonly object[]>(list: Os) => import("Object/AssignUp").AssignUp<{}, Os> extends infer M ? {} extends M ? Os[number] : import("Object/Clean").Clean<M & {}> : never, mergeDeepLeft: {
<O1 extends object, O2 extends object>(o1: O1, o2: O2): import("Object/Clean").Clean<import("Object/MergeUp").MergeUpDeep<O1, O2>>;
<O1_1 extends object>(o1: O1_1): <O2_1 extends object>(o2: O2_1) => import("Object/Clean").Clean<import("Object/MergeUp").MergeUpDeep<O1_1, O2_1>>;
}, mergeDeepRight: {
<O1 extends object, O2 extends object>(o1: O1, o2: O2): import("Object/Clean").Clean<import("Object/MergeUp").MergeUpDeep<O2, O1>>;
<O1_1 extends object>(a: O1_1): <O2_1 extends object>(o2: O2_1) => import("Object/Clean").Clean<import("Object/MergeUp").MergeUpDeep<O2_1, O1_1>>;
}, mergeDeepWith: {
<T1, T2>(fn: (x: any, z: any) => any, a: T1, b: T2): any;
<T1_1, T2_1>(fn: (x: any, z: any) => any, a: T1_1): (b: T2_1) => any;
<T1_2, T2_2>(fn: (x: any, z: any) => any): (a: T1_2, b: T2_2) => any;
}, mergeDeepWithKey: {
<T1, T2>(fn: (k: string, x: any, z: any) => any, a: T1, b: T2): any;
<T1_1, T2_1>(fn: (k: string, x: any, z: any) => any, a: T1_1): (b: T2_1) => any;
<T1_2, T2_2>(fn: (k: string, x: any, z: any) => any): (a: T1_2, b: T2_2) => any;
}, mergeLeft: {
<O1 extends object, O2 extends object>(a: O1, b: O2): import("Object/Clean").Clean<import("Object/MergeUp").MergeUpFlat<O1, O2>>;
<O1_1 extends object>(a: O1_1): <O2_1 extends object>(b: O2_1) => import("Object/Clean").Clean<import("Object/MergeUp").MergeUpFlat<O1_1, O2_1>>;
}, mergeRight: {
<O1 extends object, O2 extends object>(a: O1, b: O2): import("Object/Clean").Clean<import("Object/MergeUp").MergeUpFlat<O2, O1>>;
<O1_1 extends object>(a: O1_1): <O2_1 extends object>(b: O2_1) => import("Object/Clean").Clean<import("Object/MergeUp").MergeUpFlat<O2_1, O1_1>>;
}, mergeWith: {
<U, V>(fn: (x: any, z: any) => any, a: U, b: V): any;
<U_1>(fn: (x: any, z: any) => any, a: U_1): <V_1>(b: V_1) => any;
(fn: (x: any, z: any) => any): <U_2, V_2>(a: U_2, b: V_2) => any;
}, mergeWithKey: {
<U, V>(fn: (str: string, x: any, z: any) => any, a: U, b: V): any;
<U_1>(fn: (str: string, x: any, z: any) => any, a: U_1): <V_1>(b: V_1) => any;
(fn: (str: string, x: any, z: any) => any): <U_2, V_2>(a: U_2, b: V_2) => any;
}, min: {
<T extends R.Ord>(a: T, b: T): T;
<T_1 extends R.Ord>(a: T_1): (b: T_1) => T_1;
}, minBy: {
<T>(keyFn: (a: T) => R.Ord, a: T, b: T): T;
<T_1>(keyFn: (a: T_1) => R.Ord, a: T_1): (b: T_1) => T_1;
<T_2>(keyFn: (a: T_2) => R.Ord): import("Function/Curry").Curry<(a: T_2, b: T_2) => T_2>;
}, modulo: {
(__: R.Placeholder, b: number): (a: number) => number;
(__: R.Placeholder): (b: number, a: number) => number;
(a: number, b: number): number;
(a: number): (b: number) => number;
}, move: {
<T>(from: number, to: number, list: readonly T[]): T[];
(from: number, to: number): <T_1>(list: readonly T_1[]) => T_1[];
(from: number): {
<T_2>(to: number, list: readonly T_2[]): T_2[];
(to: number): <T_3>(list: readonly T_3[]) => T_3[];
};
}, multiply: {
(a: number, b: number): number;
(a: number): (b: number) => number;
}, nAry: {
(n: number, fn: (...arg: readonly any[]) => any): (...a: readonly any[]) => any;
(n: number): (fn: (...arg: readonly any[]) => any) => (...a: readonly any[]) => any;
}, negate: (n: number) => number, none: {
<T>(fn: (a: T) => boolean, list: readonly T[]): boolean;
<T_1>(fn: (a: T_1) => boolean): (list: readonly T_1[]) => boolean;
}, not: (value: any) => boolean, nth: {
<T>(n: number, list: readonly T[]): T | undefined;
(n: number): <T_1>(list: readonly T_1[]) => T_1 | undefined;
}, nthArg: (n: number) => (...a: readonly any[]) => any, o: {
<T1, T2, R>(f: (x: T2) => R, g: (x: T1) => T2, v: T1): R;
<T1_1, T2_1, R_1>(f: (x: T2_1) => R_1, g: (x: T1_1) => T2_1): (v: T1_1) => R_1;
<T2_2, R_2>(f: (x: T2_2) => R_2): {
<T1_2>(g: (x: T1_2) => T2_2, v: T1_2): R_2;
<T1_3>(g: (x: T1_3) => T2_2): (v: T1_3) => R_2;
};
}, objOf: {
<T, K extends string>(key: K, value: T): Record<K, T>;
<K_1 extends string>(key: K_1): <T_1>(value: T_1) => Record<K_1, T_1>;
}, of: <T>(x: T) => T[], omit: {
<T, K extends string>(names: readonly K[], obj: T): Pick<T, Exclude<keyof T, K>>;
<K_1 extends string>(names: readonly K_1[]): <T_1>(obj: T_1) => Pick<T_1, Exclude<keyof T_1, K_1>>;
}, once: {
(fn: (...a: readonly any[]) => any): (...a: readonly any[]) => any;
<T>(fn: (...a: readonly any[]) => T): (...a: readonly any[]) => T;
}, or: {
<T, U>(a: T, b: U): T | U;
<T_1>(a: T_1): <U_1>(b: U_1) => T_1 | U_1;
<T_2 extends {
or?: ((...a: readonly any[]) => any) | undefined;
}, U_2>(fn1: T_2, val2: U_2): T_2 | U_2;
<T_3 extends {
or?: ((...a: readonly any[]) => any) | undefined;
}>(fn1: T_3): <U_3>(val2: U_3) => T_3 | U_3;
}, otherwise: {
<A, B>(onError: (error: any) => B | Promise<B>, promise: Promise<A>): Promise<B>;
<A_1, B_1>(onError: (error: any) => B_1 | Promise<B_1>): (promise: Promise<A_1>) => Promise<B_1>;
}, over: {
<T>(lens: R.Lens, fn: R.Arity1Fn, value: T): T;
<T_1>(lens: R.Lens, fn: R.Arity1Fn, value: readonly T_1[]): T_1[];
(lens: R.Lens, fn: R.Arity1Fn): <T_2>(value: T_2) => T_2;
(lens: R.Lens, fn: R.Arity1Fn): <T_3>(value: readonly T_3[]) => T_3[];
(lens: R.Lens): <T_4>(fn: R.Arity1Fn, value: T_4) => T_4;
(lens: R.Lens): <T_5>(fn: R.Arity1Fn, value: readonly T_5[]) => T_5[];
}, pair: <F, S>(fst: F, snd: S) => [F, S], partial: {
<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: [V0]): (x1: V1) => T;
<V0_1, V1_1, V2, T_1>(fn: (x0: V0_1, x1: V1_1, x2: V2) => T_1, args: [V0_1, V1_1]): (x2: V2) => T_1;
<V0_2, V1_2, V2_1, T_2>(fn: (x0: V0_2, x1: V1_2, x2: V2_1) => T_2, args: [V0_2]): (x1: V1_2, x2: V2_1) => T_2;
<V0_3, V1_3, V2_2, V3, T_3>(fn: (x0: V0_3, x1: V1_3, x2: V2_2, x3: V3) => T_3, args: [V0_3, V1_3, V2_2]): (x2: V3) => T_3;
<V0_4, V1_4, V2_3, V3_1, T_4>(fn: (x0: V0_4, x1: V1_4, x2: V2_3, x3: V3_1) => T_4, args: [V0_4, V1_4]): (x2: V2_3, x3: V3_1) => T_4;
<V0_5, V1_5, V2_4, V3_2, T_5>(fn: (x0: V0_5, x1: V1_5, x2: V2_4, x3: V3_2) => T_5, args: [V0_5]): (x1: V1_5, x2: V2_4, x3: V3_2) => T_5;
<T_6>(fn: (...a: readonly any[]) => T_6, args: readonly any[]): (...a: readonly any[]) => T_6;
}, partialRight: {
<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: [V1]): (x1: V0) => T;
<V0_1, V1_1, V2, T_1>(fn: (x0: V0_1, x1: V1_1, x2: V2) => T_1, args: [V1_1, V2]): (x2: V0_1) => T_1;
<V0_2, V1_2, V2_1, T_2>(fn: (x0: V0_2, x1: V1_2, x2: V2_1) => T_2, args: [V2_1]): (x1: V0_2, x2: V1_2) => T_2;
<V0_3, V1_3, V2_2, V3, T_3>(fn: (x0: V0_3, x1: V1_3, x2: V2_2, x3: V3) => T_3, args: [V1_3, V2_2, V3]): (x0: V0_3) => T_3;
<V0_4, V1_4, V2_3, V3_1, T_4>(fn: (x0: V0_4, x1: V1_4, x2: V2_3, x3: V3_1) => T_4, args: [V2_3, V3_1]): (x0: V0_4, x1: V1_4) => T_4;
<V0_5, V1_5, V2_4, V3_2, T_5>(fn: (x0: V0_5, x1: V1_5, x2: V2_4, x3: V3_2) => T_5, args: [V3_2]): (x0: V0_5, x1: V1_5, x2: V2_4) => T_5;
<T_6>(fn: (...a: readonly any[]) => T_6, args: readonly any[]): (...a: readonly any[]) => T_6;
}, partition: {
(fn: (a: string) => boolean, list: readonly string[]): [string[], string[]];
<T>(fn: (a: T) => boolean, list: readonly T[]): [T[], T[]];
<T_1>(fn: (a: T_1) => boolean): (list: readonly T_1[]) => [T_1[], T_1[]];
(fn: (a: string) => boolean): (list: readonly string[]) => [string[], string[]];
}, path: {
<T>(path: R.Path, obj: any): T | undefined;
<T_1>(path: R.Path): (obj: any) => T_1 | undefined;
}, pathEq: {
(path: R.Path, val: any, obj: any): boolean;
(path: R.Path, val: any): (obj: any) => boolean;
(path: R.Path): import("Function/Curry").Curry<(a: any, b: any) => boolean>;
}, pathOr: {
<T>(defaultValue: T, path: R.Path, obj: any): T;
<T_1>(defaultValue: T_1, path: R.Path): (obj: any) => T_1;
<T_2>(defaultValue: T_2): import("Function/Curry").Curry<(a: R.Path, b: any) => T_2>;
}, pathSatisfies: {
<T, U>(pred: (val: T) => boolean, path: R.Path, obj: U): boolean;
<T_1, U_1>(pred: (val: T_1) => boolean, path: R.Path): (obj: U_1) => boolean;
<T_2, U_2>(pred: (val: T_2) => boolean): import("Function/Curry").Curry<(a: R.Path, b: U_2) => boolean>;
}, pick: {
<T, K extends string>(names: readonly K[], obj: T): Pick<T, Exclude<keyof T, Exclude<keyof T, K>>>;
<K_1 extends string>(names: readonly K_1[]): <T_1>(obj: T_1) => Pick<T_1, Exclude<keyof T_1, Exclude<keyof T_1, K_1>>>;
}, pickAll: {
<T, U>(names: readonly string[], obj: T): U;
(names: readonly string[]): <T_1, U_1>(obj: T_1) => U_1;
}, pickBy: {
<T, U>(pred: R.ObjPred, obj: T): U;
(pred: R.ObjPred): <T_1, U_1>(obj: T_1) => U_1;
}, pipe: {
<T1>(fn0: () => T1): () => T1;
<V0, T1_1>(fn0: (x0: V0) => T1_1): (x0: V0) => T1_1;
<V0_1, V1, T1_2>(fn0: (x0: V0_1, x1: V1) => T1_2): (x0: V0_1, x1: V1) => T1_2;
<V0_2, V1_1, V2, T1_3>(fn0: (x0: V0_2, x1: V1_1, x2: V2) => T1_3): (x0: V0_2, x1: V1_1, x2: V2) => T1_3;
<T1_4, T2>(fn0: () => T1_4, fn1: (x: T1_4) => T2): () => T2;
<V0_3, T1_5, T2_1>(fn0: (x0: V0_3) => T1_5, fn1: (x: T1_5) => T2_1): (x0: V0_3) => T2_1;
<V0_4, V1_2, T1_6, T2_2>(fn0: (x0: V0_4, x1: V1_2) => T1_6, fn1: (x: T1_6) => T2_2): (x0: V0_4, x1: V1_2) => T2_2;
<V0_5, V1_3, V2_1, T1_7, T2_3>(fn0: (x0: V0_5, x1: V1_3, x2: V2_1) => T1_7, fn1: (x: T1_7) => T2_3): (x0: V0_5, x1: V1_3, x2: V2_1) => T2_3;
<T1_8, T2_4, T3>(fn0: () => T1_8, fn1: (x: T1_8) => T2_4, fn2: (x: T2_4) => T3): () => T3;
<V0_6, T1_9, T2_5, T3_1>(fn0: (x: V0_6) => T1_9, fn1: (x: T1_9) => T2_5, fn2: (x: T2_5) => T3_1): (x: V0_6) => T3_1;
<V0_7, V1_4, T1_10, T2_6, T3_2>(fn0: (x0: V0_7, x1: V1_4) => T1_10, fn1: (x: T1_10) => T2_6, fn2: (x: T2_6) => T3_2): (x0: V0_7, x1: V1_4) => T3_2;
<V0_8, V1_5, V2_2, T1_11, T2_7, T3_3>(fn0: (x0: V0_8, x1: V1_5, x2: V2_2) => T1_11, fn1: (x: T1_11) => T2_7, fn2: (x: T2_7) => T3_3): (x0: V0_8, x1: V1_5, x2: V2_2) => T3_3;
<T1_12, T2_8, T3_4, T4>(fn0: () => T1_12, fn1: (x: T1_12) => T2_8, fn2: (x: T2_8) => T3_4, fn3: (x: T3_4) => T4): () => T4;
<V0_9, T1_13, T2_9, T3_5, T4_1>(fn0: (x: V0_9) => T1_13, fn1: (x: T1_13) => T2_9, fn2: (x: T2_9) => T3_5, fn3: (x: T3_5) => T4_1): (x: V0_9) => T4_1;
<V0_10, V1_6, T1_14, T2_10, T3_6, T4_2>(fn0: (x0: V0_10, x1: V1_6) => T1_14, fn1: (x: T1_14) => T2_10, fn2: (x: T2_10) => T3_6, fn3: (x: T3_6) => T4_2): (x0: V0_10, x1: V1_6) => T4_2;
<V0_11, V1_7, V2_3, T1_15, T2_11, T3_7, T4_3>(fn0: (x0: V0_11, x1: V1_7, x2: V2_3) => T1_15, fn1: (x: T1_15) => T2_11, fn2: (x: T2_11) => T3_7, fn3: (x: T3_7) => T4_3): (x0: V0_11, x1: V1_7, x2: V2_3) => T4_3;
<T1_16, T2_12, T3_8, T4_4, T5>(fn0: () => T1_16, fn1: (x: T1_16) => T2_12, fn2: (x: T2_12) => T3_8, fn3: (x: T3_8) => T4_4, fn4: (x: T4_4) => T5): () => T5;
<V0_12, T1_17, T2_13, T3_9, T4_5, T5_1>(fn0: (x: V0_12) => T1_17, fn1: (x: T1_17) => T2_13, fn2: (x: T2_13) => T3_9, fn3: (x: T3_9) => T4_5, fn4: (x: T4_5) => T5_1): (x: V0_12) => T5_1;
<V0_13, V1_8, T1_18, T2_14, T3_10, T4_6, T5_2>(fn0: (x0: V0_13, x1: V1_8) => T1_18, fn1: (x: T1_18) => T2_14, fn2: (x: T2_14) => T3_10, fn3: (x: T3_10) => T4_6, fn4: (x: T4_6) => T5_2): (x0: V0_13, x1: V1_8) => T5_2;
<V0_14, V1_9, V2_4, T1_19, T2_15, T3_11, T4_7, T5_3>(fn0: (x0: V0_14, x1: V1_9, x2: V2_4) => T1_19, fn1: (x: T1_19) => T2_15, fn2: (x: T2_15) => T3_11, fn3: (x: T3_11) => T4_7, fn4: (x: T4_7) => T5_3): (x0: V0_14, x1: V1_9, x2: V2_4) => T5_3;
<T1_20, T2_16, T3_12, T4_8, T5_4, T6>(fn0: () => T1_20, fn1: (x: T1_20) => T2_16, fn2: (x: T2_16) => T3_12, fn3: (x: T3_12) => T4_8, fn4: (x: T4_8) => T5_4, fn5: (x: T5_4) => T6): () => T6;
<V0_15, T1_21, T2_17, T3_13, T4_9, T5_5, T6_1>(fn0: (x: V0_15) => T1_21, fn1: (x: T1_21) => T2_17, fn2: (x: T2_17) => T3_13, fn3: (x: T3_13) => T4_9, fn4: (x: T4_9) => T5_5, fn5: (x: T5_5) => T6_1): (x: V0_15) => T6_1;
<V0_16, V1_10, T1_22, T2_18, T3_14, T4_10, T5_6, T6_2>(fn0: (x0: V0_16, x1: V1_10) => T1_22, fn1: (x: T1_22) => T2_18, fn2: (x: T2_18) => T3_14, fn3: (x: T3_14) => T4_10, fn4: (x: T4_10) => T5_6, fn5: (x: T5_6) => T6_2): (x0: V0_16, x1: V1_10) => T6_2;
<V0_17, V1_11, V2_5, T1_23, T2_19, T3_15, T4_11, T5_7, T6_3>(fn0: (x0: V0_17, x1: V1_11, x2: V2_5) => T1_23, fn1: (x: T1_23) => T2_19, fn2: (x: T2_19) => T3_15, fn3: (x: T3_15) => T4_11, fn4: (x: T4_11) => T5_7, fn5: (x: T5_7) => T6_3): (x0: V0_17, x1: V1_11, x2: V2_5) => T6_3;
<T1_24, T2_20, T3_16, T4_12, T5_8, T6_4, T7>(fn0: () => T1_24, fn1: (x: T1_24) => T2_20, fn2: (x: T2_20) => T3_16, fn3: (x: T3_16) => T4_12, fn4: (x: T4_12) => T5_8, fn5: (x: T5_8) => T6_4, fn: (x: T6_4) => T7): () => T7;
<V0_18, T1_25, T2_21, T3_17, T4_13, T5_9, T6_5, T7_1>(fn0: (x: V0_18) => T1_25, fn1: (x: T1_25) => T2_21, fn2: (x: T2_21) => T3_17, fn3: (x: T3_17) => T4_13, fn4: (x: T4_13) => T5_9, fn5: (x: T5_9) => T6_5, fn: (x: T6_5) => T7_1): (x: V0_18) => T7_1;
<V0_19, V1_12, T1_26, T2_22, T3_18, T4_14, T5_10, T6_6, T7_2>(fn0: (x0: V0_19, x1: V1_12) => T1_26, fn1: (x: T1_26) => T2_22, fn2: (x: T2_22) => T3_18, fn3: (x: T3_18) => T4_14, fn4: (x: T4_14) => T5_10, fn5: (x: T5_10) => T6_6, fn6: (x: T6_6) => T7_2): (x0: V0_19, x1: V1_12) => T7_2;
<V0_20, V1_13, V2_6, T1_27, T2_23, T3_19, T4_15, T5_11, T6_7, T7_3>(fn0: (x0: V0_20, x1: V1_13, x2: V2_6) => T1_27, fn1: (x: T1_27) => T2_23, fn2: (x: T2_23) => T3_19, fn3: (x: T3_19) => T4_15, fn4: (x: T4_15) => T5_11, fn5: (x: T5_11) => T6_7, fn6: (x: T6_7) => T7_3): (x0: V0_20, x1: V1_13, x2: V2_6) => T7_3;
<T1_28, T2_24, T3_20, T4_16, T5_12, T6_8, T7_4, T8>(fn0: () => T1_28, fn1: (x: T1_28) => T2_24, fn2: (x: T2_24) => T3_20, fn3: (x: T3_20) => T4_16, fn4: (x: T4_16) => T5_12, fn5: (x: T5_12) => T6_8, fn6: (x: T6_8) => T7_4, fn: (x: T7_4) => T8): () => T8;
<V0_21, T1_29, T2_25, T3_21, T4_17, T5_13, T6_9, T7_5, T8_1>(fn0: (x: V0_21) => T1_29, fn1: (x: T1_29) => T2_25, fn2: (x: T2_25) => T3_21, fn3: (x: T3_21) => T4_17, fn4: (x: T4_17) => T5_13, fn5: (x: T5_13) => T6_9, fn6: (x: T6_9) => T7_5, fn: (x: T7_5) => T8_1): (x: V0_21) => T8_1;
<V0_22, V1_14, T1_30, T2_26, T3_22, T4_18, T5_14, T6_10, T7_6, T8_2>(fn0: (x0: V0_22, x1: V1_14) => T1_30, fn1: (x: T1_30) => T2_26, fn2: (x: T2_26) => T3_22, fn3: (x: T3_22) => T4_18, fn4: (x: T4_18) => T5_14, fn5: (x: T5_14) => T6_10, fn6: (x: T6_10) => T7_6, fn7: (x: T7_6) => T8_2): (x0: V0_22, x1: V1_14) => T8_2;
<V0_23, V1_15, V2_7, T1_31, T2_27, T3_23, T4_19, T5_15, T6_11, T7_7, T8_3>(fn0: (x0: V0_23, x1: V1_15, x2: V2_7) => T1_31, fn1: (x: T1_31) => T2_27, fn2: (x: T2_27) => T3_23, fn3: (x: T3_23) => T4_19, fn4: (x: T4_19) => T5_15, fn5: (x: T5_15) => T6_11, fn6: (x: T6_11) => T7_7, fn7: (x: T7_7) => T8_3): (x0: V0_23, x1: V1_15, x2: V2_7) => T8_3;
<T1_32, T2_28, T3_24, T4_20, T5_16, T6_12, T7_8, T8_4, T9>(fn0: () => T1_32, fn1: (x: T1_32) => T2_28, fn2: (x: T2_28) => T3_24, fn3: (x: T3_24) => T4_20, fn4: (x: T4_20) => T5_16, fn5: (x: T5_16) => T6_12, fn6: (x: T6_12) => T7_8, fn7: (x: T7_8) => T8_4, fn8: (x: T8_4) => T9): () => T9;
<V0_24, T1_33, T2_29, T3_25, T4_21, T5_17, T6_13, T7_9, T8_5, T9_1>(fn0: (x0: V0_24) => T1_33, fn1: (x: T1_33) => T2_29, fn2: (x: T2_29) => T3_25, fn3: (x: T3_25) => T4_21, fn4: (x: T4_21) => T5_17, fn5: (x: T5_17) => T6_13, fn6: (x: T6_13) => T7_9, fn7: (x: T7_9) => T8_5, fn8: (x: T8_5) => T9_1): (x0: V0_24) => T9_1;
<V0_25, V1_16, T1_34, T2_30, T3_26, T4_22, T5_18, T6_14, T7_10, T8_6, T9_2>(fn0: (x0: V0_25, x1: V1_16) => T1_34, fn1: (x: T1_34) => T2_30, fn2: (x: T2_30) => T3_26, fn3: (x: T3_26) => T4_22, fn4: (x: T4_22) => T5_18, fn5: (x: T5_18) => T6_14, fn6: (x: T6_14) => T7_10, fn7: (x: T7_10) => T8_6, fn8: (x: T8_6) => T9_2): (x0: V0_25, x1: V1_16) => T9_2;
<V0_26, V1_17, V2_8, T1_35, T2_31, T3_27, T4_23, T5_19, T6_15, T7_11, T8_7, T9_3>(fn0: (x0: V0_26, x1: V1_17, x2: V2_8) => T1_35, fn1: (x: T1_35) => T2_31, fn2: (x: T2_31) => T3_27, fn3: (x: T3_27) => T4_23, fn4: (x: T4_23) => T5_19, fn5: (x: T5_19) => T6_15, fn6: (x: T6_15) => T7_11, fn7: (x: T7_11) => T8_7, fn8: (x: T8_7) => T9_3): (x0: V0_26, x1: V1_17, x2: V2_8) => T9_3;
<T1_36, T2_32, T3_28, T4_24, T5_20, T6_16, T7_12, T8_8, T9_4, T10>(fn0: () => T1_36, fn1: (x: T1_36) => T2_32, fn2: (x: T2_32) => T3_28, fn3: (x: T3_28) => T4_24, fn4: (x: T4_24) => T5_20, fn5: (x: T5_20) => T6_16, fn6: (x: T6_16) => T7_12, fn7: (x: T7_12) => T8_8, fn8: (x: T8_8) => T9_4, fn9: (x: T9_4) => T10): () => T10;
<V0_27, T1_37, T2_33, T3_29, T4_25, T5_21, T6_17, T7_13, T8_9, T9_5, T10_1>(fn0: (x0: V0_27) => T1_37, fn1: (x: T1_37) => T2_33, fn2: (x: T2_33) => T3_29, fn3: (x: T3_29) => T4_25, fn4: (x: T4_25) => T5_21, fn5: (x: T5_21) => T6_17, fn6: (x: T6_17) => T7_13, fn7: (x: T7_13) => T8_9, fn8: (x: T8_9) => T9_5, fn9: (x: T9_5) => T10_1): (x0: V0_27) => T10_1;
<V0_28, V1_18, T1_38, T2_34, T3_30, T4_26, T5_22, T6_18, T7_14, T8_10, T9_6, T10_2>(fn0: (x0: V0_28, x1: V1_18) => T1_38, fn1: (x: T1_38) => T2_34, fn2: (x: T2_34) => T3_30, fn3: (x: T3_30) => T4_26, fn4: (x: T4_26) => T5_22, fn5: (x: T5_22) => T6_18, fn6: (x: T6_18) => T7_14, fn7: (x: T7_14) => T8_10, fn8: (x: T8_10) => T9_6, fn9: (x: T9_6) => T10_2): (x0: V0_28, x1: V1_18) => T10_2;
<V0_29, V1_19, V2_9, T1_39, T2_35, T3_31, T4_27, T5_23, T6_19, T7_15, T8_11, T9_7, T10_3>(fn0: (x0: V0_29, x1: V1_19, x2: V2_9) => T1_39, fn1: (x: T1_39) => T2_35, fn2: (x: T2_35) => T3_31, fn3: (x: T3_31) => T4_27, fn4: (x: T4_27) => T5_23, fn5: (x: T5_23) => T6_19, fn6: (x: T6_19) => T7_15, fn7: (x: T7_15) => T8_11, fn8: (x: T8_11) => T9_7, fn9: (x: T9_7) => T10_3): (x0: V0_29, x1: V1_19, x2: V2_9) => T10_3;
}, pipeWith: {
<V0, T>(composer: (a: any) => any, fns: R.PipeWithFns<V0, T>): (x0: V0) => T;
(composer: (a: any) => any): <V0_1, T_1>(fns: R.PipeWithFns<V0_1, T_1>) => (x0: V0_1) => T_1;
}, pluck: {
<K extends keyof T, T>(p: K, list: readonly T[]): T[K][];
<T_1>(p: number, list: {
[k: number]: T_1;
}[]): T_1[];
<P extends string>(p: P): <T_2>(list: Record<P, T_2>[]) => T_2[];
(p: number): <T_3>(list: {
[k: number]: T_3;
}[]) => T_3[];
}, prepend: {
<T>(el: T, list: readonly T[]): T[];
<T_1>(el: T_1): (list: readonly T_1[]) => T_1[];
}, product: (list: readonly number[]) => number, project: {
<T, U>(props: readonly string[], objs: readonly T[]): U[];
<T_1, U_1>(props: readonly string[]): (objs: readonly T_1[]) => U_1[];
}, prop: {
<T>(__: R.Placeholder, obj: T): <P extends keyof T>(p: P) => T[P];
<P_1 extends keyof T_1, T_1>(p: P_1, obj: T_1): T_1[P_1];
<P_2 extends string>(p: P_2): <T_2>(obj: Record<P_2, T_2>) => T_2;
<P_3 extends string, T_3>(p: P_3): (obj: Record<P_3, T_3>) => T_3;
}, propEq: {
<T>(name: string | number, val: T, obj: any): boolean;
<T_1>(name: string | number, val: T_1): (obj: any) => boolean;
(name: string | number): {
<T_2>(val: T_2, obj: any): boolean;
<T_3>(val: T_3): (obj: any) => boolean;
};
}, propIs: {
(type: any, name: string, obj: any): boolean;
(type: any, name: string): (obj: any) => boolean;
(type: any): {
(name: string, obj: any): boolean;
(name: string): (obj: any) => boolean;
};
}, propOr: {
<T, U>(val: T, __: R.Placeholder, obj: U): <V>(p: string) => V;
<U_1>(__: R.Placeholder, p: string, obj: U_1): <T_1, V_1>(val: T_1) => V_1;
<T_2, U_2, V_2>(val: T_2, p: string, obj: U_2): V_2;
<T_3>(val: T_3, p: string): <U_3, V_3>(obj: U_3) => V_3;
<T_4>(val: T_4): <U_4, V_4>(p: string, obj: U_4) => V_4;
}, propSatisfies: {
<T, U>(pred: (val: T) => boolean, name: string, obj: U): boolean;
<T_1, U_1>(pred: (val: T_1) => boolean, name: string): (obj: U_1) => boolean;
<T_2, U_2>(pred: (val: T_2) => boolean): import("Function/Curry").Curry<(a: string, b: U_2) => boolean>;
}, props: {
<P extends string, T>(ps: readonly P[], obj: Record<P, T>): T[];
<P_1 extends string>(ps: readonly P_1[]): <T_1>(obj: Record<P_1, T_1>) => T_1[];
<P_2 extends string, T_2>(ps: readonly P_2[]): (obj: Record<P_2, T_2>) => T_2[];
}, range: {
(from: number, to: number): number[];
(from: number): (to: number) => number[];
}, reduce: {
<T, TResult>(fn: (acc: TResult, elem: T) => TResult | R.Reduced<TResult>, acc: TResult, list: readonly T[]): TResult;
<T_1, TResult_1>(fn: (acc: TResult_1, elem: T_1) => TResult_1 | R.Reduced<TResult_1>): (acc: TResult_1, list: readonly T_1[]) => TResult_1;
<T_2, TResult_2>(fn: (acc: TResult_2, elem: T_2) => TResult_2 | R.Reduced<TResult_2>, acc: TResult_2): (list: readonly T_2[]) => TResult_2;
}, reduceBy: {
<T, TResult>(valueFn: (acc: TResult, elem: T) => TResult, acc: TResult, keyFn: (elem: T) => string, list: readonly T[]): {
[index: string]: TResult;
};
<T_1, TResult_1>(valueFn: (acc: TResult_1, elem: T_1) => TResult_1, acc: TResult_1, keyFn: (elem: T_1) => string): (list: readonly T_1[]) => {
[index: string]: TResult_1;
};
<T_2, TResult_2>(valueFn: (acc: TResult_2, elem: T_2) => TResult_2, acc: TResult_2): import("Function/Curry").Curry<(a: (elem: T_2) => string, b: readonly T_2[]) => {
[index: string]: TResult_2;
}>;
<T_3, TResult_3>(valueFn: (acc: TResult_3, elem: T_3) => TResult_3): import("Function/Curry").Curry<(a: TResult_3, b: (elem: T_3) => string, c: readonly T_3[]) => {
[index: string]: TResult_3;
}>;
}, reduceRight: {
<T, TResult>(fn: (elem: T, acc: TResult) => TResult, acc: TResult, list: readonly T[]): TResult;
<T_1, TResult_1>(fn: (elem: T_1, acc: TResult_1) => TResult_1): (acc: TResult_1, list: readonly T_1[]) => TResult_1;
<T_2, TResult_2>(fn: (elem: T_2, acc: TResult_2) => TResult_2, acc: TResult_2): (list: readonly T_2[]) => TResult_2;
}, reduceWhile: {
<T, TResult>(predicate: (acc: TResult, elem: T) => boolean, fn: (acc: TResult, elem: T) => TResult, acc: TResult, list: readonly T[]): TResult;
<T_1, TResult_1>(predicate: (acc: TResult_1, elem: T_1) => boolean, fn: (acc: TResult_1, elem: T_1) => TResult_1, acc: TResult_1): (list: readonly T_1[]) => TResult_1;
<T_2, TResult_2>(predicate: (acc: TResult_2, elem: T_2) => boolean, fn: (acc: TResult_2, elem: T_2) => TResult_2): import("Function/Curry").Curry<(a: TResult_2, b: readonly T_2[]) => TResult_2>;
<T_3, TResult_3>(predicate: (acc: TResult_3, elem: T_3) => boolean): import("Function/Curry").Curry<(a: (acc: TResult_3, elem: T_3) => TResult_3, b: TResult_3, c: readonly T_3[]) => TResult_3>;
}, reduced: <T>(elem: T) => R.Reduced<T>, reject: R.Filter, remove: {
<T>(start: number, count: number, list: readonly T[]): T[];
<T_1>(start: number): (count: number, list: readonly T_1[]) => T_1[];
<T_2>(start: number, count: number): (list: readonly T_2[]) => T_2[];
}, repeat: {
<T>(a: T, n: number): T[];
<T_1>(a: T_1): (n: number) => T_1[];
}, replace: {
(pattern: string | RegExp, replacement: string | ((match: string, ...args: readonly any[]) => string), str: string): string;
(pattern: string | RegExp, replacement: string | ((match: string, ...args: readonly any[]) => string)): (str: string) => string;
(pattern: string | RegExp): (replacement: string | ((match: string, ...args: readonly any[]) => string)) => (str: string) => string;
}, reverse: {
<T>(list: readonly T[]): T[];
(str: string): string;
}, scan: {
<T, TResult>(fn: (acc: TResult, elem: T) => any, acc: TResult, list: readonly T[]): TResult[];
<T_1, TResult_1>(fn: (acc: TResult_1, elem: T_1) => any, acc: TResult_1): (list: readonly T_1[]) => TResult_1[];
<T_2, TResult_2>(fn: (acc: TResult_2, elem: T_2) => any): (acc: TResult_2, list: readonly T_2[]) => TResult_2[];
}, set: {
<T, U>(lens: R.Lens, a: U, obj: T): T;
<U_1>(lens: R.Lens, a: U_1): <T_1>(obj: T_1) => T_1;
(lens: R.Lens): <T_2, U_2>(a: U_2, obj: T_2) => T_2;
}, slice: {
(a: number, b: number, list: string): string;
<T>(a: number, b: number, list: readonly T[]): T[];
(a: number, b: number): {
(list: string): string;
<T_1>(list: readonly T_1[]): T_1[];
};
(a: number): {
(b: number, list: string): string;
<T_2>(b: number, list: readonly T_2[]): T_2[];
};
}, sort: {
<T>(fn: (a: T, b: T) => number, list: readonly T[]): T[];
<T_1>(fn: (a: T_1, b: T_1) => number): (list: readonly T_1[]) => T_1[];
}, sortBy: {
<T>(fn: (a: T) => R.Ord, list: readonly T[]): T[];
(fn: (a: any) => R.Ord): <T_1>(list: readonly T_1[]) => T_1[];
}, sortWith: {
<T>(fns: ((a: T, b: T) => number)[], list: readonly T[]): T[];
<T_1>(fns: ((a: T_1, b: T_1) => number)[]): (list: readonly T_1[]) => T_1[];
}, split: {
(sep: string | RegExp): (str: string) => string[];
(sep: string | RegExp, str: string): string[];
}, splitAt: {
<T>(index: number, list: readonly T[]): [T[], T[]];
(index: number, list: string): [string, string];
(index: number): {
<T_1>(list: readonly T_1[]): [T_1[], T_1[]];
(list: string): [string, string];
};
}, splitEvery: {
<T>(a: number, list: readonly T[]): T[][];
(a: number, list: string): string[];
(a: number): {
(list: string): string[];
<T_1>(list: readonly T_1[]): T_1[][];
};
}, splitWhen: {
<T, U>(pred: (val: T) => boolean, list: readonly U[]): U[][];
<T_1>(pred: (val: T_1) => boolean): <U_1>(list: readonly U_1[]) => U_1[][];
}, startsWith: {
(a: string, list: string): boolean;
(a: string): (list: string) => boolean;
<T>(a: T | readonly T[], list: readonly T[]): boolean;
<T_1>(a: T_1 | readonly T_1[]): (list: readonly T_1[]) => boolean;
}, subtract: {
(__: R.Placeholder, b: number): (a: number) => number;
(__: R.Placeholder): (b: number, a: number) => number;
(a: number, b: number): number;
(a: number): (b: number) => number;
}, sum: (list: readonly number[]) => number, symmetricDifference: {
<T>(list1: readonly T[], list2: readonly T[]): T[];
<T_1>(list: readonly T_1[]): <T_2>(list: readonly T_2[]) => T_2[];
}, symmetricDifferenceWith: {
<T>(pred: (a: T, b: T) => boolean, list1: readonly T[], list2: readonly T[]): T[];
<T_1>(pred: (a: T_1, b: T_1) => boolean): import("Function/Curry").Curry<(a: readonly T_1[], b: readonly T_1[]) => T_1[]>;
}, tail: {
(list: string): string;
<T extends any>(list: readonly T[]): T[];
}, take: {
<T>(n: number, xs: readonly T[]): T[];
(n: number, xs: string): string;
(n: number): {
(xs: string): string;
<T_1>(xs: readonly T_1[]): T_1[];
};
}, takeLast: {
<T>(n: number, xs: readonly T[]): T[];
(n: number, xs: string): string;
(n: number): {
<T_1>(xs: readonly T_1[]): T_1[];
(xs: string): string;
};
}, takeLastWhile: {
<T>(pred: (a: T) => boolean, list: readonly T[]): T[];
<T_1>(pred: (a: T_1) => boolean): <T_2>(list: readonly T_2[]) => T_2[];
}, takeWhile: {
<T>(fn: (x: T) => boolean, list: readonly T[]): T[];
<T_1>(fn: (x: T_1) => boolean): (list: readonly T_1[]) => T_1[];
}, tap: {
<T>(fn: (a: T) => any, value: T): T;
<T_1>(fn: (a: T_1) => any): (value: T_1) => T_1;
}, test: {
(regexp: RegExp, str: string): boolean;
(regexp: RegExp): (str: string) => boolean;
}, thunkify: <F extends (...args: readonly any[]) => any>(fn: F) => import("Function/Curry").Curry<(...args: Parameters<F>) => () => ReturnType<F>>, times: {
<T>(fn: (i: number) => T, n: number): T[];
<T_1>(fn: (i: number) => T_1): (n: number) => T_1[];
}, toLower: (str: string) => string, toPairs: <S>(obj: {
[k: string]: S;
} | {
[k: number]: S;
}) => [string, S][], toPairsIn: <S>(obj: {
[k: string]: S;
} | {
[k: number]: S;
}) => [string, S][], toString: <T>(val: T) => string, toUpper: (str: string) => string, transduce: {
<T, U>(xf: (arg: readonly T[]) => T[], fn: (acc: readonly U[], val: U) => U[], acc: readonly T[], list: readonly T[]): U;
<T_1, U_1>(xf: (arg: readonly T_1[]) => T_1[]): (fn: (acc: readonly U_1[], val: U_1) => U_1[], acc: readonly T_1[], list: readonly T_1[]) => U_1;
<T_2, U_2>(xf: (arg: readonly T_2[]) => T_2[], fn: (acc: readonly U_2[], val: U_2) => U_2[]): (acc: readonly T_2[], list: readonly T_2[]) => U_2;
<T_3, U_3>(xf: (arg: readonly T_3[]) => T_3[], fn: (acc: readonly U_3[], val: U_3) => U_3[], acc: readonly T_3[]): (list: readonly T_3[]) => U_3;
}, transpose: <T>(list: readonly T[][]) => T[][], traverse: {
<A, B>(of: (a: B) => B[], fn: (t: A) => B[], list: readonly A[]): B[][];
<A_1, B_1>(of: (a: B_1) => B_1[], fn: (t: A_1) => B_1[]): (list: readonly A_1[]) => B_1[][];
<A_2, B_2>(of: (a: B_2) => B_2[]): (fn: (t: A_2) => B_2[], list: readonly A_2[]) => B_2[][];
}, trim: (str: string) => string, tryCatch: <T>(tryer: (...args: readonly any[]) => T, catcher: (...args: readonly any[]) => T) => (...args: readonly any[]) => T, type: (val: any) => "Object" | "Number" | "Boolean" | "String" | "Null" | "Array" | "RegExp" | "Function" | "Undefined", unapply: <T>(fn: (args: readonly any[]) => T) => (...args: readonly any[]) => T, unary: <T>(fn: (a: T, ...args: readonly any[]) => any) => (a: T) => any, uncurryN: <T>(len: number, fn: (a: any) => any) => (...a: readonly any[]) => T, unfold: {
<T, TResult>(fn: (seed: T) => false | [TResult, T], seed: T): TResult[];
<T_1, TResult_1>(fn: (seed: T_1) => false | [TResult_1, T_1]): (seed: T_1) => TResult_1[];
}, union: {
<T>(as: readonly T[], bs: readonly T[]): T[];
<T_1>(as: readonly T_1[]): (bs: readonly T_1[]) => T_1[];
}, unionWith: {
<T>(pred: (a: T, b: T) => boolean, list1: readonly T[], list2: readonly T[]): T[];
<T_1>(pred: (a: T_1, b: T_1) => boolean): import("Function/Curry").Curry<(a: readonly T_1[], b: readonly T_1[]) => T_1[]>;
}, uniq: <T>(list: readonly T[]) => T[], uniqBy: {
<T, U>(fn: (a: T) => U, list: readonly T[]): T[];
<T_1, U_1>(fn: (a: T_1) => U_1): (list: readonly T_1[]) => T_1[];
}, uniqWith: {
<T, U>(pred: (x: T, y: T) => boolean, list: readonly T[]): T[];
<T_1, U_1>(pred: (x: T_1, y: T_1) => boolean): (list: readonly T_1[]) => T_1[];
}, unless: {
<T, U>(pred: (a: T) => boolean, whenFalseFn: (a: T) => U, obj: T): U;
<T_1, U_1>(pred: (a: T_1) => boolean, whenFalseFn: (a: T_1) => U_1): (obj: T_1) => U_1;
}, unnest: <T extends readonly any[]>(list: T) => import("Tuple/UnNest").UnNest<T>, until: {
<T, U>(pred: (val: T) => boolean, fn: (val: T) => U, init: U): U;
<T_1, U_1>(pred: (val: T_1) => boolean, fn: (val: T_1) => U_1): (init: U_1) => U_1;
}, update: {
<T>(index: number, value: T, list: readonly T[]): T[];
<T_1>(index: number, value: T_1): (list: readonly T_1[]) => T_1[];
}, useWith: (fn: (...a: readonly any[]) => any, transformers: ((...a: readonly any[]) => any)[]) => (...a: readonly any[]) => any, values: <T extends object, K extends keyof T>(obj: T) => T[K][], valuesIn: <T>(obj: any) => T[], view: {
<T, U>(lens: R.Lens): (obj: T) => U;
<T_1, U_1>(lens: R.Lens, obj: T_1): U_1;
}, when: {
<T, U>(pred: (a: T) => boolean, whenTrueFn: (a: T) => U, obj: T): U;
<T_1, U_1>(pred: (a: T_1) => boolean, whenTrueFn: (a: T_1) => U_1): (obj: T_1) => U_1;
}, where: {
<T, U>(spec: T, testObj: U): boolean;
<T_1>(spec: T_1): <U_1>(testObj: U_1) => boolean;
<ObjFunc2, U_2>(spec: ObjFunc2, testObj: U_2): boolean;
<ObjFunc2_1>(spec: ObjFunc2_1): <U_3>(testObj: U_3) => boolean;
}, whereEq: {
<T, U>(spec: T, obj: U): boolean;
<T_1>(spec: T_1): <U_1>(obj: U_1) => boolean;
}, without: {
<T>(list1: readonly T[], list2: readonly T[]): T[];
<T_1>(list1: readonly T_1[]): (list2: readonly T_1[]) => T_1[];
}, xprod: {
<K, V>(as: readonly K[], bs: readonly V[]): R.KeyValuePair<K, V>[];
<K_1>(as: readonly K_1[]): <V_1>(bs: readonly V_1[]) => R.KeyValuePair<K_1, V_1>[];
}, zip: {
<K, V>(list1: readonly K[], list2: readonly V[]): R.KeyValuePair<K, V>[];
<K_1>(list1: readonly K_1[]): <V_1>(list2: readonly V_1[]) => R.KeyValuePair<K_1, V_1>[];
}, zipObj: {
<T>(keys: readonly string[], values: readonly T[]): {
[index: string]: T;
};
(keys: readonly string[]): <T_1>(values: readonly T_1[]) => {
[index: string]: T_1;
};
<T_2>(keys: readonly number[], values: readonly T_2[]): {
[index: number]: T_2;
};
(keys: readonly number[]): <T_3>(values: readonly T_3[]) => {
[index: number]: T_3;
};
}, zipWith: {
<T, U, TResult>(fn: (x: T, y: U) => TResult, list1: readonly T[], list2: readonly U[]): TResult[];
<T_1, U_1, TResult_1>(fn: (x: T_1, y: U_1) => TResult_1, list1: readonly T_1[]): (list2: readonly U_1[]) => TResult_1[];
<T_2, U_2, TResult_2>(fn: (x: T_2, y: U_2) => TResult_2): (list1: readonly T_2[], list2: readonly U_2[]) => TResult_2[];
};
import * as my from './my';
export { R, my };

25

dist/index.js

@@ -13,22 +13,7 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
__export(require("./basic"));
__export(require("./eventhub"));
const R = __importStar(require("ramda"));
// export * from './node';
// export * from './rx';
__export(require("./eventhub"));
__export(require("./miniapp"));
__export(require("./basic"));
exports.__ = R.__, exports.F = R.F, exports.T = R.T, exports.add = R.add, exports.addIndex = R.addIndex, exports.adjust = R.adjust, exports.all = R.all, exports.allPass = R.allPass, exports.always = R.always, exports.and = R.and,
// andThen,
exports.any = R.any, exports.anyPass = R.anyPass, exports.ap = R.ap, exports.aperture = R.aperture, exports.append = R.append, exports.apply = R.apply, exports.applySpec = R.applySpec, exports.applyTo = R.applyTo, exports.ascend = R.ascend, exports.assoc = R.assoc, exports.assocPath = R.assocPath, exports.binary = R.binary, exports.bind = R.bind, exports.both = R.both, exports.call = R.call, exports.chain = R.chain, exports.clamp = R.clamp, exports.clone = R.clone, exports.comparator = R.comparator, exports.complement = R.complement, exports.compose = R.compose, exports.composeWith = R.composeWith, exports.concat = R.concat, exports.cond = R.cond, exports.construct = R.construct, exports.constructN = R.constructN, exports.converge = R.converge, exports.countBy = R.countBy, exports.curry = R.curry, exports.curryN = R.curryN, exports.dec = R.dec, exports.defaultTo = R.defaultTo, exports.descend = R.descend, exports.difference = R.difference, exports.differenceWith = R.differenceWith, exports.dissoc = R.dissoc, exports.dissocPath = R.dissocPath, exports.divide = R.divide, exports.drop = R.drop, exports.dropLast = R.dropLast, exports.dropLastWhile = R.dropLastWhile, exports.dropRepeats = R.dropRepeats, exports.dropRepeatsWith = R.dropRepeatsWith, exports.dropWhile = R.dropWhile, exports.either = R.either, exports.empty = R.empty, exports.endsWith = R.endsWith, exports.eqBy = R.eqBy, exports.eqProps = R.eqProps, exports.equals = R.equals, exports.evolve = R.evolve, exports.filter = R.filter, exports.find = R.find, exports.findIndex = R.findIndex, exports.findLast = R.findLast, exports.findLastIndex = R.findLastIndex, exports.flatten = R.flatten, exports.flip = R.flip, exports.forEach = R.forEach, exports.forEachObjIndexed = R.forEachObjIndexed, exports.fromPairs = R.fromPairs, exports.groupBy = R.groupBy, exports.groupWith = R.groupWith, exports.gt = R.gt, exports.gte = R.gte, exports.has = R.has, exports.hasIn = R.hasIn, exports.hasPath = R.hasPath, exports.head = R.head, exports.identical = R.identical, exports.identity = R.identity, exports.ifElse = R.ifElse, exports.inc = R.inc, exports.includes = R.includes,
// index,
exports.indexBy = R.indexBy, exports.indexOf = R.indexOf, exports.init = R.init, exports.innerJoin = R.innerJoin, exports.insert = R.insert, exports.insertAll = R.insertAll,
// internal,
exports.intersection = R.intersection, exports.intersperse = R.intersperse, exports.into = R.into, exports.invert = R.invert, exports.invertObj = R.invertObj, exports.invoker = R.invoker, exports.is = R.is, exports.isEmpty = R.isEmpty, exports.isNil = R.isNil, exports.join = R.join, exports.juxt = R.juxt, exports.keys = R.keys, exports.keysIn = R.keysIn, exports.last = R.last, exports.lastIndexOf = R.lastIndexOf, exports.length = R.length, exports.lens = R.lens, exports.lensIndex = R.lensIndex, exports.lensPath = R.lensPath, exports.lensProp = R.lensProp, exports.lift = R.lift, exports.liftN = R.liftN, exports.lt = R.lt, exports.lte = R.lte, exports.map = R.map, exports.mapAccum = R.mapAccum, exports.mapAccumRight = R.mapAccumRight, exports.mapObjIndexed = R.mapObjIndexed, exports.match = R.match, exports.mathMod = R.mathMod, exports.max = R.max, exports.maxBy = R.maxBy, exports.mean = R.mean, exports.median = R.median, exports.memoizeWith = R.memoizeWith, exports.mergeAll = R.mergeAll, exports.mergeDeepLeft = R.mergeDeepLeft, exports.mergeDeepRight = R.mergeDeepRight, exports.mergeDeepWith = R.mergeDeepWith, exports.mergeDeepWithKey = R.mergeDeepWithKey, exports.mergeLeft = R.mergeLeft, exports.mergeRight = R.mergeRight, exports.mergeWith = R.mergeWith, exports.mergeWithKey = R.mergeWithKey, exports.min = R.min, exports.minBy = R.minBy, exports.modulo = R.modulo, exports.move = R.move, exports.multiply = R.multiply, exports.nAry = R.nAry, exports.negate = R.negate, exports.none = R.none, exports.not = R.not, exports.nth = R.nth, exports.nthArg = R.nthArg, exports.o = R.o, exports.objOf = R.objOf, exports.of = R.of, exports.omit = R.omit, exports.once = R.once, exports.or = R.or, exports.otherwise = R.otherwise, exports.over = R.over, exports.pair = R.pair, exports.partial = R.partial, exports.partialRight = R.partialRight, exports.partition = R.partition, exports.path = R.path, exports.pathEq = R.pathEq, exports.pathOr = R.pathOr, exports.pathSatisfies = R.pathSatisfies,
// paths,
exports.pick = R.pick, exports.pickAll = R.pickAll, exports.pickBy = R.pickBy, exports.pipe = R.pipe, exports.pipeWith = R.pipeWith, exports.pluck = R.pluck, exports.prepend = R.prepend, exports.product = R.product, exports.project = R.project, exports.prop = R.prop, exports.propEq = R.propEq, exports.propIs = R.propIs, exports.propOr = R.propOr, exports.propSatisfies = R.propSatisfies, exports.props = R.props, exports.range = R.range, exports.reduce = R.reduce, exports.reduceBy = R.reduceBy, exports.reduceRight = R.reduceRight, exports.reduceWhile = R.reduceWhile, exports.reduced = R.reduced, exports.reject = R.reject, exports.remove = R.remove, exports.repeat = R.repeat, exports.replace = R.replace, exports.reverse = R.reverse, exports.scan = R.scan,
// sequence,
exports.set = R.set, exports.slice = R.slice, exports.sort = R.sort, exports.sortBy = R.sortBy, exports.sortWith = R.sortWith, exports.split = R.split, exports.splitAt = R.splitAt, exports.splitEvery = R.splitEvery, exports.splitWhen = R.splitWhen,
// splitWhenever,
exports.startsWith = R.startsWith, exports.subtract = R.subtract, exports.sum = R.sum, exports.symmetricDifference = R.symmetricDifference, exports.symmetricDifferenceWith = R.symmetricDifferenceWith, exports.tail = R.tail, exports.take = R.take, exports.takeLast = R.takeLast, exports.takeLastWhile = R.takeLastWhile, exports.takeWhile = R.takeWhile, exports.tap = R.tap, exports.test = R.test, exports.thunkify = R.thunkify, exports.times = R.times, exports.toLower = R.toLower, exports.toPairs = R.toPairs, exports.toPairsIn = R.toPairsIn, exports.toString = R.toString, exports.toUpper = R.toUpper, exports.transduce = R.transduce, exports.transpose = R.transpose, exports.traverse = R.traverse, exports.trim = R.trim, exports.tryCatch = R.tryCatch, exports.type = R.type, exports.unapply = R.unapply, exports.unary = R.unary, exports.uncurryN = R.uncurryN, exports.unfold = R.unfold, exports.union = R.union, exports.unionWith = R.unionWith, exports.uniq = R.uniq, exports.uniqBy = R.uniqBy, exports.uniqWith = R.uniqWith, exports.unless = R.unless, exports.unnest = R.unnest, exports.until = R.until, exports.update = R.update, exports.useWith = R.useWith, exports.values = R.values, exports.valuesIn = R.valuesIn, exports.view = R.view, exports.when = R.when, exports.where = R.where, exports.whereEq = R.whereEq, exports.without = R.without,
// xor,
exports.xprod = R.xprod, exports.zip = R.zip, exports.zipObj = R.zipObj, exports.zipWith = R.zipWith;
exports.R = R;
const my = __importStar(require("./my"));
exports.my = my;

2

package.json
{
"name": "jet-miniapp",
"version": "1.0.0",
"version": "2.0.0",
"description": "客户端sdk",

@@ -5,0 +5,0 @@ "main": "dist/index.js",

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc