@tempots/std 0.9.6 → 0.9.7

package/types/differentiate.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ */
+import { type AnyKey } from './utility';
+import { type ObjectWithField } from './objects';
+import { type Tail } from './tuples';
+export type Differentiate<Field extends AnyKey, State extends ObjectWithField<Field, any>, ExpectedType extends State[Field]> = State extends ObjectWithField<Field, ExpectedType> ? State : never;
+export type DifferentiateByKind<State extends {
+    kind: any;
+}, K extends State['kind']> = Differentiate<'kind', State, K>;
+export type DifferentiateAt<Path extends AnyKey[], State, ExpectedType> = Path extends [] ? State : Path extends [infer T] ? T extends keyof State ? ExpectedType extends State[T] ? Differentiate<T, State, ExpectedType> : never : never : Path extends [infer K, ...any[]] ? K extends keyof State ? Tail<Path> extends infer Rest ? Rest extends AnyKey[] ? State & {
+    [k in K]: DifferentiateAt<Rest, State[k], ExpectedType>;
+} : never : never : never : never;

package/types/differentiate.js

@@ -0,0 +1,14 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export {};

package/types/functions.d.ts

@@ -0,0 +1,22 @@
+import { type Tail } from './tuples';
+export type Equality<T> = (a: T, b: T) => boolean;
+export type Effect<T> = (value: T) => void;
+export type Proc = () => void;
+export type Lazy<T> = () => T;
+export type Fun = (...args: any[]) => any;
+export type Fun1<A, T> = (a1: A) => T;
+export type Fun2<A, B, T> = (a1: A, a2: B) => T;
+export type Fun3<A, B, C, T> = (a1: A, a2: B, a3: C) => T;
+export type Fun4<A, B, C, D, T> = (a1: A, a2: B, a3: C, a4: D) => T;
+export type Fun5<A, B, C, D, E, T> = (a1: A, a2: B, a3: C, a4: D, a5: E) => T;
+export type Fun6<A, B, C, D, E, F, T> = (a1: A, a2: B, a3: C, a4: D, a5: E, a6: F) => T;
+export type AnyFunction = Fun | Function;
+export type FirstArgument<F extends AnyFunction> = F extends (a: infer A) => any ? unknown extends A ? never : A : never;
+export type OnlyIfDoesNotReturnNever<F extends Fun> = F extends Fun1<any, never> ? never : F;
+type CheckFunctionsChain<In, Args extends Array<Fun1<any, any>>> = {
+    empty: (i: In) => In;
+    one: FirstArgument<Args[0]> extends In ? Args[0] : never;
+    n: FirstArgument<Args[0]> extends In ? (arg: FirstArgument<Args[0]>) => ReturnType<CheckFunctionsChain<ReturnType<Args[0]>, Tail<Args>>> : never;
+}[Args extends [] ? 'empty' : Args extends [any] ? 'one' : 'n'];
+export type FunctionsChain<In, Args extends Fun[]> = OnlyIfDoesNotReturnNever<CheckFunctionsChain<In, Args>>;
+export {};

package/types/functions.js

@@ -0,0 +1,13 @@
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export {};

package/types/generic.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ */
+import { type Equals, type NotEquals } from './assert';
+export type Pointer<T> = () => T;
+export type DeRef<T extends () => any> = T extends () => infer Ret ? Ret : never;
+export type WhenEquals<X, Y, A = X, B = never> = Equals<X, Y> extends true ? A : B;
+export type WhenNotEquals<X, Y, A = X, B = never> = NotEquals<X, Y> extends true ? A : B;
+export type Cast<A, B> = A extends B ? A : B;

package/types/generic.js

@@ -0,0 +1,13 @@
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export {};

package/types/objects.d.ts

