@silvermine/toolbox 0.3.0 → 0.5.0

package/dist/types/utils/is-object.d.ts

@@ -9,4 +9,4 @@
  * @see https://github.com/jashkenas/underscore/blob/d5fe0fd4060f13b40608cb9d92eda6d857e8752c/underscore.js#L1322
  * @returns `true` if `o` is an `object`
  */
-export declare function isObject(o: any): o is object;
+export declare function isObject(o: unknown): o is object;

package/dist/types/utils/is-promise-like.d.ts

@@ -5,4 +5,4 @@
  *
  * @returns `true` if `o` is `Promise`-like (i.e. has a `then` function)
  */
-export declare function isPromiseLike(o: any): o is PromiseLike<unknown>;
+export declare function isPromiseLike(o: unknown): o is PromiseLike<unknown>;

package/dist/types/utils/is-promise.d.ts

@@ -3,4 +3,4 @@
  *
  * @returns `true` if `o` is a `Promise`
  */
-export declare function isPromise(o: any): o is Promise<unknown>;
+export declare function isPromise(o: unknown): o is Promise<unknown>;

package/dist/types/utils/is-set.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Type guard for `Set`s.
+ *
+ * @returns `true` if `o` is a `Set`, regardless of the types that it contains
+ */
+export declare function isSet(o: unknown): o is Set<unknown>;

package/dist/types/utils/is-string.d.ts

@@ -5,4 +5,4 @@
  * `string` values, even if the TypeScript compiler's `strictNullChecks` flag is set to
  * `false` in your project.
  */
-export declare function isString(o: any): o is string;
+export declare function isString(o: unknown): o is string;

package/dist/types/utils/make-template.d.ts

@@ -7,7 +7,7 @@ export interface ToolboxTemplateSettings {
     };
 }
 export interface ToolboxTemplateFunction {
-    (data: Record<string, any>): string;
+    (data: Record<string, unknown>): string;
 }
 /**
  * A simple replacement for _.template from either Underscore or Lodash that removes the

package/dist/types/utils/range.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates an array of numbers (positive and/or negative) progressing from
+ * start up to, but not including, end. A step of -1 is used if a negative start
+ * is specified without an end or step. If end is not specified, it's set to
+ * start with start then set to 0.
+ */
+export declare function range(start: number, end?: number, step?: number): number[];

package/eslint.config.js

@@ -0,0 +1,15 @@
+const config = require('@silvermine/eslint-config'),
+      node = require('@silvermine/eslint-config/partials/node'),
+      nodeTests = require('@silvermine/eslint-config/partials/node-tests');
+
+module.exports = [
+   ...config,
+   {
+      files: [ 'tests/**.ts' ],
+      ...nodeTests,
+   },
+   {
+      files: [ '**/*.ts', '**/*.js' ],
+      ...node,
+   },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@silvermine/toolbox",
-   "version": "0.3.0",
+   "version": "0.5.0",
    "description": "A library of common TypeScript types, custom type guards, and utility functions.",
    "main": "./dist/commonjs/index",
    "types": "./dist/types/index.d.ts",
@@ -36,30 +36,30 @@
       "tslib": "^1.9.0 || ^2"
    },
    "devDependencies": {
-      "@silvermine/chai-strictly-equal": "1.1.0",
-      "@silvermine/eslint-config": "github:silvermine/eslint-config-silvermine#39387feb42f5d78bf4947fbb7cb0727b5ea2bebe",
+      "@silvermine/chai-strictly-equal": "1.1.1",
+      "@silvermine/eslint-config": "github:silvermine/eslint-config-silvermine#634db8f6cfb2314070ba59339faf86f089c8e65d",
       "@silvermine/standardization": "2.0.0",
       "@silvermine/typescript-config": "git+https://github.com/silvermine/typescript-config#23213e33077089e723629dead5342abe6f3b3c8c",
-      "@types/chai": "4.1.7",
-      "@types/mocha": "5.2.5",
+      "@types/chai": "4.3.20",
+      "@types/mocha": "5.2.7",
       "@types/node": "12.20.45",
-      "@types/sinon": "5.0.5",
-      "chai": "4.2.0",
-      "check-node-version": "4.0.2",
-      "coveralls": "3.0.9",
-      "eslint": "8.0.0",
-      "grunt": "1.0.4",
-      "grunt-cli": "1.3.2",
-      "grunt-concurrent": "2.3.1",
-      "grunt-contrib-clean": "2.0.0",
+      "@types/sinon": "5.0.7",
+      "chai": "4.5.0",
+      "check-node-version": "4.2.1",
+      "coveralls": "3.1.1",
+      "eslint": "8.57.1",
+      "grunt": "1.6.1",
+      "grunt-cli": "1.5.0",
+      "grunt-concurrent": "3.0.0",
+      "grunt-contrib-clean": "2.0.1",
       "grunt-contrib-watch": "1.1.0",
       "grunt-exec": "3.0.0",
       "mocha": "5.2.0",
-      "nyc": "13.1.0",
+      "nyc": "13.3.0",
       "sinon": "5.1.1",
-      "source-map-support": "0.5.16",
+      "source-map-support": "0.5.21",
       "ts-node": "7.0.1",
-      "tslib": "2.6.2",
-      "typescript": "3.9.5"
+      "tslib": "2.6.3",
+      "typescript": "3.9.10"
    }
 }

