umt 2.2.1 → 2.4.0

package/module/es5/tests/unit/Math/reduce.test.js

@@ -1,93 +0,0 @@
-"use strict";
-
-var _reduce = require("@/Math/reduce");
-describe("reduce function", function () {
-  describe("basic fraction reduction", function () {
-    it("should reduce simple fractions", function () {
-      expect((0, _reduce.reduce)(2, 4)).toEqual({
-        x: 1,
-        y: 2,
-        gcd: 2
-      });
-      expect((0, _reduce.reduce)(3, 6)).toEqual({
-        x: 1,
-        y: 2,
-        gcd: 3
-      });
-      expect((0, _reduce.reduce)(8, 12)).toEqual({
-        x: 2,
-        y: 3,
-        gcd: 4
-      });
-    });
-    it("should handle already reduced fractions", function () {
-      expect((0, _reduce.reduce)(3, 4)).toEqual({
-        x: 3,
-        y: 4,
-        gcd: 1
-      });
-      expect((0, _reduce.reduce)(7, 9)).toEqual({
-        x: 7,
-        y: 9,
-        gcd: 1
-      });
-    });
-    it("should handle fractions with 1", function () {
-      expect((0, _reduce.reduce)(5, 1)).toEqual({
-        x: 5,
-        y: 1,
-        gcd: 1
-      });
-      expect((0, _reduce.reduce)(1, 7)).toEqual({
-        x: 1,
-        y: 7,
-        gcd: 1
-      });
-    });
-  });
-  describe("edge cases", function () {
-    it("should handle zero in numerator or denominator", function () {
-      expect((0, _reduce.reduce)(0, 5)).toEqual({
-        x: Number.NaN,
-        y: Number.NaN
-      });
-      expect((0, _reduce.reduce)(5, 0)).toEqual({
-        x: Number.NaN,
-        y: Number.NaN
-      });
-      expect((0, _reduce.reduce)(0, 0)).toEqual({
-        x: Number.NaN,
-        y: Number.NaN
-      });
-    });
-    it("should handle negative numbers", function () {
-      expect((0, _reduce.reduce)(-6, 8)).toEqual({
-        x: -3,
-        y: 4,
-        gcd: 2
-      });
-      expect((0, _reduce.reduce)(6, -8)).toEqual({
-        x: -3,
-        y: 4,
-        gcd: 2
-      });
-      expect((0, _reduce.reduce)(-6, -8)).toEqual({
-        x: 3,
-        y: 4,
-        gcd: 2
-      });
-    });
-    it("should handle larger numbers", function () {
-      expect((0, _reduce.reduce)(1000, 2500)).toEqual({
-        x: 2,
-        y: 5,
-        gcd: 500
-      });
-      expect((0, _reduce.reduce)(24680, 12340)).toEqual({
-        x: 2,
-        y: 1,
-        gcd: 12340
-      });
-    });
-  });
-});

package/module/es5/tests/unit/Math/repeatedTrial.test.d.ts

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

package/module/es5/tests/unit/Math/repeatedTrial.test.js

@@ -1,39 +0,0 @@
-"use strict";
-
-var _repeatedTrial = require("@/Math/repeatedTrial");
-describe("repeatedTrial", function () {
-  it("should calculate basic probability cases", function () {
-    expect((0, _repeatedTrial.repeatedTrial)(4, 2, {
-      x: 1,
-      y: 3
-    })).toEqual([8, 27]);
-    expect((0, _repeatedTrial.repeatedTrial)(5, 2, {
-      x: 1,
-      y: 2
-    })).toEqual([5, 16]);
-    expect((0, _repeatedTrial.repeatedTrial)(3, 2, {
-      x: 1,
-      y: 2
-    })).toEqual([3, 8]);
-  });
-  it("should handle extreme probability cases", function () {
-    expect((0, _repeatedTrial.repeatedTrial)(3, 3, {
-      x: 2,
-      y: 3
-    })).toEqual([8, 27]);
-    expect((0, _repeatedTrial.repeatedTrial)(4, 4, {
-      x: 1,
-      y: 2
-    })).toEqual([1, 16]);
-  });
-  it("should handle probability with simple fractions", function () {
-    expect((0, _repeatedTrial.repeatedTrial)(2, 1, {
-      x: 1,
-      y: 2
-    })).toEqual([1, 2]);
-    expect((0, _repeatedTrial.repeatedTrial)(3, 2, {
-      x: 1,
-      y: 3
-    })).toEqual([2, 9]);
-  });
-});

