@tempots/std 0.9.0

package/test/colors.spec.ts

@@ -0,0 +1,406 @@
+import { describe, expect, test } from 'vitest'
+import {
+  Channel,
+  hsl2hsluv,
+  hsl2hsv,
+  hsl2lab,
+  hsl2lch,
+  hsl2luv,
+  hsl2rgb,
+  hsl2srgb,
+  hsl2xyz,
+  hsluv2hsl,
+  hsluv2hsv,
+  hsluv2lab,
+  hsluv2lch,
+  hsluv2luv,
+  hsluv2rgb,
+  hsluv2srgb,
+  hsluv2xyz,
+  hsv2hsl,
+  hsv2hsluv,
+  hsv2lab,
+  hsv2lch,
+  hsv2luv,
+  hsv2rgb,
+  hsv2srgb,
+  hsv2xyz,
+  lab2hsl,
+  lab2hsluv,
+  lab2hsv,
+  lab2lch,
+  lab2luv,
+  lab2rgb,
+  lab2srgb,
+  lab2xyz,
+  lch2hsl,
+  lch2hsluv,
+  lch2hsv,
+  lch2lab,
+  lch2luv,
+  lch2rgb,
+  lch2srgb,
+  lch2xyz,
+  luv2hsl,
+  luv2hsluv,
+  luv2hsv,
+  luv2lab,
+  luv2lch,
+  luv2rgb,
+  luv2srgb,
+  luv2xyz,
+  rgb2hsl,
+  rgb2hsluv,
+  rgb2hsv,
+  rgb2lab,
+  rgb2lch,
+  rgb2luv,
+  rgb2srgb,
+  rgb2xyz,
+  srgb2hsl,
+  srgb2hsluv,
+  srgb2hsv,
+  srgb2lab,
+  srgb2lch,
+  srgb2luv,
+  srgb2rgb,
+  srgb2xyz,
+  WHITE_REFERENCE,
+  xyz2hsl,
+  xyz2hsluv,
+  xyz2hsv,
+  xyz2lab,
+  xyz2lch,
+  xyz2luv,
+  xyz2rgb,
+  xyz2srgb
+} from '../src/colors/convert'
+import { HSL } from '../src/colors/hsl'
+import { HSLuv } from '../src/colors/hsluv'
+import { HSV } from '../src/colors/hsv'
+import { LAB } from '../src/colors/lab'
+import { LCH } from '../src/colors/lch'
+import { LUV } from '../src/colors/luv'
+import { RGB } from '../src/colors/rgb'
+import { SRGB } from '../src/colors/srgb'
+import { XYZ } from '../src/colors/xyz'
+import { nearEquals } from '../src/numbers'
+
+expect.extend({
+  toNearEqual (
+    this: any,
+    received: number,
+    expected: number,
+    precision = 0.0001
+  ) {
+    const pass = nearEquals(received, expected, precision)
+    if (pass) {
+      return {
+        message: () => `expected ${received} to be near ${expected}`,
+        pass: true
+      }
+    } else {
+      return {
+        message: () => `expected ${received} to be near ${expected}`,
+        pass: false
+      }
+    }
+  },
+  toNearEqualArray (
+    this: any,
+    received: number[],
+    expected: number[],
+    tollerance = 0.01
+  ) {
+    const values = received.map((v, i) =>
+      nearEquals(v, expected[i], tollerance)
+    )
+    const pass = values.every(v => v)
+    const maybeNot = this.isNot ? 'not ' : ''
+    return {
+      message: () => `expected ${received} ${maybeNot}to equal ${expected}`,
+      pass
+    }
+  },
+  toColorEqual<
+    T extends { equals: (other: T, tollerance?: number) => boolean }
+  >(this: any, received: T, expected: T, tollerance = 0.001) {
+    const pass = received.equals(expected, tollerance)
+    const maybeNot = this.isNot ? 'not ' : ''
+    return {
+      message: () =>
+        `expected ${received} ${maybeNot}to equal ${expected} with tollerance ${tollerance}`,
+      pass
+    }
+  }
+})
+
+describe('Channel conversion', () => {
+  test('cmyk2rgb', () => {
+    expect(Channel.cmyk2rgb([0.6, 0.0, 0.08, 0.07])).toNearEqualArray([
+      0.372, 0.93, 0.8556
+    ])
+  })
+  test('hsl2hsv', () => {
+    expect(Channel.hsl2hsv([172, 0.8, 0.65])).toNearEqualArray([
+      172, 0.60215, 0.93
+    ])
+  })
+  test('hsv2hsl', () => {
+    expect(Channel.hsv2hsl([172, 0.60215, 0.93])).toNearEqualArray([
+      172, 0.8, 0.65
+    ])
+  })
+  test('hsl2lab', () => {
+    expect(Channel.lch2lab([86.07, 42.79865, 183.0])).toNearEqualArray([
+      86.07, -42.74, -2.24
+    ])
+  })
+  test('hsl2rgb', () => {
+    expect(Channel.hsl2rgb([172, 0.8, 0.65])).toNearEqualArray([
+      0.37, 0.9299, 0.8553
+    ])
+  })
+  test('lab2lch', () => {
+    expect(Channel.lab2lch([86.07, -42.74, -2.24])).toNearEqualArray([
+      86.07, 42.79865, 183.0
+    ])
+  })
+  test('lab2xyz', () => {
+    expect(
+      Channel.lab2xyz([86.07, -42.74, -2.24], WHITE_REFERENCE)
+    ).toNearEqualArray([
+      47.65533671728852, 68.12717437567908, 77.04768177230773
+    ])
+  })
+  test('lch2lab', () => {
+    expect(Channel.lch2lab([86, 42.699, 183.024])).toNearEqualArray([
+      86.0, -42.64, -2.25
+    ])
+  })
+  test('luv2xyz', () => {
+    expect(
+      Channel.luv2xyz([81.495, -60.109, 95.919], WHITE_REFERENCE)
+    ).toNearEqualArray([33.727, 59.37, 10.602])
+  })
+  test('rgb2cmyk', () => {
+    expect(Channel.rgb2cmyk([0.372, 0.93, 0.8556])).toNearEqualArray([
+      0.6, 0.0, 0.08, 0.07
+    ])
+  })
+  test('rgb2hsl', () => {
+    expect(Channel.rgb2hsl([0.37, 0.9299, 0.8553])).toNearEqualArray([
+      172, 0.8, 0.65
+    ])
+  })
+  test('rgb2xyz', () => {
+    expect(Channel.rgb2xyz([100 / 255, 230 / 255, 25 / 255])).toNearEqualArray([
+      33.727, 59.37, 10.602
+    ])
+  })
+  test('xyz2lab', () => {
+    expect(
+      Channel.xyz2lab([47.6553, 68.1272, 77.0477], WHITE_REFERENCE)
+    ).toNearEqualArray([86.07001279, -42.74015717, -2.2399919])
+  })
+  test('xyz2luv', () => {
+    expect(
+      Channel.xyz2luv([33.727, 59.37, 10.602], WHITE_REFERENCE)
+    ).toNearEqualArray([81.495, -60.109, 95.919])
+  })
+  test('xyz2rgb', () => {
+    expect(Channel.xyz2rgb([33.727, 59.37, 10.602])).toNearEqualArray([
+      100 / 255,
+      230 / 255,
+      25 / 255
+    ])
+  })
+})
+
+const data: Array<[string, HSL, HSLuv, HSV, LAB, LCH, LUV, RGB, SRGB, XYZ]> = [
+  [
+    'white',
+    new HSL(0, 0, 100),
+    new HSLuv(0, 0, 100),
+    new HSV(0, 0, 100),
+    new LAB(100.0, 0.00526049995830391, -0.010408184525267927),
+    new LCH(100, 0.011662039483869973, 296.81292623674057),
+    new LUV(100, 0.0008906695967064726, -0.01710795288980549), // ?
+    new RGB(0xffffff),
+    new SRGB(100, 100, 100),
+    new XYZ(95.047, 100.00001, 108.883)
+  ],
+  [
+    'black',
+    new HSL(0, 0, 0),
+    new HSLuv(0, 0, 0),
+    new HSV(0, 0, 0),
+    new LAB(0, 0, 0),
+    new LCH(0, 0, 0),
+    new LUV(0, 0, 0), // ?
+    new RGB(0x000000),
+    new SRGB(0, 0, 0),
+    new XYZ(0, 0, 0)
+  ],
+  [
+    'red',
+    new HSL(0, 100, 50),
+    new HSLuv(39.99901061253295, 130.2942612189005, 53.24079414130722),
+    new HSV(0, 100, 100),
+    new LAB(53.24079414130722, 80.09245959641109, 67.20319651585301),
+    new LCH(53.24079414130722, 104.55176567686985, 39.99901061253295),
+    new LUV(53.23711, 175.00981, 37.7651),
+    new RGB(0xff0000),
+    new SRGB(100, 0, 0),
+    new XYZ(41.24564, 21.26729, 1.93339)
+  ],
+  [
+    'blue',
+    new HSL(240, 100, 50),
+    new HSLuv(306.2849380699878, 180.58923065120075, 32.297010932850725),
+    new HSV(240, 100, 100),
+    new LAB(32.297010932850725, 79.18751984512224, -107.8601617541481),
+    new LCH(32.297010932850725, 133.80761485376166, 306.2849380699878),
+    new LUV(32.30087, -9.40241, -130.35109), // ?
+    new RGB(0x0000ff),
+    new SRGB(0, 0, 100),
+    new XYZ(18.04375, 7.2175, 95.03041)
+  ],
+  [
+    'orange',
+    new HSL(25, 100, 50),
+    new HSLuv(53.47833595850165, 111.817148741431, 63.03279007232754),
+    new HSV(25, 100, 100),
+    new LAB(63.03279007232754, 53.11047037606681, 71.71795303124753),
+    new LCH(63.03279007232754, 89.24229294767866, 53.47833595850165),
+    new LUV(63.03017, 124.01539, 54.82948), // ?
+    new RGB(0xff6a00),
+    new SRGB(100, 41.66666666666667, 0),
+    new XYZ(46.42513, 31.62627, 3.659886)
+  ],
+  [
+    'magenta',
+    new HSL(300, 100, 50),
+    new HSLuv(328.23496466690494, 98.52676527397858, 60.32421212836874),
+    new HSV(300, 100, 100),
+    new LAB(60.32421212836874, 98.23431188800397, -60.82489220885008),
+    new LCH(60.32421212836874, 115.54067484798533, 328.23496466690494),
+    new LUV(60.32273, 84.05559, -108.69637), // ?
+    new RGB(0xff00ff),
+    new SRGB(100, 0, 100),
+    new XYZ(59.28939, 28.48479, 96.9638)
+  ]
+]
+
+describe.each(data)(
+  'testing %s',
+  (name, hsl, hsluv, hsv, lab, lch, luv, rgb, srgb, xyz) => {
+    test(`Convert HSL ${name}`, () => {
+      expect(hsl).toColorEqual(hsl)
+      expect(hsl2hsluv(hsl)).toColorEqual(hsluv)
+      expect(hsl2hsv(hsl)).toColorEqual(hsv)
+      expect(hsl2lab(hsl)).toColorEqual(lab)
+      expect(hsl2lch(hsl)).toColorEqual(lch)
+      expect(hsl2luv(hsl)).toColorEqual(luv, 0.1)
+      expect(hsl2rgb(hsl)).toColorEqual(rgb)
+      expect(hsl2srgb(hsl)).toColorEqual(srgb)
+      expect(hsl2xyz(hsl)).toColorEqual(xyz)
+    })
+
+    test(`Convert HSLuv ${name}`, () => {
+      expect(hsluv).toColorEqual(hsluv)
+      expect(hsluv2hsl(hsluv)).toColorEqual(hsl)
+      expect(hsluv2hsv(hsluv)).toColorEqual(hsv)
+      expect(hsluv2lab(hsluv)).toColorEqual(lab)
+      expect(hsluv2lch(hsluv)).toColorEqual(lch)
+      expect(hsluv2luv(hsluv)).toColorEqual(luv, 0.1)
+      expect(hsluv2rgb(hsluv)).toColorEqual(rgb)
+      expect(hsluv2srgb(hsluv)).toColorEqual(srgb)
+      expect(hsluv2xyz(hsluv)).toColorEqual(xyz)
+    })
+
+    test(`Convert HSV ${name}`, () => {
+      expect(hsv).toColorEqual(hsv)
+      expect(hsv2hsl(hsv)).toColorEqual(hsl)
+      expect(hsv2hsluv(hsv)).toColorEqual(hsluv)
+      expect(hsv2lab(hsv)).toColorEqual(lab)
+      expect(hsv2lch(hsv)).toColorEqual(lch)
+      expect(hsv2luv(hsv)).toColorEqual(luv, 0.1)
+      expect(hsv2rgb(hsv)).toColorEqual(rgb)
+      expect(hsv2srgb(hsv)).toColorEqual(srgb)
+      expect(hsv2xyz(hsv)).toColorEqual(xyz)
+    })
+
+    test(`Convert LAB ${name}`, () => {
+      expect(lab).toColorEqual(lab)
+      expect(lab2hsl(lab)).toColorEqual(hsl)
+      expect(lab2hsluv(lab)).toColorEqual(hsluv)
+      expect(lab2hsv(lab)).toColorEqual(hsv, 0.1)
+      expect(lab2lch(lab)).toColorEqual(lch)
+      expect(lab2luv(lab)).toColorEqual(luv, 0.1)
+      expect(lab2rgb(lab)).toColorEqual(rgb)
+      expect(lab2srgb(lab)).toColorEqual(srgb)
+      expect(lab2xyz(lab)).toColorEqual(xyz, 0.1)
+    })
+
+    test(`Convert LCH ${name}`, () => {
+      expect(lch).toColorEqual(lch)
+      expect(lch2hsl(lch)).toColorEqual(hsl)
+      expect(lch2hsluv(lch)).toColorEqual(hsluv)
+      expect(lch2hsv(lch)).toColorEqual(hsv, 0.1)
+      expect(lch2lab(lch)).toColorEqual(lab)
+      expect(lch2luv(lch)).toColorEqual(luv, 0.1)
+      expect(lch2rgb(lch)).toColorEqual(rgb)
+      expect(lch2srgb(lch)).toColorEqual(srgb)
+      expect(lch2xyz(lch)).toColorEqual(xyz, 0.1)
+    })
+
+    test(`Convert LUV ${name}`, () => {
+      expect(luv).toColorEqual(luv)
+      expect(luv2hsl(luv)).toColorEqual(hsl, 0.1)
+      expect(luv2hsluv(luv)).toColorEqual(hsluv, 0.1)
+      expect(luv2hsv(luv)).toColorEqual(hsv, 0.1)
+      expect(luv2lab(luv)).toColorEqual(lab, 0.1)
+      expect(luv2lch(luv)).toColorEqual(lch, 0.1)
+      expect(luv2rgb(luv)).toColorEqual(rgb, 0.1)
+      expect(luv2srgb(luv)).toColorEqual(srgb, 0.1)
+      expect(luv2xyz(luv)).toColorEqual(xyz, 0.1)
+    })
+
+    test(`Convert RGB ${name}`, () => {
+      expect(rgb).toColorEqual(rgb)
+      expect(rgb2hsl(rgb)).toColorEqual(hsl, 0.2)
+      expect(rgb2hsluv(rgb)).toColorEqual(hsluv, 0.2)
+      expect(rgb2hsv(rgb)).toColorEqual(hsv, 0.2)
+      expect(rgb2lab(rgb)).toColorEqual(lab, 0.2)
+      expect(rgb2lch(rgb)).toColorEqual(lch, 0.2)
+      expect(rgb2luv(rgb)).toColorEqual(luv, 0.5)
+      expect(rgb2srgb(rgb)).toColorEqual(srgb, 0.2)
+      expect(rgb2xyz(rgb)).toColorEqual(xyz, 0.2)
+    })
+
+    test(`Convert sRGB ${name}`, () => {
+      expect(srgb).toColorEqual(srgb)
+      expect(srgb2hsl(srgb)).toColorEqual(hsl)
+      expect(srgb2hsluv(srgb)).toColorEqual(hsluv)
+      expect(srgb2hsv(srgb)).toColorEqual(hsv)
+      expect(srgb2lab(srgb)).toColorEqual(lab)
+      expect(srgb2lch(srgb)).toColorEqual(lch)
+      expect(srgb2luv(srgb)).toColorEqual(luv, 0.1)
+      expect(srgb2rgb(srgb)).toColorEqual(rgb)
+      expect(srgb2xyz(srgb)).toColorEqual(xyz)
+    })
+
+    test(`Convert XYZ ${name}`, () => {
+      expect(xyz).toColorEqual(xyz)
+      expect(xyz2hsl(xyz)).toColorEqual(hsl)
+      expect(xyz2hsluv(xyz)).toColorEqual(hsluv)
+      expect(xyz2hsv(xyz)).toColorEqual(hsv)
+      expect(xyz2lab(xyz)).toColorEqual(lab)
+      expect(xyz2lch(xyz)).toColorEqual(lch)
+      expect(xyz2luv(xyz)).toColorEqual(luv, 0.1)
+      expect(xyz2rgb(xyz)).toColorEqual(rgb)
+      expect(xyz2srgb(xyz)).toColorEqual(srgb)
+    })
+  }
+)