package/renovate.json

@@ -0,0 +1,4 @@
+{
+   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+   "extends": [ "github>silvermine/renovate-config" ]
+}

package/src/index.ts

@@ -14,6 +14,7 @@ export * from './utils/has-defined';
 export * from './utils/is-arguments';
 export * from './utils/is-array';
 export * from './utils/is-array-of-strings';
+export * from './utils/is-boolean';
 export * from './utils/is-empty';
 export * from './utils/is-enum-value';
 export * from './utils/is-map-with-values-of-type';
@@ -21,12 +22,14 @@ export * from './utils/is-number';
 export * from './utils/is-object';
 export * from './utils/is-promise';
 export * from './utils/is-promise-like';
+export * from './utils/is-set';
 export * from './utils/is-string';
 export * from './utils/is-undefined';
 export * from './utils/is-null';
 export * from './utils/is-not-null-or-undefined';
 
 export * from './utils/chunk';
+export * from './utils/compact';
 export * from './utils/flatten';
 export * from './utils/pick';
 export * from './utils/pluck';
@@ -35,3 +38,4 @@ export * from './utils/get';
 export * from './utils/escape-html';
 export * from './utils/make-template';
 export * from './utils/uniq';
+export * from './utils/range';

package/src/types/KeyValueStringObject.ts

@@ -1,8 +1,6 @@
-import { isObject } from '../utils/is-object';
-import { isArray } from '../utils/is-array';
-import { isArguments } from '../utils/is-arguments';
 import { isArrayOfStrings } from '../utils/is-array-of-strings';
 import { isString } from '../utils/is-string';
+import { isStringUnknownMap } from './StringUnknownMap';
 
 /**
  * `KeyValueStringObject`s have `string`s as keys and one of:
@@ -32,15 +30,15 @@ export interface KeyValueStringObject { [k: string]: (string | string[] | KeyVal
  *
  * @returns `true` if `o` is a `KeyValueStringObject`
  */