package/module/es5/tests/unit/Math/roundOf.test.d.ts

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

package/module/es5/tests/unit/Math/roundOf.test.js

@@ -1,40 +0,0 @@
-"use strict";
-
-var _roundOf = require("@/Math/roundOf");
-describe("roundOf function", function () {
-  describe("basic rounding", function () {
-    it("should round to default precision (0)", function () {
-      expect((0, _roundOf.roundOf)(1.111111111111)).toBe(1);
-      expect((0, _roundOf.roundOf)(1.555555555555)).toBe(2);
-      expect((0, _roundOf.roundOf)(1.499999999999)).toBe(1);
-    });
-    it("should round to specified decimal places", function () {
-      expect((0, _roundOf.roundOf)(1.111111111111, 2)).toBe(1.11);
-      expect((0, _roundOf.roundOf)(1.555555555555, 2)).toBe(1.56);
-      expect((0, _roundOf.roundOf)(1.499999999999, 2)).toBe(1.5);
-    });
-    it("should handle increasing precision", function () {
-      var value = 1.111111111111;
-      expect((0, _roundOf.roundOf)(value, 1)).toBe(1.1);
-      expect((0, _roundOf.roundOf)(value, 2)).toBe(1.11);
-      expect((0, _roundOf.roundOf)(value, 3)).toBe(1.111);
-      expect((0, _roundOf.roundOf)(value, 4)).toBe(1.1111);
-      expect((0, _roundOf.roundOf)(value, 5)).toBe(1.11111);
-    });
-  });
-  describe("edge cases", function () {
-    it("should handle negative numbers", function () {
-      expect((0, _roundOf.roundOf)(-1.234, 2)).toBe(-1.23);
-      expect((0, _roundOf.roundOf)(-1.235, 2)).toBe(-1.24);
-    });
-    it("should handle zero with different precisions", function () {
-      expect((0, _roundOf.roundOf)(0, 0)).toBe(0);
-      expect((0, _roundOf.roundOf)(0, 2)).toBe(0);
-      expect((0, _roundOf.roundOf)(0.0, 4)).toBe(0);
-    });
-    it("should handle negative precision", function () {
-      expect((0, _roundOf.roundOf)(1234.5678, -1)).toBe(1230);
-      expect((0, _roundOf.roundOf)(1234.5678, -2)).toBe(1200);
-    });
-  });
-});

package/module/es5/tests/unit/Math/solveEquation.test.d.ts

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

package/module/es5/tests/unit/Math/solveEquation.test.js

@@ -1,24 +0,0 @@
-"use strict";
-
-var _solveEquation = require("@/Math/solveEquation");
-describe("solveEquation function", function () {
-  it("should solve a 2x2 system of linear equations (case 1)", function () {
-    // System:
-    // x + y = 4
-    // x + 2y = 10
-    expect((0, _solveEquation.solveEquation)([[1, 1], [1, 2]], [4, 10])).toEqual([-2, 6]);
-  });
-  it("should solve a 2x2 system of linear equations (case 2)", function () {
-    // System:
-    // x + 6y = 33
-    // x + y = 8
-    expect((0, _solveEquation.solveEquation)([[1, 6], [1, 1]], [33, 8])).toEqual([3, 5]);
-  });
-  it("should solve a 3x3 system of linear equations", function () {
-    // System:
-    // 5x - 4y + 6z = 8
-    // 7x - 6y + 10z = 14
-    // 4x + 9y + 7z = 74
-    expect((0, _solveEquation.solveEquation)([[5, -4, 6], [7, -6, 10], [4, 9, 7]], [8, 14, 74])).toEqual([2, 5, 3]);
-  });
-});

package/module/es5/tests/unit/Math/standardDeviation.test.d.ts

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

package/module/es5/tests/unit/Math/standardDeviation.test.js

