@silvermine/toolbox 0.2.0 → 0.4.0

package/dist/esm/utils/uniq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniq.js","sourceRoot":"","sources":["../../../src/utils/uniq.ts"],"names":[],"mappings":"AAAA,MAAM,YAAY,GAAG,CAAO,GAAQ,EAAE,QAA8C,EAAO,EAAE;IAC1F,MAAM,MAAM,GAAQ,EAAE,EAChB,IAAI,GAAQ,EAAE,CAAC;IAErB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE;QACnD,IAAI,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,EACd,QAAQ,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QAEvC,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE;YAChC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACpB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACrB;KACH;IACD,OAAO,MAAM,CAAC;AACjB,CAAC,CAAC;AAGF,MAAM,UAAU,GAAG,CAAO,GAAQ,EAAO,EAAE;IACxC,MAAM,MAAM,GAAQ,EAAE,CAAC;IAEvB,IAAI,QAA2B,CAAC;IAEhC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE;QACnD,IAAI,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QAEnB,IAAI,CAAC,KAAK,CAAC,IAAI,QAAQ,KAAK,KAAK,EAAE;YAChC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACrB;QACD,QAAQ,GAAG,KAAK,CAAC;KACnB;IACD,OAAO,MAAM,CAAC;AACjB,CAAC,CAAC;AAGF,MAAM,YAAY,GAAG,CAAI,GAAQ,EAAO,EAAE;IACvC,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QAC9C,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AACjB,CAAC,CAAC;AAGF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAO,GAAQ,EAAE,QAAkB,EAAE,QAA+C,EAAO,EAAE;IAC9G,IAAI,QAAQ,EAAE;QACX,OAAO,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;KACrC;IACD,IAAI,QAAQ,EAAE;QACX,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC;KACzB;IACD,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC;AAC5B,CAAC,CAAC"}

package/dist/types/index.d.ts

@@ -4,6 +4,7 @@ export * from './types/Optional';
 export * from './types/PropsWithType';
 export * from './types/RequireDefined';
 export * from './types/RequireOptional';
+export * from './types/StrictUnion';
 export * from './types/StringArrayOfStringsMap';
 export * from './types/StringMap';
 export * from './types/StringUnknownMap';
@@ -12,6 +13,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';
@@ -19,14 +21,19 @@ 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';
 export * from './utils/delay';
 export * from './utils/get';
 export * from './utils/escape-html';
 export * from './utils/make-template';
+export * from './utils/uniq';
+export * from './utils/range';

package/dist/types/types/StrictUnion.d.ts

@@ -0,0 +1,15 @@
+declare type UnionKeys<T> = T extends unknown ? keyof T : never;
+declare type InvalidKeys<K extends string | number | symbol> = {
+    [P in K]?: never;
+};
+declare type StrictUnionHelper<T, TAll> = T extends unknown ? (T & InvalidKeys<Exclude<UnionKeys<TAll>, keyof T>>) : never;
+/**
+ * A basic TypeScript union (e.g. A | B) results in a type containing the available
+ * properties from the provided types. When StrictUnion is used (e.g. StrictUnion<A | B>),
+ * the resulting type can only contain the properties from one of the types (e.g. all the
+ * properties from A, but none of the properties from B).
+ *
+ * See: https://github.com/microsoft/TypeScript/issues/20863#issuecomment-520551758
+ */
+export declare type StrictUnion<T> = StrictUnionHelper<T, T>;
+export {};

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

@@ -0,0 +1,3 @@
+declare type FalsyVals = '' | 0 | false | null | undefined;
+export declare function compact<T>(arr: (T | FalsyVals)[]): T[];
+export {};

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

@@ -4,4 +4,4 @@
  * @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 declare function isArguments(o: any): boolean;
+export declare function isArguments(o: unknown): o is IArguments;

package/dist/types/utils/is-array-of-strings.d.ts

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

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

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

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

@@ -0,0 +1 @@
+export declare function isBoolean(o: unknown): o is boolean;

package/dist/types/utils/is-enum-value.d.ts

@@ -1,4 +1,4 @@
 /**
  * Type guard to check to see if the given value is a valid value for the enum.
  */
-export declare function isEnumValue<T>(enumType: T, value: any): value is T[keyof T];
+export declare function isEnumValue<T>(enumType: T, value: unknown): value is T[keyof T];

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

@@ -5,4 +5,4 @@
  * 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 declare function isNumber(o: any): o is number;
+export declare function isNumber(o: unknown): o is number;

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/pick.d.ts