package/test/commmon.ts

@@ -0,0 +1,9 @@
+export interface Union1 { type: 'Union1', v1: number }
+export interface Union2 { type: 'Union2', v2: boolean }
+export interface Union3 { type: 'Union3', v3: string }
+
+export type Union = Union1 | Union2 | Union3
+
+export const makeUnion1 = (v1: number): Union1 => ({ type: 'Union1', v1 })
+export const makeUnion2 = (v2: boolean): Union2 => ({ type: 'Union2', v2 })
+export const makeUnion3 = (v3: string): Union3 => ({ type: 'Union3', v3 })

package/test/equals.spec.ts

@@ -0,0 +1,165 @@
+/*
+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.
+*/
+
+import { describe, expect, test } from 'vitest'
+import { strictEqual, deepEqual, looseEqual } from '../src/equals'
+
+describe('equals', () => {
+  test('strictEqual with number', () => {
+    expect(strictEqual(1, 1)).toBe(true)
+    expect(strictEqual(0, 0)).toBe(true)
+    expect(strictEqual(-1, -1)).toBe(true)
+
+    expect(strictEqual(Math.E, Math.E)).toBe(true)
+    expect(strictEqual(Math.LN10, Math.LN10)).toBe(true)
+    expect(strictEqual(Math.LN2, Math.LN2)).toBe(true)
+    expect(strictEqual(Math.LOG10E, Math.LOG10E)).toBe(true)
+    expect(strictEqual(Math.PI, Math.PI)).toBe(true)
+    expect(strictEqual(Math.SQRT1_2, Math.SQRT1_2)).toBe(true)
+    expect(strictEqual(Math.SQRT2, Math.SQRT2)).toBe(true)
+
+    expect(strictEqual(Infinity, Infinity)).toBe(true)
+    expect(strictEqual(-Infinity, -Infinity)).toBe(true)
+    expect(strictEqual(NaN, NaN)).toBe(true)
+
+    expect(strictEqual(-Infinity, Infinity)).toBe(false)
+    expect(strictEqual(-1, 1)).toBe(false)
+  })
+
+  test('strictEqual with string', () => {
+    expect(strictEqual('', '')).toBe(true)
+    expect(strictEqual('a', 'a')).toBe(true)
+
+    expect(strictEqual('A', 'a')).toBe(false)
+  })
+
+  test('strictEqual with date', () => {
+    const a = new Date('2020-01-02')
+    const b = new Date('2020-01-02')
+    expect(strictEqual(a, a)).toBe(true)
+    expect(strictEqual(a, b)).toBe(false)
+  })
+
+  test('deepEqual with number', () => {
+    expect(deepEqual(1, 1)).toBe(true)
+    expect(deepEqual(0, 0)).toBe(true)
+    expect(deepEqual(-1, -1)).toBe(true)
+
+    expect(deepEqual(Math.E, Math.E)).toBe(true)
+    expect(deepEqual(Math.LN10, Math.LN10)).toBe(true)
+    expect(deepEqual(Math.LN2, Math.LN2)).toBe(true)
+    expect(deepEqual(Math.LOG10E, Math.LOG10E)).toBe(true)
+    expect(deepEqual(Math.PI, Math.PI)).toBe(true)
+    expect(deepEqual(Math.SQRT1_2, Math.SQRT1_2)).toBe(true)
+    expect(deepEqual(Math.SQRT2, Math.SQRT2)).toBe(true)
+
+    expect(deepEqual(Infinity, Infinity)).toBe(true)
+    expect(deepEqual(-Infinity, -Infinity)).toBe(true)
+    expect(deepEqual(NaN, NaN)).toBe(true)
+
+    expect(deepEqual(-Infinity, Infinity)).toBe(false)
+    expect(deepEqual(-1, 1)).toBe(false)
+  })
+
+  test('deepEqual with string', () => {
+    expect(deepEqual('', '')).toBe(true)
+    expect(deepEqual('a', 'a')).toBe(true)
+
+    expect(deepEqual('A', 'a')).toBe(false)
+  })
+
+  test('deepEqual with date', () => {
+    const a = new Date('2020-01-01')
+    const b = new Date('2020-01-01')
+    const c = new Date('2020-01-02')
+    expect(deepEqual(a, a)).toBe(true)
+    expect(deepEqual(a, b)).toBe(true)
+    expect(deepEqual(a, c)).toBe(false)
+  })
+
+  test('deepEqual with arrays', () => {
+    const a = [1, 'a']
+    const b = [1, 'a']
+    const c = [1, 2]
+    expect(deepEqual(a, a)).toBe(true)
+    expect(deepEqual(a, b)).toBe(true)
+    expect(deepEqual(a, c)).toBe(false)
+  })
+
+  test('deepEqual with objects', () => {
+    const a = { a: 1, b: 'b' }
+    const b = { a: 1, b: 'b' }
+    const c = { a: 1, b: 2 } as never
+    const d = { a: 1, b: 'b', c: undefined }
+    const e = { a: 1, b: 'b', c: undefined }
+    const f = { a: 1, b: 'b', c: null } as Record<string, unknown>
+    expect(deepEqual(a, a)).toBe(true)
+    expect(deepEqual(a, b)).toBe(true)
+    expect(deepEqual(a, c)).toBe(false)
+    expect(deepEqual(a, d)).toBe(false)
+    expect(deepEqual(f, e)).toBe(false)
+    expect(deepEqual(f, { ...f } as never)).toBe(true)
+  })
+
+  test('deepEqual with deep structures', () => {
+    const get = () => ({
+      a: 1,
+      b: {
+        c: undefined,
+        d: '1',
+        e: new Date('2020-01-01'),
+        f: [1, { g: true }]
+      }
+    })
+
+    expect(deepEqual(get(), get())).toBe(true)
+  })
+
+  test('deepEqual with Set', () => {
+    const get = () => new Set([1, 2, 3])
+    const get2 = () => new Set([1, 2, 4])
+
+    expect(deepEqual(get(), get())).toBe(true)
+    expect(deepEqual(get(), get2())).toBe(false)
+  })
+
+  test('deepEqual with Map', () => {
+    const get = () => {
+      const map = new Map()
+      map.set(1, 'a')
+      map.set(2, 'b')
+      map.set(3, 'c')
+      return map
+    }
+    const get2 = () => {
+      const map = new Map()
+      map.set(1, 'a')
+      map.set(2, 'b')
+      map.set(3, 'd')
+      return map
+    }
+
+    expect(deepEqual(get(), get())).toBe(true)
+    expect(deepEqual(get(), get2())).toBe(false)
+  })
+
+  test('looseEqual matches expectations', () => {
+    expect(looseEqual(1, 1)).toBe(true)
+    expect(looseEqual(1, 0)).toBe(false)
+    expect(looseEqual(null, null)).toBe(true)
+    expect(looseEqual(null, undefined)).toBe(true)
+    expect(looseEqual(null, '')).toBe(false)
+    expect(looseEqual(null, 0)).toBe(false)
+    expect(looseEqual('', 0 as unknown as string)).toBe(true)
+  })
+})