@@ -1,23 +0,0 @@
-"use strict";
-
-var _standardDeviation = require("@/Math/standardDeviation");
-describe("standardDeviation function", function () {
-  it("should calculate standard deviation of sequential integers", function () {
-    expect((0, _standardDeviation.standardDeviation)([1, 2, 3, 4, 5])).toBe(1.4142135623730951);
-    expect((0, _standardDeviation.standardDeviation)([1, 2, 3])).toBe(0.816496580927726);
-  });
-  it("should calculate standard deviation of non-sequential values", function () {
-    expect((0, _standardDeviation.standardDeviation)([10, 12, 23, 23, 16, 23, 21, 16])).toBe(4.898979485566356);
-    expect((0, _standardDeviation.standardDeviation)([5, 10, 15, 20, 25])).toBe(7.0710678118654755);
-  });
-  it("should handle edge cases", function () {
-    // All same values should have standard deviation of 0
-    expect((0, _standardDeviation.standardDeviation)([5, 5, 5, 5])).toBe(0);
-
-    // Single value should have standard deviation of 0
-    expect((0, _standardDeviation.standardDeviation)([42])).toBe(0);
-
-    // Empty array should return 0 (as average function returns 0 for empty arrays)
-    expect((0, _standardDeviation.standardDeviation)([])).toBe(0);
-  });
-});

package/module/es5/tests/unit/Math/subtract.test.d.ts

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

package/module/es5/tests/unit/Math/subtract.test.js

@@ -1,46 +0,0 @@
-"use strict";
-
-var _subtract = require("@/Math/subtract");
-function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
-function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-describe("subtract function", function () {
-  test.each([{
-    a: [1, 1],
-    expected: 0
-  }, {
-    a: [1.1, 1],
-    expected: 0.1
-  }, {
-    a: [1, 1.1],
-    expected: -0.1
-  }, {
-    a: [1, 1, 1],
-    expected: -1
-  }, {
-    a: [5, 2, 1],
-    expected: 2
-  }, {
-    a: [10, 1, 1, 1],
-    expected: 7
-  }])("subtracting $a should result in $expected", function (_ref) {
-    var a = _ref.a,
-      expected = _ref.expected;
-    expect(_subtract.subtract.apply(void 0, _toConsumableArray(a))).toBe(expected);
-  });
-  describe("floating point precision", function () {
-    it("should handle floating point precision correctly", function () {
-      // These operations would normally have floating point errors
-      expect((0, _subtract.subtract)(0.3, 0.1)).toBe(0.2);
-      expect((0, _subtract.subtract)(0.7, 0.1)).toBe(0.6);
-      expect((0, _subtract.subtract)(1.0, 0.9)).toBe(0.1);
-    });
-    it("should handle multiple decimal places", function () {
-      expect((0, _subtract.subtract)(0.12345, 0.00001)).toBe(0.12344);
-      expect((0, _subtract.subtract)(1.23456, 0.00001, 0.00002)).toBe(1.23453);
-    });
-  });
-});

package/module/es5/tests/unit/Math/toBaseN.test.d.ts

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

package/module/es5/tests/unit/Math/toBaseN.test.js

@@ -1,40 +0,0 @@
-"use strict";
-
-var _toBaseN = require("@/Math/toBaseN");
-describe("toBaseN function", function () {
-  describe("binary (base 2)", function () {
-    it("should convert decimal numbers to binary strings", function () {
-      expect((0, _toBaseN.toBaseN)(1)).toBe("1");
-      expect((0, _toBaseN.toBaseN)(2)).toBe("10");
-      expect((0, _toBaseN.toBaseN)(3)).toBe("11");
-      expect((0, _toBaseN.toBaseN)(4)).toBe("100");
-      expect((0, _toBaseN.toBaseN)(5)).toBe("101");
-      expect((0, _toBaseN.toBaseN)(6)).toBe("110");
-      expect((0, _toBaseN.toBaseN)(112)).toBe("1110000");
-    });
-  });
-  describe("base 4", function () {
-    it("should convert decimal numbers to base 4 strings", function () {
-      expect((0, _toBaseN.toBaseN)(7, 4)).toBe("13");
-      expect((0, _toBaseN.toBaseN)(8, 4)).toBe("20");
-      expect((0, _toBaseN.toBaseN)(9, 4)).toBe("21");
-      expect((0, _toBaseN.toBaseN)(112, 4)).toBe("1300");
-    });
-  });
-  describe("octal (base 8)", function () {
-    it("should convert decimal numbers to octal strings", function () {
-      expect((0, _toBaseN.toBaseN)(7, 8)).toBe("7");
-      expect((0, _toBaseN.toBaseN)(8, 8)).toBe("10");
-      expect((0, _toBaseN.toBaseN)(9, 8)).toBe("11");
-      expect((0, _toBaseN.toBaseN)(112, 8)).toBe("160");
-    });
-  });
-  describe("hexadecimal (base 16)", function () {
-    it("should convert decimal numbers to hexadecimal strings", function () {
-      expect((0, _toBaseN.toBaseN)(10, 16)).toBe("a");
-      expect((0, _toBaseN.toBaseN)(15, 16)).toBe("f");
-      expect((0, _toBaseN.toBaseN)(16, 16)).toBe("10");
-      expect((0, _toBaseN.toBaseN)(255, 16)).toBe("ff");
-    });
-  });
-});