@@ -0,0 +1,50 @@
+/**
+ *
+ */
+import { type AnyKey } from './utility';
+import { type Tail } from './tuples';
+import { type AnyFunction } from './functions';
+import { type WhenEquals } from './generic';
+export type ObjectWithField<F extends AnyKey, V> = {
+    [_ in F]: V;
+};
+export type ObjectWithPath<Path extends AnyKey[], V> = Path extends [] ? {} : Path extends [infer T] ? T extends AnyKey ? {
+    [_ in T]: V;
+} : never : Path extends [infer K, ...any[]] ? K extends AnyKey ? Tail<Path> extends infer Rest ? Rest extends AnyKey[] ? {
+    [_ in K]: ObjectWithPath<Rest, V>;
+} : never : never : never : never;
+export type TypeAtPath<Path extends AnyKey[], O> = {
+    next: Path extends [infer K, ...any[]] ? K extends AnyKey ? Tail<Path> extends infer Rest ? O extends Record<AnyKey, any> ? Rest extends AnyKey[] ? TypeAtPath<Rest, O[K]> : never : never : never : never : never;
+    empty: O;
+    done: O extends Record<AnyKey, any> ? Path extends [infer K] ? K extends AnyKey ? O[K] : never : never : never;
+}[Path extends [] ? 'empty' : Path extends [any] ? 'done' : 'next'];
+export type WritableKeys<T> = {
+    [K in keyof T]-?: WhenEquals<{
+        [Q in K]: T[K];
+    }, {
+        -readonly [Q in K]: T[K];
+    }, K>;
+}[keyof T];
+export type ReadonlyKeys<T> = {
+    [P in keyof T]-?: WhenEquals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }, never, P>;
+}[keyof T];
+export type Id<T> = {} & {
+    [P in keyof T]: T[P];
+};
+export type KeysWithFieldType<T, Condition> = {
+    [K in keyof T]: WhenEquals<T[K], Condition, K>;
+}[keyof T];
+export type KeysWithoutFieldType<T, Condition> = {
+    [K in keyof T]: WhenEquals<T[K], Condition, never, K>;
+}[keyof T];
+export type RemoveNullableFromFields<T> = {
+    [K in keyof T]: NonNullable<T[K]>;
+};
+export type WritableFields<T> = Pick<T, WritableKeys<T>>;
+export type ReadonlyFields<T> = Pick<T, ReadonlyKeys<T>>;
+export type ExcludeFunctionFields<T> = Pick<T, KeysWithoutFieldType<T, AnyFunction>>;
+export type Merge<A, B> = Id<A & B>;

package/types/objects.js

@@ -0,0 +1,13 @@
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export {};

package/types/tuples.d.ts

@@ -0,0 +1,44 @@
+/**
+ *
+ */
+import { type Pointer, type DeRef } from './generic';
+export type Tail<T extends any[]> = ((...args: T) => void) extends (_: any, ...rest: infer Rest) => void ? Rest : never;
+type DropNImpl<N extends number, T extends any[], I extends any[]> = {
+    return: T;
+    next: DropNImpl<N, Tail<T>, Prepend<any, I>>;
+}[Length<I> extends N ? 'return' : 'next'];
+export type DropN<N extends number, T extends any[]> = DropNImpl<N, T, []>;
+type ReverseImpl<T extends any[], R extends any[], I extends any[]> = {
+    return: DeRef<Pointer<R>>;
+    next: ReverseImpl<T, Prepend<T[Length<I>], R>, Prepend<any, I>>;
+}[Length<I> extends Length<T> ? 'return' : 'next'];
+export type Reverse<T extends any[]> = ReverseImpl<T, [], []>;
+export type Head<T extends any[]> = T extends [infer H, ...any[]] ? H : never;
+export type Last<T extends any[]> = {
+    n: Last<Tail<T>>;
+    one: T extends [infer H] ? H : never;
+    empty: never;
+}[T extends [] ? 'empty' : T extends [any] ? 'one' : 'n'];
+export type TupleToUnion<T extends any[]> = T[number];
+export type Prepend<Insert, Tail extends any[]> = [Insert, ...Tail];
+export type Append<Tuple extends any[], Element> = [...Tuple, Element];
+export type Length<T extends any[]> = T['length'];
+export type LoseLastImpl<A extends any[], B extends any[]> = {
+    empty: A;
+    next: LoseLastImpl<Prepend<B[0], A>, Tail<B>>;
+}[B extends [] ? 'empty' : B extends [any] ? 'empty' : 'next'];
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
+export type Push<T extends any[], V> = [...T, V];
+export type UnionToTuple<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple1<Exclude<T, L>>, L>;
+type UnionToTuple1<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple2<Exclude<T, L>>, L>;
+type UnionToTuple2<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple3<Exclude<T, L>>, L>;
+type UnionToTuple3<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple4<Exclude<T, L>>, L>;
+type UnionToTuple4<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple5<Exclude<T, L>>, L>;
+type UnionToTuple5<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple6<Exclude<T, L>>, L>;
+type UnionToTuple6<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple7<Exclude<T, L>>, L>;
+type UnionToTuple7<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple8<Exclude<T, L>>, L>;
+type UnionToTuple8<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple9<Exclude<T, L>>, L>;
+type UnionToTuple9<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTupleX<Exclude<T, L>>, L>;
+type UnionToTupleX<T> = never;
+export {};

