@tempots/std 0.11.0 → 0.12.0

package/array.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const y=require("./maybe.cjs"),M=require("./object.cjs");function q(t,e){return Array.from({length:t.length},(n,r)=>e(t[r],r))}function E(t,e){const n=[];for(let r=0;r<t.length;r++){const i=e(t[r],r);i!=null&&n.push(i)}return n}function j(t,e){const n=[];for(const r of t)n.push(...e(r));return n}function w(t){return t.length>0?y.Maybe.just(t[0]):y.Maybe.nothing}function A(t){return t.slice(1)}function b(t,e,n){if(t.length!==e.length)return!1;for(let r=0;r<t.length;r++)if(!n(t[r],e[r]))return!1;return!0}function N(t){return function(e,n){return b(e,n,t)}}function O(t){return t.length===0}function B(t){return t.length>0}function k(t,e){const n=[];for(const r of t)e(r)&&n.push(r);return n}function I(t,e){const n=[];for(let r=0;r<t.length;r++){const i=e(t[r],r);i!=null&&n.push(i)}return n}function P(t){return k(t,e=>e!=null)}function _(t){return[].concat(...t)}function S(t,e,n){for(const r of t)n=e(n,r);return n}function C(t,e){for(const n of t)if(!e(n))return!1;return!0}function R(t,e){for(const n of t)if(e(n))return!0;return!1}function T(t,e){for(const n of t)e(n)}function $(...t){return[].concat(...t)}function D(t,e=!0){return function(n,r){if(n.length<r.length)return-1*(e?1:-1);if(n.length>r.length)return 1*(e?1:-1);for(let i=0;i<n.length;i++){const u=t(n[i],r[i]);if(u!==0)return u}return 0}}function L(t,e){return e.slice().sort(t)}function d(t,e){return Array.from({length:t},(n,r)=>e(r))}function V(t,e=0){return d(t,n=>e+n)}function W(t,e){return d(t,()=>e)}function z(t){return Array.from(new Set(t))}function G(t,e){const n={};return t.forEach(r=>{n[e(r)]=r}),M.keys(n).map(r=>n[r])}function H(t,e){const n=t.indexOf(e);return n<0?!1:(t.splice(n,1),!0)}function J(t,e){const n=t.findIndex(e);return n<0?!1:(t.splice(n,1),!0)}function Q(t){const e=[];for(let n=t.next();!(n.done??!1);n=t.next())e.push(n.value);return e}function U(t,e,n){const r={removals:[],swaps:[],inserts:[]},{removals:i,inserts:u,swaps:a}=r,l=new Map;e.forEach((o,f)=>l.set(n(o),f));const s=t.map((o,f)=>[o,f]).filter(([o])=>!l.has(n(o))).map(([o,f])=>f);for(let o=s.length-1;o>=0;o--){const f=s[o],c=i.length>0?i[i.length-1]:void 0;c!=null&&c.at===f+1?(c.at--,c.qt++):i.push({at:f,qt:1})}const h=new Map;t.forEach((o,f)=>h.set(n(o),f));const g=e.map((o,f)=>[o,f]).filter(([o])=>!h.has(n(o))).map(([o,f])=>f);for(const o of g){const f=u.length>0?u[u.length-1]:void 0;f!=null&&f.at+f.values.length===o?f.values.push(e[o]):u.push({at:o,values:[e[o]]})}const p=t.filter((o,f)=>!s.includes(f)),m=new Map;for(let o=0;o<p.length;o++)m.set(n(p[o]),o);const v=e.filter((o,f)=>!g.includes(f));for(let o=0;o<v.length;o++){const f=n(v[o]),c=m.get(f);if(c==null||o===c)continue;const x=n(p[o]);m.delete(x),a.push({from:o,to:c})}return r}function X(t,e){const n=[...e];for(const{at:r,qt:i}of t.removals)n.splice(r,i);for(const{from:r,to:i}of t.swaps){const u=n[i];n[i]=n[r],n[r]=u}for(const r of t.inserts)n.splice(r.at,0,...r.values);return n}function Y(t,e=" and ",n=", "){return t.length===0?"":t.length===1?String(t[0]):`${t.slice(0,-1).join(n)}${e}${String(t[t.length-1])}`}function Z(t,e,n=!0){const r=t.map((l,s)=>[l,s]);r.sort((l,s)=>e(l[0],s[0]));const i=new Array(r.length);let u=0,a=r[0][0];for(let l=0;l<r.length;l++){const[s,h]=r[l];e(s,a)!==0&&(u=l,a=s),i[h]=u,n&&u++}return i}exports.all=C;exports.any=R;exports.applyOperations=X;exports.concat=$;exports.diffOperations=U;exports.distinctByPredicate=G;exports.distinctPrimitive=z;exports.each=T;exports.equals=b;exports.fill=W;exports.filter=k;exports.filterMap=I;exports.filterNulls=P;exports.flatMap=j;exports.flatten=_;exports.foldLeft=S;exports.hasValues=B;exports.head=w;exports.isEmpty=O;exports.joinWithConjunction=Y;exports.makeCompare=D;exports.makeEquals=N;exports.map=q;exports.mapNotNull=E;exports.numbersRange=V;exports.ofIterableIterator=Q;exports.range=d;exports.rank=Z;exports.remove=H;exports.removeByPredicate=J;exports.sort=L;exports.tail=A;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const q=require("./object.cjs");function x(r,t){return Array.from({length:r.length},(e,n)=>t(r[n],n))}function F(r,t){const e=[];for(const n of r)e.push(...t(n));return e}function w(r){return r.length>0?r[0]:void 0}function B(r){return r.slice(1)}function P(r,t,e){if(r.length!==t.length)return!1;for(let n=0;n<r.length;n++)if(!e(r[n],t[n]))return!1;return!0}function b(r){return r.length===0}function j(r){return r.length>0}function g(r,t){const e=[];for(const n of r)t(n)&&e.push(n);return e}function M(r,t){const e=[];for(let n=0;n<r.length;n++){const l=t(r[n],n);l!=null&&e.push(l)}return e}function I(r){return g(r,t=>t!=null)}function S(r){return[].concat(...r)}function k(r,t,e){for(const n of r)e=t(e,n);return e}function D(r,t){for(const e of r)if(!t(e))return!1;return!0}function _(r,t){for(const e of r)if(t(e))return!0;return!1}function T(r,t){for(const e of r)t(e)}function H(...r){return[].concat(...r)}function N(r,t,e,n=!0){if(r.length<t.length)return-1*(n?1:-1);if(r.length>t.length)return 1*(n?1:-1);for(let l=0;l<r.length;l++){const f=e(r[l],t[l]);if(f!==0)return f}return 0}function $(r,t){return r.slice().sort(t)}function p(r,t){return Array.from({length:r},(e,n)=>t(n))}function C(r,t=0){return p(r,e=>t+e)}function L(r,t){return p(r,()=>t)}function V(r){return Array.from(new Set(r))}function W(r,t){const e={};return r.forEach(n=>{e[t(n)]=n}),q.objectKeys(e).map(n=>e[n])}function v(r,t){const e=r.indexOf(t);return e<0?!1:(r.splice(e,1),!0)}function R(r,t){let e=!1;for(;v(r,t);)e=!0;return e}function E(r,t){const e=r.findIndex(t);return e<0?!1:(r.splice(e,1),!0)}function z(r,t){let e=!1;for(;E(r,t);)e=!0;return e}function G(r){const t=[];for(let e=r.next();!(e.done??!1);e=r.next())t.push(e.value);return t}function J(r,t,e){const n={removals:[],swaps:[],inserts:[]},{removals:l,inserts:f,swaps:c}=n,i=new Map;t.forEach((a,o)=>i.set(e(a),o));const u=r.map((a,o)=>[a,o]).filter(([a])=>!i.has(e(a))).map(([a,o])=>o);for(let a=u.length-1;a>=0;a--){const o=u[a],s=l.length>0?l[l.length-1]:void 0;s!=null&&s.at===o+1?(s.at--,s.qt++):l.push({at:o,qt:1})}const y=new Map;r.forEach((a,o)=>y.set(e(a),o));const h=t.map((a,o)=>[a,o]).filter(([a])=>!y.has(e(a))).map(([a,o])=>o);for(const a of h){const o=f.length>0?f[f.length-1]:void 0;o!=null&&o.at+o.values.length===a?o.values.push(t[a]):f.push({at:a,values:[t[a]]})}const A=r.filter((a,o)=>!u.includes(o)),m=new Map;for(let a=0;a<A.length;a++)m.set(e(A[a]),a);const d=t.filter((a,o)=>!h.includes(o));for(let a=0;a<d.length;a++){const o=e(d[a]),s=m.get(o);if(s==null||a===s)continue;const O=e(A[a]);m.delete(O),c.push({from:a,to:s})}return n}function Q(r,t){const e=[...t];for(const{at:n,qt:l}of r.removals)e.splice(n,l);for(const{from:n,to:l}of r.swaps){const f=e[l];e[l]=e[n],e[n]=f}for(const n of r.inserts)e.splice(n.at,0,...n.values);return e}function U(r,t=" and ",e=", "){return r.length===0?"":r.length===1?String(r[0]):`${r.slice(0,-1).join(e)}${t}${String(r[r.length-1])}`}function X(r,t,e=!0){const n=r.map((i,u)=>[i,u]);n.sort((i,u)=>t(i[0],u[0]));const l=new Array(n.length);let f=0,c=n[0][0];for(let i=0;i<n.length;i++){const[u,y]=n[i];t(u,c)!==0&&(f=i,c=u),l[y]=f,e&&f++}return l}exports.allElements=D;exports.anyElement=_;exports.applyArrayDiffOperations=Q;exports.areArraysEqual=P;exports.arrayDiffOperations=J;exports.arrayHasValues=j;exports.arrayHead=w;exports.arrayOfIterableIterator=G;exports.arrayTail=B;exports.compareArrays=N;exports.concatArrays=H;exports.createFilledArray=L;exports.filterArray=g;exports.filterMapArray=M;exports.filterNullsFromArray=I;exports.flatMapArray=F;exports.flattenArray=S;exports.foldLeftArray=k;exports.forEachElement=T;exports.generateArray=p;exports.generateSequenceArray=C;exports.isArrayEmpty=b;exports.joinArrayWithConjunction=U;exports.mapArray=x;exports.rankArray=X;exports.removeAllFromArray=R;exports.removeAllFromArrayByPredicate=z;exports.removeOneFromArray=v;exports.removeOneFromArrayByPredicate=E;exports.sortArray=$;exports.uniqueByPredicate=W;exports.uniquePrimitives=V;