@@ -0,0 +1,2 @@
+export declare function pick<T extends object, K extends keyof T>(obj: T, props: K[]): Pick<T, K>;
+export declare function pick<T extends object, K extends keyof T = never>(obj: T, ...props: K[]): Pick<T, K>;

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/dist/types/utils/uniq.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Produce a duplicate-free version of the array. If the array has already
+ * been sorted, you have the option of using a faster algorithm.
+ * The faster algorithm will not work with an iteratee if the iteratee
+ * is not a one-to-one function, so providing an iteratee will disable
+ * the faster algorithm.
+ */
+export declare const uniq: <T, U>(arr: T[], isSorted?: boolean | undefined, iteratee?: ((value: T, i: number, arr: T[]) => U) | undefined) => T[];

package/package.json

@@ -1,15 +1,21 @@
 {
    "name": "@silvermine/toolbox",
-   "version": "0.2.0",
+   "version": "0.4.0",
    "description": "A library of common TypeScript types, custom type guards, and utility functions.",
    "main": "./dist/commonjs/index",
    "types": "./dist/types/index.d.ts",
    "module": "./dist/esm/index",
    "scripts": {
       "prepare": "grunt build",
-      "test:node-version": "check-node-version --npm 6.14.12 --print",
-      "test": "npm run test:node-version && TS_NODE_PROJECT='tests/tsconfig.json' TS_NODE_FILES=true nyc mocha --opts ./.mocha.opts",
-      "commitlint": "commitlint --from 0b9d320"
+      "check-node-version": "check-node-version --npm 10.5.0 --print",
+      "test": "TS_NODE_PROJECT='tests/tsconfig.json' TS_NODE_FILES=true nyc mocha --opts ./.mocha.opts",
+      "eslint": "eslint '{,!(node_modules|dist)/**/}*.{js,ts}'",
+      "markdownlint": "markdownlint -c .markdownlint.json -i CHANGELOG.md '{,!(node_modules)/**/}*.md'",
+      "commitlint": "commitlint --from 0b9d320",
+      "standards": "npm run markdownlint && npm run eslint",
+      "release:preview": "node ./node_modules/@silvermine/standardization/scripts/release.js preview",
+      "release:prep-changelog": "node ./node_modules/@silvermine/standardization/scripts/release.js prep-changelog",
+      "release:finalize": "node ./node_modules/@silvermine/standardization/scripts/release.js finalize"
    },
    "author": "Matt Luedke",
    "license": "MIT",
@@ -27,42 +33,33 @@
       "type guards"
    ],
    "peerDependencies": {
-      "tslib": "1.9.x"
+      "tslib": "^1.9.0 || ^2"
    },
    "devDependencies": {
-      "@silvermine/chai-strictly-equal": "1.1.0",
-      "@silvermine/eslint-config": "3.1.0-beta.0",
-      "@silvermine/standardization": "1.2.1",
-      "@silvermine/typescript-config": "git+https://github.com/silvermine/typescript-config.git#23213e33077089e723629dead5342abe6f3b3c8c",
-      "@types/chai": "4.1.7",
-      "@types/mocha": "5.2.5",
+      "@silvermine/chai-strictly-equal": "1.1.1",
+      "@silvermine/eslint-config": "github:silvermine/eslint-config-silvermine#aa8ecacb12ab778078fd195d3b15f09ecac76c11",
+      "@silvermine/standardization": "2.0.0",
+      "@silvermine/typescript-config": "git+https://github.com/silvermine/typescript-config#23213e33077089e723629dead5342abe6f3b3c8c",
+      "@types/chai": "4.3.18",
+      "@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",
-      "cz-conventional-changelog": "3.1.0",
-      "eslint": "6.8.0",
-      "grunt": "1.0.4",
+      "@types/sinon": "5.0.7",
+      "chai": "4.5.0",
+      "check-node-version": "4.2.1",
+      "coveralls": "3.1.1",
+      "eslint": "8.57.0",
+      "grunt": "1.6.1",
       "grunt-cli": "1.3.2",
-      "grunt-concurrent": "2.3.1",
-      "grunt-contrib-clean": "2.0.0",
+      "grunt-concurrent": "3.0.0",
+      "grunt-contrib-clean": "2.0.1",
       "grunt-contrib-watch": "1.1.0",
-      "grunt-eslint": "24.0.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",
-      "standard-version": "5.0.2",
+      "source-map-support": "0.5.21",
       "ts-node": "7.0.1",
-      "tslib": "1.9.3",
-      "typescript": "3.9.5"
-   },
-   "dependencies": {},
-   "config": {
-      "commitizen": {
-         "path": "./node_modules/cz-conventional-changelog"
-      }
+      "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

@@ -4,6 +4,7 @@ export * from './types/Optional';
 export * from './types/PropsWithType';
 export * from './types/RequireDefined';
 export * from './types/RequireOptional';
+export * from './types/StrictUnion';
 export * from './types/StringArrayOfStringsMap';
 export * from './types/StringMap';
 export * from './types/StringUnknownMap';
@@ -13,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';
@@ -20,15 +22,20 @@ 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';
 export * from './utils/delay';
 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/StrictUnion.ts

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/no-type-alias */
+
+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;
+
+/**
+ * A basic TypeScript union (e.g. A | B) results in a type containing the available
+ * properties from the provided types. When StrictUnion is used (e.g. StrictUnion<A | B>),
+ * the resulting type can only contain the properties from one of the types (e.g. all the
+ * properties from A, but none of the properties from B).
+ *
+ * See: https://github.com/microsoft/TypeScript/issues/20863#issuecomment-520551758
+ */
+export type StrictUnion<T> = StrictUnionHelper<T, T>;

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/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,7 +8,7 @@ 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;
    }

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-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-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,7 +9,7 @@
  * @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 {
+export function isObject(o: unknown): o is object {
    let 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> {
+export function isPromiseLike(o: unknown): o is PromiseLike<unknown> {
    return isPromise(o) || (isObject(o) && typeof (o as any).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/pick.ts

@@ -0,0 +1,24 @@
+import { isArray } from './is-array';
+
+// NOTE: If changing these types, ensure the following cases cause a type error:
+//
+// const noProps = pick({ a: 1 });
+//
+// noProps.a; // Property 'a' does not exist on type 'Pick<{ a: number; }, never>'.
+//
+// const emptyArr = pick({ a: 1 }, []);
+//
+// emptyArr.a; // Property 'a' does not exist on type 'Pick<{ a: number; }, never>'.
+
+export function pick<T extends object, K extends keyof T>(obj: T, props: K[]): Pick<T, K>;
+export function pick<T extends object, K extends keyof T = never>(obj: T, ...props: K[]): Pick<T, K>;
+export function pick<T extends object, K extends keyof T>(obj: T, ...args: K[] | [ K[] ]): Pick<T, K> {
+   const props = ((args.length === 1 && isArray(args[0])) ? args[0] : args) as K[];
+
+   return props.reduce((memo, prop) => {
+      if (prop in obj) {
+         memo[prop] = obj[prop];
+      }
+      return memo;
+   }, {} as Pick<T, K>);
+}

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

@@ -0,0 +1,59 @@
+const iterateeUniq = <T, U>(arr: T[], iteratee: (value: T, i: number, arr: T[]) => U): T[] => {
+   const result: T[] = [],
+         seen: U[] = [];
+
+   for (let i = 0, length = arr.length; i < length; i++) {
+      let value = arr[i],
+          computed = iteratee(value, i, arr);
+
+      if (seen.indexOf(computed) === -1) {
+         seen.push(computed);
+         result.push(value);
+      }
+   }
+   return result;
+};
+
+
+const sortedUniq = <T, U>(arr: T[]): T[] => {
+   const result: T[] = [];
+
+   let lastSeen: T | U | undefined;
+
+   for (let i = 0, length = arr.length; i < length; i++) {
+      let value = arr[i];
+
+      if (i === 0 || lastSeen !== value) {
+         result.push(value);
+      }
+      lastSeen = value;
+   }
+   return result;
+};
+
+
+const standardUniq = <T>(arr: T[]): T[] => {
+   const result = arr.filter((value, index, _arr) => {
+      return _arr.indexOf(value) === index;
+   });
+
+   return result;
+};
+
+
+/**
+ * Produce a duplicate-free version of the array. If the array has already
+ * been sorted, you have the option of using a faster algorithm.
+ * The faster algorithm will not work with an iteratee if the iteratee
+ * is not a one-to-one function, so providing an iteratee will disable
+ * the faster algorithm.
+ */
+export const uniq = <T, U>(arr: T[], isSorted?: boolean, iteratee?: (value: T, i: number, arr: T[]) => U): T[] => {
+   if (iteratee) {
+      return iterateeUniq(arr, iteratee);
+   }
+   if (isSorted) {
+      return sortedUniq(arr);
+   }
+   return standardUniq(arr);
+};