-export function isKeyValueStringObject(o: any): o is KeyValueStringObject {
+export function isKeyValueStringObject(o: unknown): o is KeyValueStringObject {
    // Arrays and the array-like `arguments` variable are objects, so they would not be
    // caught by an `isObject` check
-   if (!isObject(o) || isArray(o) || isArguments(o)) {
+   if (!isStringUnknownMap(o)) {
       return false;
    }
 
-   for (let k of Object.keys(o)) {
-      let v: any = (o as any)[k];
+   for (const k of Object.keys(o)) {
+      const v: unknown = o[k];
 
       if (!isString(v) && !isArrayOfStrings(v) && !isKeyValueStringObject(v)) {
          return false;

package/src/types/StrictUnion.ts

@@ -1,6 +1,5 @@
-/* eslint-disable @typescript-eslint/no-type-alias */
+import { UnionKeys } from './UnionKeys';
 
-type UnionKeys<T> = T extends unknown ? keyof T : never;
 type InvalidKeys<K extends string | number | symbol> = { [P in K]?: never };
 type StrictUnionHelper<T, TAll> = T extends unknown ? (T & InvalidKeys<Exclude<UnionKeys<TAll>, keyof T>>) : never;
 

package/src/types/StringArrayOfStringsMap.ts

@@ -1,7 +1,5 @@
-import { isArguments } from '../utils/is-arguments';
 import { isArrayOfStrings } from '../utils/is-array-of-strings';
-import { isObject } from '../utils/is-object';
-import { isArray } from '../utils/is-array';
+import { isStringUnknownMap } from './StringUnknownMap';
 
 /**
  * `StringArrayOfStringsMap`s have `string`s as keys and `string[]` as values. For
@@ -21,15 +19,15 @@ export interface StringArrayOfStringsMap { [s: string]: string[] }
  *
  * @returns `true` if `o` is a `StringArrayOfStringsMap`
  */
-export function isStringArrayOfStringsMap(o: any): o is StringArrayOfStringsMap {
+export function isStringArrayOfStringsMap(o: unknown): o is StringArrayOfStringsMap {
    // Arrays and the array-like `arguments` variable are objects, so they would not be
    // caught by an `isObject` check
-   if (!isObject(o) || isArray(o) || isArguments(o)) {
+   if (!isStringUnknownMap(o)) {
       return false;
    }
 
-   for (let k of Object.keys(o)) {
-      if (!isArrayOfStrings((o as any)[k])) {
+   for (const k of Object.keys(o)) {
+      if (!isArrayOfStrings(o[k])) {
          return false;
       }
    }

package/src/types/StringMap.ts

@@ -1,7 +1,5 @@
-import { isObject } from '../utils/is-object';
-import { isArray } from '../utils/is-array';
-import { isArguments } from '../utils/is-arguments';
 import { isString } from '../utils/is-string';
+import { isStringUnknownMap } from './StringUnknownMap';
 
 /**
  * `StringMap`s have `string`s as keys and `string`s as values. For example:
@@ -19,15 +17,15 @@ export interface StringMap { [s: string]: string }
  *
  * @returns `true` if `o` is a `StringMap`
  */
-export function isStringMap(o: any): o is StringMap {
+export function isStringMap(o: unknown): o is StringMap {
    // Arrays and the array-like `arguments` variable are objects, so they would not be
    // caught by an `isObject` check
-   if (!isObject(o) || isArray(o) || isArguments(o)) {
+   if (!isStringUnknownMap(o)) {
       return false;
    }
 
-   for (let k of Object.keys(o)) {
-      if (!isString((o as any)[k])) {
+   for (const k of Object.keys(o)) {
+      if (!isString(o[k])) {
          return false;
       }
    }

package/src/types/StringUnknownMap.ts

@@ -57,6 +57,6 @@ export interface StringUnknownMap { [s: string]: unknown }
  *
  * @returns `true` if `o` is a `StringUnknownMap`
  */
-export function isStringUnknownMap(o: any): o is StringUnknownMap {
+export function isStringUnknownMap(o: unknown): o is StringUnknownMap {
    return isObject(o) && !isArray(o) && !isArguments(o);
 }

package/src/types/UnionKeys.ts

@@ -0,0 +1,9 @@
+/**
+ * Extracts all the keys of a union type. For example:
+ *
+ * ```
+ * type Union = { a: number } | { b: string };
+ * type Keys = UnionKeys<Union>; // 'a' | 'b'
+ * ```
+ */
+export type UnionKeys<T> = T extends T ? keyof T : never;

package/src/utils/compact.ts

@@ -0,0 +1,14 @@
+type FalsyVals = '' | 0 | false | null | undefined;
+
+function notFalsy<T>(value: T | FalsyVals): value is T {
+   return value !== ''
+      && value !== 0
+      && value !== false
+      && value !== null
+      && value !== undefined
+      && !(typeof value === 'number' && isNaN(value));
+}
+
+export function compact<T>(arr: (T | FalsyVals)[]): T[] {
+   return arr.filter(notFalsy);
+}

package/src/utils/get-tag-string.ts

@@ -34,6 +34,6 @@
  * @see https://github.com/jashkenas/underscore/blob/d5fe0fd4060f13b40608cb9d92eda6d857e8752c/underscore.js#L1326
  * @see https://github.com/lodash/lodash/blob/750067f42d3aa5f927604ece2c6df0ff2b2e9d72/isNumber.js#L31
  */
-export function getTagString(o: any): string {
+export function getTagString(o: unknown): string {
    return Object.prototype.toString.call(o);
 }

package/src/utils/get.ts

@@ -32,6 +32,7 @@ function toKey(value: unknown): string | symbol {
 const IS_DEEP_PROP_REGEX = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
       IS_PLAIN_PROP_REGEX = /^\w*$/;
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isKey(value: any, object: any): boolean {
    if (Array.isArray(value)) {
       return false;
@@ -93,6 +94,7 @@ function stringToPath(str: string): string[] {
    return result;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function createPathArray(value: any, object: any): string[] {
    if (Array.isArray(value)) {
       return value;
@@ -139,6 +141,7 @@ function get<TResult = unknown>(
        resultObj: unknown = obj;
 
    while (resultObj !== null && resultObj !== undefined && index < length) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       resultObj = (resultObj as any)[toKey(pathArray[index])];
 
       index += 1;

package/src/utils/has-defined.ts

@@ -1,5 +1,6 @@
 import { isUndefined } from './is-undefined';
 import { RequireDefined } from '../types/RequireDefined';
+import { UnionKeys } from '../types/UnionKeys';
 
 /**
  * Tests that an optional or possibly-undefined property on type `T` is defined (that is,
@@ -18,6 +19,6 @@ import { RequireDefined } from '../types/RequireDefined';
  * @param propName the name of the optional or possibly-undefined property that you want
  * to be required
  */
-export function hasDefined<T, U extends keyof T>(o: T, propName: U): o is RequireDefined<T, U> {
+export function hasDefined<T, U extends keyof T | UnionKeys<T>>(o: T, propName: U): o is RequireDefined<Extract<T, { [key in U]?: unknown }>, U> {
    return Object.prototype.hasOwnProperty.call(o, propName) && !isUndefined(o[propName]);
 }

package/src/utils/is-arguments.ts

@@ -6,6 +6,6 @@ import { getTagString } from './get-tag-string';
  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments
  * @returns `true` if `o` is a function's array-like `arguments` variable
  */
-export function isArguments(o: any): boolean {
+export function isArguments(o: unknown): o is IArguments {
    return getTagString(o) === '[object Arguments]';
 }

package/src/utils/is-array-of-strings.ts

@@ -8,12 +8,12 @@ import { isString } from './is-string';
  * not counted as `string` values, even if the TypeScript compiler's `strictNullChecks`
  * flag is set to `false` in your project.
  */
-export function isArrayOfStrings(values: any): values is string[] {
+export function isArrayOfStrings(values: unknown): values is string[] {
    if (!isArray(values)) {
       return false;
    }
 
-   for (let v of values) {
+   for (const v of values) {
       if (!isString(v)) {
          return false;
       }

package/src/utils/is-array.ts

@@ -3,6 +3,6 @@
  *
  * @returns `true` if `o` is an `Array`, regardless of the types that it contains
  */
-export function isArray(o: any): o is unknown[] {
+export function isArray(o: unknown): o is unknown[] {
    return Array.isArray(o);
 }

package/src/utils/is-boolean.ts

@@ -0,0 +1,3 @@
+export function isBoolean(o: unknown): o is boolean {
+   return o === true || o === false;
+}

package/src/utils/is-empty.ts

@@ -2,6 +2,32 @@ import { isArray } from './is-array';
 import { isString } from './is-string';
 import { isArguments } from './is-arguments';
 import { isUndefined } from './is-undefined';
+import { isNull } from './is-null';
+import { isBoolean } from './is-boolean';
+import { isNumber } from './is-number';
+import { isSet } from './is-set';
+import { isObject } from './is-object';
+
+
+interface IEmptyArguments extends IArguments {
+   length: 0;
+}
+
+interface IEmptyObj {
+   [s: string]: never;
+}
+
+type IEmptyTypes = (
+   null |
+   undefined |
+   boolean |
+   number |
+   never[] |
+   '' |
+   IEmptyArguments |
+   Set<never> |
+   IEmptyObj
+);
 
 /**
  * Checks if `o` is an empty object. An object is "empty" if it:
@@ -12,12 +38,18 @@ import { isUndefined } from './is-undefined';
  *
  * @returns `true` if `o` is empty
  */
-export function isEmpty(o: any): boolean {
-   if (o === null || isUndefined(o)) {
+export function isEmpty(o: unknown[]): boolean;
+export function isEmpty(o: object): boolean;
+export function isEmpty(o: unknown): o is IEmptyTypes;
+export function isEmpty(o: unknown): boolean {
+   if (isNull(o) || isUndefined(o) || isBoolean(o) || isNumber(o)) {
       return true;
    }
    if (isArray(o) || isString(o) || isArguments(o)) {
       return o.length === 0;
    }
-   return Object.keys(o).length === 0;
+   if (isSet(o)) {
+      return o.size === 0;
+   }
+   return isObject(o) && Object.keys(o).length === 0;
 }

package/src/utils/is-enum-value.ts

@@ -1,7 +1,7 @@
 /**
  * Type guard to check to see if the given value is a valid value for the enum.
  */
-export function isEnumValue<T>(enumType: T, value: any): value is T[keyof T] {
+export function isEnumValue<T>(enumType: T, value: unknown): value is T[keyof T] {
    return (Object.keys(enumType) as Array<keyof T>)
       .map((key) => {
          return enumType[key];

package/src/utils/is-map-with-values-of-type.ts

@@ -6,13 +6,13 @@ import { isStringUnknownMap } from '../types/StringUnknownMap';
  * @returns `true` if `o` is a map with `string` keys and values that pass the provided
  * type guard.
  */
-export function isMapWithValuesOfType<T>(guard: (x: any) => x is T, o: any): o is Record<string, T> {
+export function isMapWithValuesOfType<T>(guard: (x: unknown) => x is T, o: unknown): o is Record<string, T> {
    if (!isStringUnknownMap(o)) {
       return false;
    }
 
-   for (let k of Object.keys(o)) {
-      if (!guard((o as any)[k])) {
+   for (const k of Object.keys(o)) {
+      if (!guard(o[k])) {
          return false;
       }
    }

package/src/utils/is-number.ts

@@ -8,6 +8,6 @@ import { isObject } from './is-object';
  * considered `number`s. If you need to check for one of those values, you can use the
  * built-in `Number.isNaN` or `Number.isFinite` functions.
  */
-export function isNumber(o: any): o is number {
+export function isNumber(o: unknown): o is number {
    return typeof o === 'number' || (isObject(o) && getTagString(o) === '[object Number]');
 }

package/src/utils/is-object.ts

@@ -9,8 +9,8 @@
  * @see https://github.com/jashkenas/underscore/blob/d5fe0fd4060f13b40608cb9d92eda6d857e8752c/underscore.js#L1322
  * @returns `true` if `o` is an `object`
  */
-export function isObject(o: any): o is object {
-   let type = typeof o;
+export function isObject(o: unknown): o is object {
+   const type = typeof o;
 
    return o !== null && (type === 'object' || type === 'function');
 }

package/src/utils/is-promise-like.ts

@@ -8,6 +8,6 @@ import { isObject } from './is-object';
  *
  * @returns `true` if `o` is `Promise`-like (i.e. has a `then` function)
  */
-export function isPromiseLike(o: any): o is PromiseLike<unknown> {
-   return isPromise(o) || (isObject(o) && typeof (o as any).then === 'function');
+export function isPromiseLike(o: unknown): o is PromiseLike<unknown> {
+   return isPromise(o) || (isObject(o) && typeof (o as PromiseLike<unknown>).then === 'function');
 }

package/src/utils/is-promise.ts

@@ -6,6 +6,6 @@ import { getTagString } from './get-tag-string';
  *
  * @returns `true` if `o` is a `Promise`
  */
-export function isPromise(o: any): o is Promise<unknown> {
+export function isPromise(o: unknown): o is Promise<unknown> {
    return isObject(o) && getTagString(o) === '[object Promise]';
 }

package/src/utils/is-set.ts

@@ -0,0 +1,8 @@
+/**
+ * Type guard for `Set`s.
+ *
+ * @returns `true` if `o` is a `Set`, regardless of the types that it contains
+ */
+export function isSet(o: unknown): o is Set<unknown> {
+   return o instanceof Set;
+}

package/src/utils/is-string.ts

@@ -8,6 +8,6 @@ import { getTagString } from './get-tag-string';
  * `string` values, even if the TypeScript compiler's `strictNullChecks` flag is set to
  * `false` in your project.
  */
-export function isString(o: any): o is string {
+export function isString(o: unknown): o is string {
    return typeof o === 'string' || (isObject(o) && getTagString(o) === '[object String]');
 }

package/src/utils/make-template.ts

@@ -6,6 +6,7 @@ const DEFAULT_SETTINGS: ToolboxTemplateSettings = {
    interpolate: /<%=([\s\S]+?)%>/g,
 };
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function getValue(path: string, data: any): unknown {
    return get(data, (path || '').trim(), '');
 }
@@ -16,7 +17,7 @@ export interface ToolboxTemplateSettings {
 }
 
 export interface ToolboxTemplateFunction {
-   (data: Record<string, any>): string;
+   (data: Record<string, unknown>): string;
 }
 
 /**
@@ -51,23 +52,19 @@ export interface ToolboxTemplateFunction {
 export function makeTemplate(text: string, userSettings?: ToolboxTemplateSettings): (data: unknown) => string {
    type TemplateFunction = (data: unknown) => unknown;
 
-   let parts: (TemplateFunction | string)[] = [],
-       index = 0,
-       settings = Object.assign({}, DEFAULT_SETTINGS, userSettings || {}),
-       regExpPattern, matcher;
+   let index = 0;
 
-   regExpPattern = [
-      settings.escape.source,
-      settings.interpolate.source,
-   ];
-   matcher = new RegExp(regExpPattern.join('|') + '|$', 'g');
+   const parts: (TemplateFunction | string)[] = [],
+         settings = Object.assign({}, DEFAULT_SETTINGS, userSettings || {}),
+         regExpPattern = [ settings.escape.source, settings.interpolate.source ],
+         matcher = new RegExp(regExpPattern.join('|') + '|$', 'g');
 
    text.replace(matcher, (match, escape, interpolate, offset) => {
       parts.push(text.slice(index, offset));
       index = offset + match.length;
 
       if (escape) {
-         parts.push((data: any) => {
+         parts.push((data: unknown) => {
             return escapeHTML(getValue(escape, data));
          });
       } else if (interpolate) {

package/src/utils/range.ts

@@ -0,0 +1,24 @@
+/**
+ * Creates an array of numbers (positive and/or negative) progressing from
+ * start up to, but not including, end. A step of -1 is used if a negative start
+ * is specified without an end or step. If end is not specified, it's set to
+ * start with start then set to 0.
+ */
+export function range(start: number, end?: number, step?: number): number[] {
+   if (end === undefined) {
+      end = start;
+      start = 0;
+   }
+
+   if (!step) {
+      step = start < end ? 1 : -1;
+   }
+
+   const length = Math.max(Math.ceil((end - start) / step), 0),
+         result = Array(length);
+
+   for (let i = 0; i < length; i++) {
+      result[i] = start + (i * step);
+   }
+   return result;
+}

package/src/utils/uniq.ts

@@ -3,8 +3,8 @@ const iterateeUniq = <T, U>(arr: T[], iteratee: (value: T, i: number, arr: T[])
          seen: U[] = [];
 
    for (let i = 0, length = arr.length; i < length; i++) {
-      let value = arr[i],
-          computed = iteratee(value, i, arr);
+      const value = arr[i],
+            computed = iteratee(value, i, arr);
 
       if (seen.indexOf(computed) === -1) {
          seen.push(computed);
@@ -21,7 +21,7 @@ const sortedUniq = <T, U>(arr: T[]): T[] => {
    let lastSeen: T | U | undefined;
 
    for (let i = 0, length = arr.length; i < length; i++) {
-      let value = arr[i];
+      const value = arr[i];
 
       if (i === 0 || lastSeen !== value) {
          result.push(value);