package/test/functions.spec.ts

@@ -0,0 +1,9 @@
+import { id } from '../src/functions'
+import { describe, expect, test } from 'vitest'
+
+describe('functions helpers', () => {
+  test('id', () => {
+    expect(id(1)).toBe(1)
+    expect(id('a')).toBe('a')
+  })
+})

package/test/index.d.ts

@@ -0,0 +1,20 @@
+export {}
+
+declare global {
+  namespace jest {
+    interface Matchers<R> {
+      toColorEqual<T>(value: T, precision?: number): R
+      toNearEqual(value: number): R
+      toNearEqualArray(value: [number, number, number]): R
+      toNearEqualArray(value: number[]): R
+    }
+  }
+  namespace vitest {
+    interface Matchers<R> {
+      toColorEqual<T>(value: T, precision?: number): R
+      toNearEqual(value: number): R
+      toNearEqualArray(value: [number, number, number]): R
+      toNearEqualArray(value: number[]): R
+    }
+  }
+}

package/test/objects.spec.ts

@@ -0,0 +1,22 @@
+import { sameKeys, isObject } from '../src/objects'
+import { describe, expect, test } from 'vitest'
+
+describe('objects helpers', () => {
+  test('sameKeys works as expected', () => {
+    expect(sameKeys({}, {})).toBe(true)
+    expect(sameKeys({ a: 1 }, { a: 2 })).toBe(true)
+    expect(sameKeys({ a: 1, b: 'c' }, { a: 2, b: true })).toBe(true)
+    expect(sameKeys({ a: 1 }, { a: 2, b: true })).toBe(false)
+    expect(sameKeys({ a: 1 }, { b: true })).toBe(false)
+  })
+
+  test('isObject behaves as expected', () => {
+    expect(isObject({})).toBe(true)
+    expect(isObject({ 1: 2 })).toBe(true)
+    expect(isObject({ a: 2 })).toBe(true)
+    expect(isObject(null)).toBe(false)
+    expect(isObject(undefined)).toBe(false)
+    expect(isObject(Array.from([1, 2]))).toBe(false)
+    expect(isObject('v')).toBe(false)
+  })
+})

package/test/reg-exps.spec.ts

@@ -0,0 +1,33 @@
+/*
+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.
+*/
+
+import { map } from '../src/reg-exps'
+import { describe, expect, test } from 'vitest'
+
+describe('reg_exps.ts', () => {
+  test('Map with non-global pattern', () => {
+    const pattern = /xx|yyy/
+    expect(map('axxbbyyyc', pattern, v => v.toUpperCase())).toBe('aXXbbYYYc')
+    expect(map('xxbbyyy', pattern, v => v.toUpperCase())).toBe('XXbbYYY')
+    expect(map('xx', pattern, v => v.toUpperCase())).toBe('XX')
+    expect(map('x', pattern, v => v.toUpperCase())).toBe('x')
+  })
+
+  test('Map with global pattern', () => {
+    const pattern = /xx|yyy/g
+    expect(map('axxbbyyyc', pattern, v => v.toUpperCase())).toBe('aXXbbYYYc')
+    expect(map('xxbbyyy', pattern, v => v.toUpperCase())).toBe('XXbbYYY')
+    expect(map('xx', pattern, v => v.toUpperCase())).toBe('XX')
+    expect(map('x', pattern, v => v.toUpperCase())).toBe('x')
+  })
+})