package/types/tuples.js

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export {};
+// | _Concat_0_0
+// | _Concat_0_1
+// | _Concat_1_0
+// | _Concat_2_3
+// | _Pop_1
+// | _Pop_2
+// | _LoseLast_1
+// | _LoseLast_2
+// | _LoseLast_3
+// | _LoseLast_4

package/{src/types/utility.ts → types/utility.d.ts}

@@ -1,3 +1,2 @@
-export type AnyKey = string | number | symbol
-
-export type Primitive = string | boolean | number | null | undefined
+export type AnyKey = string | number | symbol;
+export type Primitive = string | boolean | number | null | undefined;

package/types/utility.js

@@ -0,0 +1 @@
+export {};

package/uuid.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Helper functions to generate and validate [UUID](http://en.wikipedia.org/wiki/Universally_unique_identifier)
+ * strings (version 4).
+ */
+import { type Newtype, NewtypeClass } from './newtype';
+/**
+ * `Uuid.create()` returns a string value representing a random UUID string.
+ */
+export declare function create(): UUID;
+export type UUID = Newtype<string, {
+    readonly UUID: unique symbol;
+}>;
+export declare const UUID: NewtypeClass<UUID>;

package/uuid.js

@@ -0,0 +1,56 @@
+/*
+Copyright 2019 Google LLC
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+/**
+ * Helper functions to generate and validate [UUID](http://en.wikipedia.org/wiki/Universally_unique_identifier)
+ * strings (version 4).
+ */
+import { NewtypeClass } from './newtype';
+const random = (max) => Math.floor(Math.random() * max);
+const srandom = () => '0123456789abcdef'.charAt(random(0x10));
+/**
+ * `Uuid.create()` returns a string value representing a random UUID string.
+ */
+export function create() {
+    const s = [];
+    let i = 0;
+    for (i = 0; i < 8; i++)
+        s[i] = srandom();
+    s[8] = '-';
+    for (i = 9; i < 13; i++)
+        s[i] = srandom();
+    s[13] = '-';
+    s[14] = '4';
+    for (i = 15; i < 18; i++)
+        s[i] = srandom();
+    s[18] = '-';
+    s[19] = '89AB'.charAt(random(0x3));
+    for (i = 20; i < 23; i++)
+        s[i] = srandom();
+    s[23] = '-';
+    for (i = 24; i < 36; i++)
+        s[i] = srandom();
+    return UUID.unsafeOf(s.join(''));
+}
+const pattern = /^[0123456789abcdef]{8}-[0123456789abcdef]{4}-4[0123456789abcdef]{3}-[89ab][0123456789abcdef]{3}-[0123456789abcdef]{12}$/i;
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const UUID = new (class extends NewtypeClass {
+    /**
+     * Returns `true` if the passed `uuid` conforms to the UUID v.4 format.
+     */
+    isValid(uuid) {
+        return pattern.test(uuid);
+    }
+    toString(uuid) {
+        return UUID.get(uuid);
+    }
+})();

package/validation.d.ts

@@ -0,0 +1,23 @@
+import { Result } from './result';
+export interface Valid {
+    type: 'valid';
+}
+export interface Invalid<E> {
+    type: 'invalid';
+    error: E;
+}
+export type Validation<E> = Valid | Invalid<E>;
+export type PromiseValidation<E> = PromiseLike<Validation<E>>;
+export declare const Validation: {
+    valid: {
+        type: "valid";
+    };
+    invalid<E>(error: E): Validation<E>;
+    isValid<E_1>(r: Validation<E_1>): r is Valid;
+    isInvalid<E_2>(r: Validation<E_2>): r is Invalid<E_2>;
+    cmatch: <V, E_3>(valid: () => V, invalid: (error: E_3) => V) => (r: Validation<E_3>) => V;
+    match: <V_1, E_4>(r: Validation<E_4>, valid: () => V_1, invalid: (error: E_4) => V_1) => V_1;
+    toResult: <T, E_5>(value: T) => (validation: Validation<E_5>) => Result<T, E_5>;
+    whenValid: <E_6>(apply: () => void) => (r: Validation<E_6>) => Validation<E_6>;
+    whenInvalid: <E_7>(apply: (e: E_7) => void) => (r: Validation<E_7>) => Validation<E_7>;
+};

package/validation.js

@@ -0,0 +1,44 @@
+import { Result } from './result';
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const Validation = {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    valid: { type: 'valid' },
+    invalid(error) {
+        return { type: 'invalid', error };
+    },
+    isValid(r) {
+        return r.type === 'valid';
+    },
+    isInvalid(r) {
+        return r.type === 'invalid';
+    },
+    cmatch: (valid, invalid) => (r) => {
+        if (Validation.isValid(r)) {
+            return valid();
+        }
+        else {
+            return invalid(r.error);
+        }
+    },
+    match: (r, valid, invalid) => {
+        if (Validation.isValid(r)) {
+            return valid();
+        }
+        else {
+            return invalid(r.error);
+        }
+    },
+    toResult: (value) => Validation.cmatch(() => Result.success(value), (err) => Result.failure(err)),
+    whenValid: (apply) => (r) => {
+        if (Validation.isValid(r)) {
+            apply();
+        }
+        return r;
+    },
+    whenInvalid: (apply) => (r) => {
+        if (Validation.isInvalid(r)) {
+            apply(r.error);
+        }
+        return r;
+    }
+};

package/src/arrays.ts

@@ -1,296 +0,0 @@
-/*
-Copyright 2019 Google LLC
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    https://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-/**
- * Utility functions to manipulate `Array` values.
- */
-
-import { Maybe } from './maybe'
-import { type Ordering, type Compare } from './ord'
-import { type Primitive } from './types/utility'
-import { keys } from './objects'
-
-export function map<A, B> (arr: A[], f: (a: A, index: number) => B): B[] {
-  return Array.from({ length: arr.length }, (_, i) => f(arr[i], i))
-}
-
-export function mapNotNull<A, B> (
-  arr: A[],
-  f: (a: A, index: number) => B | null | undefined
-): B[] {
-  const buff = [] as B[]
-  for (let i = 0; i < arr.length; i++) {
-    const v = f(arr[i], i)
-    if (v != null) {
-      buff.push(v)
-    }
-  }
-  return buff
-}
-
-export function flatMap<A, B> (arr: A[], f: (a: A) => B[]): B[] {
-  const buff = []
-  for (const el of arr) {
-    buff.push(...f(el))
-  }
-  return buff
-}
-
-export function head<A> (arr: A[]): Maybe<A> {
-  return arr.length > 0 ? arr[0] : Maybe.nothing
-}
-
-export function tail<A> (arr: A[]): A[] {
-  return arr.slice(1)
-}
-
-export function equals<T> (a: T[], b: T[], equality: (a: T, b: T) => boolean): boolean {
-  if (a.length !== b.length) return false
-  else {
-    for (let i = 0; i < a.length; i++) {
-      if (!equality(a[i], b[i])) return false
-    }
-    return true
-  }
-}
-
-export function makeEquals<T> (equality: (a: T, b: T) => boolean) {
-  return function (a: T[], b: T[]) {
-    return equals(a, b, equality)
-  }
-}
-
-export function isEmpty<T> (arr: T[]): arr is [] {
-  return arr.length === 0
-}
-
-export function hasValues<T> (arr: T[]): arr is [T, ...T[]] {
-  return arr.length > 0
-}
-
-export function filter<T> (arr: T[], predicate: (v: T) => boolean): T[] {
-  const buff = [] as T[]
-  for (const a of arr) if (predicate(a)) buff.push(a)
-  return buff
-}
-
-export function filterNulls<T> (arr: Array<T | null | undefined>): T[] {
-  return filter(arr, v => v != null) as T[]
-}
-
-export function flatten<T> (arr: T[][]): T[] {
-  return ([] as T[]).concat(...arr)
-}
-
-export function foldLeft<T, B> (arr: T[], f: (acc: B, curr: T) => B, b: B): B {
-  for (const a of arr) {
-    b = f(b, a)
-  }
-  return b
-}
-
-export function all<T> (arr: T[], predicate: (v: T) => boolean): boolean {
-  for (const a of arr) {
-    if (!predicate(a)) {
-      return false
-    }
-  }
-  return true
-}
-
-export function any<T> (arr: T[], predicate: (v: T) => boolean): boolean {
-  for (const a of arr) {
-    if (predicate(a)) {
-      return true
-    }
-  }
-  return false
-}
-
-export function each<T> (arr: T[], f: (v: T) => void): void {
-  for (const a of arr) f(a)
-}
-
-export function concat<A> (...arrs: A[][]): A[] {
-  return ([] as A[]).concat(...arrs)
-}
-
-export function makeCompare<A> (comparef: Compare<A>, shorterFirst = true) {
-  return function (a: A[], b: A[]) {
-    if (a.length < b.length) {
-      return -1 * (shorterFirst ? 1 : -1)
-    } else if (a.length > b.length) {
-      return 1 * (shorterFirst ? 1 : -1)
-    }
-    for (let i = 0; i < a.length; i++) {
-      const ord = comparef(a[i], b[i])
-      if (ord !== 0) return ord
-    }
-    return 0
-  }
-}
-
-export function sort<A> (compare: (a: A, b: A) => Ordering, arr: A[]): A[] {
-  return arr.slice().sort(compare)
-}
-
-export function range<A> (length: number, f: (index: number) => A): A[] {
-  return Array.from({ length }, (_, i) => f(i))
-}
-
-export function numbersRange (length: number, startAt = 0): number[] {
-  return range(length, i => startAt + i)
-}
-
-export function fill<A> (length: number, value: A): A[] {
-  return range(length, () => value)
-}
-
-export function distinctPrimitive<T extends Primitive> (values: T[]): T[] {
-  return Array.from(new Set(values))
-}
-
-export function distinctByPredicate<T> (
-  values: T[],
-  predicate: (a: T) => string
-): T[] {
-  const map: Record<string, T> = {}
-  values.forEach(v => {
-    map[predicate(v)] = v
-  })
-  return keys(map).map(k => map[k])
-}
-
-export function remove<A> (
-  arr: A[],
-  item: A,
-  predicate?: (a: A) => boolean
-): boolean {
-  let index
-  if (predicate !== undefined) {
-    index = arr.findIndex(predicate)
-  } else {
-    index = arr.indexOf(item)
-  }
-  if (index < 0) {
-    return false
-  } else {
-    arr.splice(index, 1)
-    return true
-  }
-}
-
-export function ofIterableIterator<A> (it: IterableIterator<A>): A[] {
-  const buff = [] as A[]
-  for (let r = it.next(); !(r.done ?? false); r = it.next()) {
-    buff.push(r.value)
-  }
-  return buff
-}
-
-export interface DiffOperations<T> {
-  removals: Array<{ at: number, qt: number }>
-  swaps: Array<{ from: number, to: number }>
-  inserts: Array<{ at: number, values: T[] }>
-}
-
-export function diffOperations<T, K> (
-  from: T[],
-  to: T[],
-  getKey: (v: T) => K
-): DiffOperations<T> {
-  const ops: DiffOperations<T> = {
-    removals: [],
-    swaps: [],
-    inserts: []
-  }
-  const { removals, inserts, swaps } = ops
-  const mapB = new Map<K, number>()
-  to.forEach((v, i) => mapB.set(getKey(v), i))
-
-  const indexesOfAThatDoNotExistInB = from
-    .map((v, i) => [v, i] as const)
-    .filter(([v]) => !mapB.has(getKey(v)))
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    .map(([_, i]) => i)
-  for (let i = indexesOfAThatDoNotExistInB.length - 1; i >= 0; i--) {
-    const p = indexesOfAThatDoNotExistInB[i]
-    const last = removals.length > 0 ? removals[removals.length - 1] : undefined
-    if ((last != null) && last.at === p + 1) {
-      last.at--
-      last.qt++
-    } else {
-      removals.push({ at: p, qt: 1 })
-    }
-  }
-
-  const mapA = new Map<K, number>()
-  from.forEach((v, i) => mapA.set(getKey(v), i))
-
-  const indexesOfBThatDoNotExistInA = to
-    .map((v, i) => [v, i] as const)
-    .filter(([v]) => !mapA.has(getKey(v)))
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    .map(([_, i]) => i)
-  for (const p of indexesOfBThatDoNotExistInA) {
-    const last = inserts.length > 0 ? inserts[inserts.length - 1] : undefined
-    if ((last != null) && last.at + last.values.length === p) {
-      last.values.push(to[p])
-    } else {
-      inserts.push({ at: p, values: [to[p]] })
-    }
-  }
-
-  const ra = from.filter((_, i) => !indexesOfAThatDoNotExistInB.includes(i))
-  const mapRA = new Map<K, number>()
-  for (let i = 0; i < ra.length; i++) {
-    mapRA.set(getKey(ra[i]), i)
-  }
-
-  const rb = to.filter((_, i) => !indexesOfBThatDoNotExistInA.includes(i))
-  for (let i = 0; i < rb.length; i++) {
-    const bk = getKey(rb[i])
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const ai = mapRA.get(bk)!
-    if (ai == null || i === ai) continue
-    const ak = getKey(ra[i])
-    mapRA.delete(ak)
-    swaps.push({ from: i, to: ai })
-  }
-  return ops
-}
-
-export function applyOperations<T> (
-  operations: DiffOperations<T>,
-  start: T[]
-): T[] {
-  const buff = [...start]
-  for (const { at, qt } of operations.removals) {
-    buff.splice(at, qt)
-  }
-  for (const { from, to } of operations.swaps) {
-    const t = buff[to]
-    buff[to] = buff[from]
-    buff[from] = t
-  }
-  for (const op of operations.inserts) {
-    buff.splice(op.at, 0, ...op.values)
-  }
-  return buff
-}
-
-export function joinWithConjunction<A> (arr: A[], conjunction = ' and ', separator = ', '): string {
-  if (arr.length === 0) return ''
-  if (arr.length === 1) return String(arr[0])
-  return `${arr.slice(0, -1).join(separator)}${conjunction}${String(arr[arr.length - 1])}`
-}