package/module/es5/tests/unit/Math/toCelsius.test.d.ts

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

package/module/es5/tests/unit/Math/toCelsius.test.js

@@ -1,18 +0,0 @@
-"use strict";
-
-var _toCelsius = require("@/Math/toCelsius");
-describe("toCelsius function", function () {
-  it("should convert Kelvin to Celsius", function () {
-    expect((0, _toCelsius.toCelsius)(273.15)).toBe(0);
-    expect((0, _toCelsius.toCelsius)(300)).toBe(26.85);
-    expect((0, _toCelsius.toCelsius)(373.15)).toBe(100);
-    expect((0, _toCelsius.toCelsius)(0)).toBe(-273.15);
-  });
-  it("should handle non-standard temperatures", function () {
-    expect((0, _toCelsius.toCelsius)(32)).toBe(-241.15);
-    expect((0, _toCelsius.toCelsius)(1000)).toBe(726.85);
-  });
-  it("should handle negative Kelvin values (though physically impossible)", function () {
-    expect((0, _toCelsius.toCelsius)(-100)).toBe(-373.15);
-  });
-});

package/module/es5/tests/unit/Math/toKelvin.test.d.ts

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

package/module/es5/tests/unit/Math/toKelvin.test.js

@@ -1,18 +0,0 @@
-"use strict";
-
-var _toKelvin = require("@/Math/toKelvin");
-describe("toKelvin function", function () {
-  it("should convert Celsius to Kelvin", function () {
-    expect((0, _toKelvin.toKelvin)(0)).toBe(273.15);
-    expect((0, _toKelvin.toKelvin)(26.85)).toBe(300);
-    expect((0, _toKelvin.toKelvin)(100)).toBe(373.15);
-  });
-  it("should handle negative Celsius values", function () {
-    expect((0, _toKelvin.toKelvin)(-40)).toBe(233.15);
-    expect((0, _toKelvin.toKelvin)(-273.15)).toBe(0);
-  });
-  it("should handle extreme temperatures", function () {
-    expect((0, _toKelvin.toKelvin)(1000)).toBe(1273.15);
-    expect((0, _toKelvin.toKelvin)(-300)).toBe(-26.85); // Below absolute zero (physically impossible)
-  });
-});

package/module/es5/tests/unit/Math/uuidv7.test.d.ts

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

package/module/es5/tests/unit/Math/uuidv7.test.js

@@ -1,33 +0,0 @@
-"use strict";
-
-var _uuidv = require("@/Math/uuidv7");
-describe("uuidv7 function", function () {
-  it("should generate UUID v7 with correct format", function () {
-    var uuid = (0, _uuidv.uuidv7)();
-    var uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-    expect(uuid).toMatch(uuidRegex);
-  });
-  it("should generate unique UUIDs", function () {
-    var uuid1 = (0, _uuidv.uuidv7)();
-    var uuid2 = (0, _uuidv.uuidv7)();
-    expect(uuid1).not.toBe(uuid2);
-  });
-  it("should have version 7", function () {
-    var uuid = (0, _uuidv.uuidv7)();
-    var version = uuid.split("-")[2][0];
-    expect(version).toBe("7");
-  });
-  it("should have correct variant", function () {
-    var uuid = (0, _uuidv.uuidv7)();
-    var variant = uuid.split("-")[3][0];
-    expect(["8", "9", "a", "b"]).toContain(variant);
-  });
-  it("should generate non-colliding UUIDs", function () {
-    var uuids = new Set();
-    for (var index = 0; index < 1000; index++) {
-      var uuid = (0, _uuidv.uuidv7)();
-      expect(uuids.has(uuid)).toBe(false);
-      uuids.add(uuid);
-    }
-  });
-});

package/module/es5/tests/unit/Math/valueSwap.test.d.ts

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

package/module/es5/tests/unit/Math/valueSwap.test.js