package/array.d.ts

@@ -1,35 +1,312 @@
-import { Maybe } from './maybe';
-import { Compare, Primitive } from './domain';
+import { Compare, Maybe, Nothing, Primitive } from './domain';
 
-export declare function map<A, B>(arr: A[], f: (a: A, index: number) => B): B[];
-export declare function mapNotNull<A, B>(arr: A[], f: (a: A, index: number) => B | null | undefined): B[];
-export declare function flatMap<A, B>(arr: A[], f: (a: A) => B[]): B[];
-export declare function head<A>(arr: A[]): Maybe<A>;
-export declare function tail<A>(arr: A[]): A[];
-export declare function equals<T>(a: T[], b: T[], equality: (a: T, b: T) => boolean): boolean;
-export declare function makeEquals<T>(equality: (a: T, b: T) => boolean): (a: T[], b: T[]) => boolean;
-export declare function isEmpty<T>(arr: T[]): arr is [];
-export declare function hasValues<T>(arr: T[]): arr is [T, ...T[]];
-export declare function filter<T>(arr: T[], predicate: (v: T) => boolean): T[];
-export declare function filterMap<A, B>(arr: A[], f: (a: A, index: number) => Maybe<B>): B[];
-export declare function filterNulls<T>(arr: Array<T | null | undefined>): T[];
-export declare function flatten<T>(arr: T[][]): T[];
-export declare function foldLeft<T, B>(arr: T[], f: (acc: B, curr: T) => B, b: B): B;
-export declare function all<T>(arr: T[], predicate: (v: T) => boolean): boolean;
-export declare function any<T>(arr: T[], predicate: (v: T) => boolean): boolean;
-export declare function each<T>(arr: T[], f: (v: T) => void): void;
-export declare function concat<A>(...arrs: A[][]): A[];
-export declare function makeCompare<A>(comparef: Compare<A>, shorterFirst?: boolean): (a: A[], b: A[]) => number;
-export declare function sort<A>(compare: Compare<A>, arr: A[]): A[];
-export declare function range<A>(length: number, f: (index: number) => A): A[];
-export declare function numbersRange(length: number, startAt?: number): number[];
-export declare function fill<A>(length: number, value: A): A[];
-export declare function distinctPrimitive<T extends Primitive>(values: T[]): T[];
-export declare function distinctByPredicate<T>(values: T[], predicate: (a: T) => string): T[];
-export declare function remove<A>(arr: A[], item: A): boolean;
-export declare function removeByPredicate<A>(arr: A[], predicate: (a: A) => boolean): boolean;
-export declare function ofIterableIterator<A>(it: IterableIterator<A>): A[];
-export interface DiffOperations<T> {
+/**
+ * Applies a function to each element of an array and returns a new array with the results.
+ *
+ * @typeParam A - The type of the elements in the input array.
+ * @typeParam B - The type of the elements in the output array.
+ * @param arr - The input array.
+ * @param f - The function to apply to each element.
+ * @returns The new array with the results of applying the function to each element.
+ * @category manipulation
+ * @public
+ */
+export declare function mapArray<A, B>(arr: A[], f: (a: A, index: number) => B): B[];
+/**
+ * Applies a mapping function to each element of an array and flattens the result.
+ *
+ * @param arr - The input array.
+ * @param f - The mapping function to apply to each element of the array.
+ * @returns A new array with the flattened result of applying the mapping function to each element of the input array.
+ * @typeParam A - The type of the elements in the input array.
+ * @typeParam B - The type of the elements in the resulting flattened array.
+ * @category manipulation
+ * @public
+ */
+export declare function flatMapArray<A, B>(arr: A[], f: (a: A) => B[]): B[];
+/**
+ * Returns the first element of an array, or `undefined` if the array is empty.
+ *
+ * @param arr - The input array.
+ * @returns The first element of the array, or `undefined` if the array is empty.
+ * @typeParam A - The type of elements in the array.
+ * @category access
+ * @public
+ */
+export declare function arrayHead<A>(arr: A[]): Maybe<A>;
+/**
+ * Returns a new array containing all elements of the input array except for the first element.
+ *
+ * @param arr - The input array.
+ * @returns A new array containing all elements of the input array except for the first element.
+ * @category access
+ * @public
+ */
+export declare function arrayTail<A>(arr: A[]): A[];
+/**
+ * Checks if two arrays are equal based on a custom equality function.
+ *
+ * @typeParam T - The type of elements in the arrays.
+ * @param a - The first array.
+ * @param b - The second array.
+ * @param equality - The custom equality function to compare elements.
+ * @returns Returns `true` if the arrays are equal, `false` otherwise.
+ * @category comparison
+ * @public
+ */
+export declare function areArraysEqual<T>(a: T[], b: T[], equality: (a: T, b: T) => boolean): boolean;
+/**
+ * Checks if an array is empty.
+ *
+ * @param arr - The array to check.
+ * @returns `true` if the array is empty, `false` otherwise.
+ * @category query
+ * @public
+ */
+export declare function isArrayEmpty<T>(arr: T[]): arr is [];
+/**
+ * Checks if an array has values.
+ *
+ * @param arr - The array to check.
+ * @returns `true` if the array has values, `false` otherwise.
+ * @category query
+ * @public
+ */
+export declare function arrayHasValues<T>(arr: T[]): arr is [T, ...T[]];
+/**
+ * Filters the elements of an array based on a predicate function.
+ *
+ * @typeParam T - The type of the elements in the array.
+ * @param arr - The array to filter.
+ * @param predicate - The predicate function used to filter the elements.
+ * @returns The filtered array.
+ * @category manipulation
+ * @public
+ */
+export declare function filterArray<T>(arr: T[], predicate: (v: T) => boolean): T[];
+/**
+ * Applies a mapping function to each element of an array and returns a new array
+ * containing the mapped values, excluding any `null` or `undefined` values.
+ *
+ * @typeParam A - The type of the elements in the input array.
+ * @typeParam B - The type of the elements in the output array.
+ * @param arr - The input array.
+ * @param f - The mapping function to apply to each element.
+ * @returns The new array containing the mapped values.
+ * @category manipulation
+ * @public
+ */
+export declare function filterMapArray<A, B>(arr: A[], f: (a: A, index: number) => Maybe<B>): B[];
+/**
+ * Filters out null and undefined values from an array.
+ *
+ * @typeParam T - The type of elements in the array.
+ * @param arr - The array to filter.
+ * @returns The filtered array.
+ * @category manipulation
+ * @public
+ */
+export declare function filterNullsFromArray<T>(arr: Array<T | Nothing>): T[];
+/**
+ * Flattens a two-dimensional array into a one-dimensional array.
+ *
+ * @param arr - The two-dimensional array to flatten.
+ * @returns The flattened one-dimensional array.
+ * @typeParam T - The type of elements in the array.
+ * @category manipulation
+ * @public
+ */
+export declare function flattenArray<T>(arr: T[][]): T[];
+/**
+ * Applies a function to each element of an array, accumulating the result from left to right.
+ *
+ * @typeParam T - The type of the array elements.
+ * @typeParam B - The type of the accumulator.
+ * @param arr - The array to iterate over.
+ * @param f - The function to apply to each element.
+ * @param b - The initial value of the accumulator.
+ * @returns The accumulated result.
+ * @category manipulation
+ * @public
+ */
+export declare function foldLeftArray<T, B>(arr: T[], f: (acc: B, curr: T) => B, b: B): B;
+/**
+ * Checks if all elements in an array satisfy a given predicate.
+ *
+ * @param arr - The array to check.
+ * @param predicate - The predicate function to apply to each element.
+ * @returns `true` if all elements satisfy the predicate, `false` otherwise.
+ * @typeParam T - The type of elements in the array.
+ * @category query
+ * @public
+ */
+export declare function allElements<T>(arr: T[], predicate: (v: T) => boolean): boolean;
+/**
+ * Checks if any element in the array satisfies the given predicate.
+ *
+ * @param arr - The array to check.
+ * @param predicate - The predicate function to apply to each element.
+ * @returns `true` if any element satisfies the predicate, `false` otherwise.
+ * @typeParam T - The type of elements in the array.
+ * @category query
+ * @public
+ */
+export declare function anyElement<T>(arr: T[], predicate: (v: T) => boolean): boolean;
+/**
+ * Applies a function to each element in an array.
+ *
+ * @typeParam T - The type of elements in the array.
+ * @param arr - The array to iterate over.
+ * @param f - The function to apply to each element.
+ * @category effect
+ * @public
+ */
+export declare function forEachElement<T>(arr: T[], f: (v: T) => void): void;
+/**
+ * Concatenates multiple arrays into a single array.
+ *
+ * @param arrs - The arrays to concatenate.
+ * @returns The concatenated array.
+ * @typeParam A - The type of elements in the arrays.
+ * @category manipulation
+ * @public
+ */
+export declare function concatArrays<A>(...arrs: A[][]): A[];
+/**
+ * Compares two arrays based on their lengths and element values.
+ *
+ * @typeParam A - The type of elements in the arrays.
+ * @param a - The first array to compare.
+ * @param b - The second array to compare.
+ * @param comparef - The compare function to use for comparing the elements of the arrays.
+ * @param shorterFirst - Optional. Specifies whether shorter arrays should be considered smaller. Defaults to true.
+ * @returns A compare function that can be used to compare arrays.
+ * @category comparison
+ * @public
+ */
+export declare function compareArrays<A>(a: A[], b: A[], comparef: Compare<A>, shorterFirst?: boolean): number;
+/**
+ * Sorts an array in place using the provided compare function.
+ *
+ * @typeParam A - The type of elements in the array.
+ * @param arr - The array to be sorted.
+ * @param compare - The compare function used to determine the order of the elements.
+ * @returns The sorted array.
+ * @category manipulation
+ * @public
+ */
+export declare function sortArray<A>(arr: A[], compare: Compare<A>): A[];
+/**
+ * Generates an array of values by applying a function to each index.
+ *
+ * @param length - The length of the resulting array.
+ * @param f - The function to apply to each index. It takes the index as a parameter and returns the corresponding value.
+ * @returns An array of values generated by applying the function to each index.
+ * @category creation
+ * @public
+ */
+export declare function generateArray<A>(length: number, f: (index: number) => A): A[];
+/**
+ * Generates an array of numbers in a specified range.
+ *
+ * @param length - The length of the array to generate.
+ * @param startAt - The starting value of the range. Default is 0.
+ * @returns An array of numbers in the specified range.
+ * @category creation
+ * @public
+ */
+export declare function generateSequenceArray(length: number, startAt?: number): number[];
+/**
+ * Creates a new array with the specified length and fills it with the provided value.
+ *
+ * @typeParam A - The type of the elements in the array.
+ * @param length - The length of the new array.
+ * @param value - The value to fill the array with.
+ * @returns A new array filled with the specified value.
+ * @category creation
+ * @public
+ */
+export declare function createFilledArray<A>(length: number, value: A): A[];
+/**
+ * Returns an array containing only the distinct primitive values from the input array.
+ *
+ * @typeParam T - The type of the input array elements.
+ * @param values - The input array.
+ * @returns An array containing only the distinct primitive values from the input array.
+ * @category manipulation
+ * @public
+ */
+export declare function uniquePrimitives<T extends Primitive>(values: T[]): T[];
+/**
+ * Returns an array of distinct elements from the input array based on the provided predicate.
+ *
+ * @typeParam T - The type of elements in the input array.
+ * @param values - The input array.
+ * @param predicate - The predicate function used to determine uniqueness.
+ * @returns An array of distinct elements.
+ * @category manipulation
+ * @public
+ */
+export declare function uniqueByPredicate<T>(values: T[], predicate: (a: T) => string): T[];
+/**
+ * Removes the first occurrence of an item from an array.
+ *
+ * @typeParam A - The type of the array elements.
+ * @param arr - The array from which to remove the item.
+ * @param item - The item to remove from the array.
+ * @returns `true` if the item was found and removed, `false` otherwise.
+ * @category mutation
+ * @public
+ */
+export declare function removeOneFromArray<A>(arr: A[], item: A): boolean;
+/**
+ * Removes all occurrences of an item from an array.
+ *
+ * @typeParam A - The type of the array elements.
+ * @param arr - The array from which to remove the item.
+ * @param item - The item to remove from the array.
+ * @returns `true` if at least one occurrence was found and removed, `false` otherwise.
+ * @category mutation
+ * @public
+ */
+export declare function removeAllFromArray<A>(arr: A[], item: A): boolean;
+/**
+ * Removes the first occurrence in an array that satisfy the given predicate.
+ *
+ * @typeParam A - The type of elements in the array.
+ * @param arr - The array from which elements will be removed.
+ * @param predicate - The predicate function used to determine which elements to remove.
+ * @returns `true` if at least one element was removed, `false` otherwise.
+ * @category mutation
+ * @public
+ */
+export declare function removeOneFromArrayByPredicate<A>(arr: A[], predicate: (a: A) => boolean): boolean;
+/**
+ * Removes all occurrences in an array that satisfy the given predicate.
+ *
+ * @typeParam A - The type of elements in the array.
+ * @param arr - The array from which elements will be removed.
+ * @param predicate - The predicate function used to determine which elements to remove.
+ * @returns `true` if at least one element was removed, `false` otherwise.
+ * @category mutation
+ * @public
+ */
+export declare function removeAllFromArrayByPredicate<A>(arr: A[], predicate: (a: A) => boolean): boolean;
+/**
+ * Converts an IterableIterator to an array.
+ *
+ * @param it - The IterableIterator to convert.
+ * @returns An array containing the values from the IterableIterator.
+ * @category creation
+ * @public
+ */
+export declare function arrayOfIterableIterator<A>(it: IterableIterator<A>): A[];
+/**
+ * Represents the different operations that can be performed on an array.
+ *
+ * @public
+ */
+export interface ArrayDiffOperations<T> {
     removals: Array<{
         at: number;
         qt: number;
@@ -43,7 +320,52 @@ export interface DiffOperations<T> {
         values: T[];
     }>;
 }
-export declare function diffOperations<T, K>(from: T[], to: T[], getKey: (v: T) => K): DiffOperations<T>;
-export declare function applyOperations<T>(operations: DiffOperations<T>, start: T[]): T[];
-export declare function joinWithConjunction<A>(arr: A[], conjunction?: string, separator?: string): string;
-export declare function rank<T>(array: T[], compare: (a: T, b: T) => number, incrementDuplicates?: boolean): number[];
+/**
+ * Calculates the difference operations between two arrays based on a key function.
+ *
+ * @typeParam T - The type of elements in the arrays.
+ * @typeParam K - The type of the key used to compare elements.
+ * @param from - The source array.
+ * @param to - The target array.
+ * @param getKey - The key function used to compare elements.
+ * @returns The difference operations between the two arrays.
+ * @category manipulation
+ * @public
+ */
+export declare function arrayDiffOperations<T, K>(from: T[], to: T[], getKey: (v: T) => K): ArrayDiffOperations<T>;
+/**
+ * Applies a series of operations to an array and returns the modified array.
+ *
+ * @typeParam T - The type of elements in the array.
+ * @param operations - The operations to apply.
+ * @param start - The initial array.
+ * @returns The modified array after applying the operations.
+ * @category manipulation
+ * @public
+ */
+export declare function applyArrayDiffOperations<T>(operations: ArrayDiffOperations<T>, start: T[]): T[];
+/**
+ * Joins an array of values into a string using a conjunction and separator.
+ *
+ * @param arr - The array of values to join.
+ * @param conjunction - The conjunction to use between the second-to-last and last value. Default is ' and '.
+ * @param separator - The separator to use between each value. Default is ', '.
+ * @returns The joined string.
+ * @category transformation
+ * @public
+ */
+export declare function joinArrayWithConjunction<A>(arr: A[], conjunction?: string, separator?: string): string;
+/**
+ * Assigns ranks to the elements in the array based on the provided compare function.
+ * The ranks are assigned in ascending order, with the lowest value receiving a rank of 0.
+ * If there are duplicate values, the rank of the duplicates can be incremented or not based on the `incrementDuplicates` parameter.
+ *
+ * @typeParam T - The type of elements in the array.
+ * @param array - The array to rank.
+ * @param compare - The compare function used to determine the order of elements.
+ * @param incrementDuplicates - Whether to increment the rank of duplicate values.
+ * @returns An array of ranks corresponding to the elements in the input array.
+ * @category transformation
+ * @public
+ */
+export declare function rankArray<T>(array: T[], compare: (a: T, b: T) => number, incrementDuplicates?: boolean): number[];