@@ -1,28 +0,0 @@
-"use strict";
-
-var _valueSwap = require("@/Math/valueSwap");
-describe("valueSwap function", function () {
-  it("should keep order when x < y", function () {
-    expect((0, _valueSwap.valueSwap)(1, 2)).toEqual([1, 2]);
-    expect((0, _valueSwap.valueSwap)(-2, -1)).toEqual([-2, -1]);
-    expect((0, _valueSwap.valueSwap)(0.1, 0.2)).toEqual([0.1, 0.2]);
-  });
-  it("should swap order when x > y", function () {
-    expect((0, _valueSwap.valueSwap)(2, 1)).toEqual([1, 2]);
-    expect((0, _valueSwap.valueSwap)(-1, -2)).toEqual([-2, -1]);
-    expect((0, _valueSwap.valueSwap)(0.2, 0.1)).toEqual([0.1, 0.2]);
-  });
-  it("should handle equal numbers", function () {
-    expect((0, _valueSwap.valueSwap)(1, 1)).toEqual([1, 1]);
-    expect((0, _valueSwap.valueSwap)(0, 0)).toEqual([0, 0]);
-    expect((0, _valueSwap.valueSwap)(-1, -1)).toEqual([-1, -1]);
-  });
-  it("should handle decimal numbers", function () {
-    expect((0, _valueSwap.valueSwap)(1.5, 1.2)).toEqual([1.2, 1.5]);
-    expect((0, _valueSwap.valueSwap)(0.5, 1.5)).toEqual([0.5, 1.5]);
-  });
-  it("should handle negative numbers", function () {
-    expect((0, _valueSwap.valueSwap)(-5, 5)).toEqual([-5, 5]);
-    expect((0, _valueSwap.valueSwap)(5, -5)).toEqual([-5, 5]);
-  });
-});

package/module/es5/tests/unit/Math/xoshiro256.test.d.ts

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

package/module/es5/tests/unit/Math/xoshiro256.test.js

@@ -1,33 +0,0 @@
-"use strict";
-
-var _xoshiro = require("@/Math/xoshiro256");
-describe("xoshiro256 function", function () {
-  it("should generate random numbers within the default range", function () {
-    var state = [1, 2, 3, 4];
-    var result = (0, _xoshiro.xoshiro256)(state);
-    expect(result).toBeGreaterThanOrEqual(0);
-    expect(result).toBeLessThan(1);
-  });
-  it("should generate the same sequence with the same seed values", function () {
-    var state1 = [1, 2, 3, 4];
-    var state2 = [1, 2, 3, 4];
-    var result1 = (0, _xoshiro.xoshiro256)(state1);
-    var result2 = (0, _xoshiro.xoshiro256)(state2);
-    expect(result1).toBe(result2);
-  });
-  it("should generate different sequences with different seed values", function () {
-    var state1 = [1, 2, 3, 4];
-    var state2 = [4, 3, 2, 1];
-    var result1 = (0, _xoshiro.xoshiro256)(state1);
-    var result2 = (0, _xoshiro.xoshiro256)(state2);
-    expect(result1).not.toBe(result2);
-  });
-  it("should respect the min and max parameters", function () {
-    var state = [1, 2, 3, 4];
-    var min = 10;
-    var max = 20;
-    var result = (0, _xoshiro.xoshiro256)(state, min, max);
-    expect(result).toBeGreaterThanOrEqual(min);
-    expect(result).toBeLessThan(max);
-  });
-});

package/module/es5/tests/unit/Object/has.test.d.ts

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

package/module/es5/tests/unit/Object/has.test.js

@@ -1,60 +0,0 @@
-"use strict";
-
-var _has = require("@/Object/has");
-describe("has", function () {
-  it("should return true for existing nested path (string)", function () {
-    expect((0, _has.has)({
-      a: {
-        b: 1
-      }
-    }, "a.b")).toBe(true);
-  });
-  it("should return true for existing nested path (array)", function () {
-    expect((0, _has.has)({
-      a: {
-        b: 1
-      }
-    }, ["a", "b"])).toBe(true);
-  });
-  it("should return false for non-existing nested path (string)", function () {
-    expect((0, _has.has)({
-      a: {
-        b: 1
-      }
-    }, "a.c")).toBe(false);
-  });
-  it("should return false for non-existing nested path (array)", function () {
-    expect((0, _has.has)({
-      a: {
-        b: 1
-      }
-    }, ["a", "c"])).toBe(false);
-  });
-  it("should return false for non-existing top-level path", function () {
-    expect((0, _has.has)({
-      a: {
-        b: 1
-      }
-    }, "b")).toBe(false);
-  });
-  it("should handle empty path (string)", function () {
-    expect((0, _has.has)({
-      a: {
-        b: 1
-      }
-    }, "")).toBe(false);
-  });
-  it("should handle empty path (array)", function () {
-    expect((0, _has.has)({
-      a: {
-        b: 1
-      }
-    }, [])).toBe(true);
-  });
-  it("should handle null or undefined object", function () {
-    // @ts-expect-error
-    expect((0, _has.has)(null, "a.b")).toBe(false);
-    // @ts-expect-error
-    expect((0, _has.has)(undefined, "a.b")).toBe(false);
-  });
-});

package/module/es5/tests/unit/Object/keyBy.test.d.ts

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

package/module/es5/tests/unit/Object/keyBy.test.js

@@ -1,120 +0,0 @@
-"use strict";
-
-var _keyBy = require("@/Object/keyBy");
-var _lodash = _interopRequireDefault(require("lodash"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-describe("keyBy", function () {
-  it("should create an object using property name as key", function () {
-    var input = [{
-      id: "a1",
-      name: "Alice"
-    }, {
-      id: "b2",
-      name: "Bob"
-    }];
-    var result = {
-      a1: {
-        id: "a1",
-        name: "Alice"
-      },
-      b2: {
-        id: "b2",
-        name: "Bob"
-      }
-    };
-    var output = (0, _keyBy.keyBy)(input, "id");
-    var lodashOutput = _lodash["default"].keyBy(input, "id");
-    expect(output).toEqual(result);
-    expect(lodashOutput).toEqual(result);
-  });
-  it("should generate keys using a custom function", function () {
-    var input = [{
-      dir: "left",
-      code: 97
-    }, {
-      dir: "right",
-      code: 100
-    }];
-    var result = {
-      a: {
-        dir: "left",
-        code: 97
-      },
-      d: {
-        dir: "right",
-        code: 100
-      }
-    };
-    var output = (0, _keyBy.keyBy)(input, function (o) {
-      return String.fromCharCode(o.code);
-    });
-    var lodashOutput = _lodash["default"].keyBy(input, function (o) {
-      return String.fromCharCode(o.code);
-    });
-    expect(output).toEqual(result);
-    expect(lodashOutput).toEqual(result);
-  });
-  it("should return an empty object for an empty array", function () {
-    var result = {};
-    var output = (0, _keyBy.keyBy)([], "id");
-    var lodashOutput = _lodash["default"].keyBy([], "id");
-    expect(output).toEqual(result);
-    expect(lodashOutput).toEqual(result);
-  });
-  it("should use later values when there are duplicate keys", function () {
-    var input = [{
-      id: "a1",
-      name: "Alice"
-    }, {
-      id: "a1",
-      name: "Alex"
-    }];
-    var result = {
-      a1: {
-        id: "a1",
-        name: "Alex"
-      }
-    };
-    var output = (0, _keyBy.keyBy)(input, "id");
-    var lodashOutput = _lodash["default"].keyBy(input, "id");
-    expect(output).toEqual(result);
-    expect(lodashOutput).toEqual(result);
-  });
-  it("should accept an object as input", function () {
-    var input = {
-      first: {
-        id: "a1",
-        name: "Alice"
-      },
-      second: {
-        id: "b2",
-        name: "Bob"
-      }
-    };
-    var result = {
-      a1: {
-        id: "a1",
-        name: "Alice"
-      },
-      b2: {
-        id: "b2",
-        name: "Bob"
-      }
-    };
-    var output = (0, _keyBy.keyBy)(input, "id");
-    var lodashOutput = _lodash["default"].keyBy(input, "id");
-    expect(output).toEqual(result);
-    expect(lodashOutput).toEqual(result);
-  });
-  it("should act as identity function when iteratee is not specified", function () {
-    var input = ["a", "b"];
-    var result = {
-      a: "a",
-      b: "b"
-    };
-    var output = (0, _keyBy.keyBy)(input);
-    var lodashOutput = _lodash["default"].keyBy(input);
-    expect(output).toEqual(result);
-    expect(lodashOutput).toEqual(result);
-  });
-});

package/module/es5/tests/unit/Object/pick.test.d.ts

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