@voiceflow/common 8.2.8 → 8.3.0

package/build/cjs/utils/slot.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=slot.test.d.ts.map

package/build/cjs/utils/slot.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slot.test.d.ts","sourceRoot":"","sources":["../../../src/utils/slot.test.ts"],"names":[],"mappings":""}

package/build/cjs/utils/slot.test.js

@@ -1,38 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const SlotUtils = __importStar(require("./slot"));
-describe('Utils | slot', () => {
-    describe('getValueWithSynonyms', () => {
-        it('extracts synonyms', () => {
-            expect(SlotUtils.getValueWithSynonyms('a, b, c, d')).toEqual(['a', ['b', 'c', 'd']]);
-        });
-    });
-    describe('mapSlotAnnotations', () => {
-        it('renames keys and maps', () => {
-            expect(SlotUtils.mapSlotAnnotations('test {{[name].key}} thing', () => ({ key: 'newKey', name: 'newName' }))).toEqual('test {{[newName].newKey}} thing');
-        });
-    });
-});

package/build/cjs/utils/string.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=string.test.d.ts.map

package/build/cjs/utils/string.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"string.test.d.ts","sourceRoot":"","sources":["../../../src/utils/string.test.ts"],"names":[],"mappings":""}

package/build/cjs/utils/string.test.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const string_1 = require("./string");
-describe('Utils | string', () => {
-    describe('capitalizeFirstLetter()', () => {
-        it('capitalizes the first letter', () => {
-            expect((0, string_1.capitalizeFirstLetter)('')).toBe('');
-            expect((0, string_1.capitalizeFirstLetter)('123')).toBe('123');
-            expect((0, string_1.capitalizeFirstLetter)('abc')).toBe('Abc');
-        });
-    });
-    describe('capitalizeAllWords()', () => {
-        it('capitalizes all the space-delimited words', () => {
-            expect((0, string_1.capitalizeAllWords)('')).toBe('');
-            expect((0, string_1.capitalizeAllWords)('abc')).toBe('Abc');
-            expect((0, string_1.capitalizeAllWords)('abc def')).toBe('Abc Def');
-        });
-    });
-    describe('arrayStringReplace()', () => {
-        it('replace a pattern for each item in an array', () => {
-            expect((0, string_1.arrayStringReplace)('x', 'y', [])).toEqual([]);
-            expect((0, string_1.arrayStringReplace)('x', 'y', ['foo'])).toEqual(['foo']);
-            expect((0, string_1.arrayStringReplace)('x', 'y', ['xyz', 'foo', 'fox', 'bar'])).toEqual(['yyz', 'foo', 'foy', 'bar']);
-        });
-    });
-    describe('stripHTMLTags()', () => {
-        it('remove HTML tags from a string', () => {
-            expect((0, string_1.stripHTMLTags)('')).toBe('');
-            expect((0, string_1.stripHTMLTags)('<')).toBe('<');
-            expect((0, string_1.stripHTMLTags)('<>')).toBe('<>');
-            expect((0, string_1.stripHTMLTags)('<foo>')).toBe('');
-            expect((0, string_1.stripHTMLTags)('a b c d')).toBe('a b c d');
-            expect((0, string_1.stripHTMLTags)('a <foo> b <bar> c <fizz> d')).toBe('a  b  c  d');
-        });
-    });
-    describe('removeTrailingUnderscores()', () => {
-        it('remove leading and trailing underscore characters', () => {
-            expect((0, string_1.removeTrailingUnderscores)('')).toBe('');
-            expect((0, string_1.removeTrailingUnderscores)('foo')).toBe('foo');
-            expect((0, string_1.removeTrailingUnderscores)('__foo')).toBe('foo');
-            expect((0, string_1.removeTrailingUnderscores)('foo__')).toBe('foo');
-            expect((0, string_1.removeTrailingUnderscores)('__foo__')).toBe('foo');
-        });
-    });
-    describe('conditionalReplace()', () => {
-        it('do nothing with falsey value', () => {
-            expect((0, string_1.conditionalReplace)('fizz', /i/)).toBe('fizz');
-        });
-        it('use truthy value as replacement value', () => {
-            expect((0, string_1.conditionalReplace)('fizz', /i/, 'u')).toBe('fuzz');
-        });
-    });
-});

package/build/cjs/utils/timezones.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=timezones.test.d.ts.map

package/build/cjs/utils/timezones.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timezones.test.d.ts","sourceRoot":"","sources":["../../../src/utils/timezones.test.ts"],"names":[],"mappings":""}

package/build/cjs/utils/timezones.test.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const array_1 = require("./array");
-const timezones_1 = require("./timezones");
-describe('Utils | timezones', () => {
-    describe('TIMEZONES', () => {
-        it('a list of all timezones', () => {
-            expect(timezones_1.TIMEZONES.length).toBe(490);
-            expect((0, array_1.unique)(timezones_1.TIMEZONES)).toEqual(timezones_1.TIMEZONES);
-        });
-    });
-});

package/build/cjs/utils/typeguard.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=typeguard.test.d.ts.map

package/build/cjs/utils/typeguard.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typeguard.test.d.ts","sourceRoot":"","sources":["../../../src/utils/typeguard.test.ts"],"names":[],"mappings":""}

package/build/cjs/utils/typeguard.test.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const typeguard_1 = require("./typeguard");
-describe('Utils | typeguard', () => {
-    describe('createTypeguardCreator()', () => {
-        it('casts the guarded argument', () => {
-            const createTypeguard = (0, typeguard_1.createTypeguardCreator)();
-            const input = 'foo';
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const assertTyped = (_arg) => undefined;
-            const typeguard = createTypeguard('foo');
-            if (typeguard(input)) {
-                assertTyped(input);
-            }
-        });
-        it('typeguard against a single value', () => {
-            const createTypeguard = (0, typeguard_1.createTypeguardCreator)();
-            const typeguard = createTypeguard('foo');
-            expect(typeguard('foo')).toBe(true);
-            expect(typeguard('bar')).toBe(false);
-        });
-        it('typeguard against an array of values', () => {
-            const createTypeguard = (0, typeguard_1.createTypeguardCreator)();
-            const typeguard = createTypeguard(['foo', 'bar']);
-            expect(typeguard('foo')).toBe(true);
-            expect(typeguard('bar')).toBe(true);
-            expect(typeguard('fizz')).toBe(false);
-        });
-    });
-    describe('createTypedTypeguardCreator()', () => {
-        it('casts the guarded argument', () => {
-            const createTypeguard = (0, typeguard_1.createTypedTypeguardCreator)();
-            const input = { type: 'foo', id: 123 };
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const assertTyped = (_arg) => undefined;
-            const typeguard = createTypeguard('foo');
-            if (typeguard(input)) {
-                assertTyped(input);
-            }
-        });
-        it('typeguard against a single value', () => {
-            const createTypeguard = (0, typeguard_1.createTypedTypeguardCreator)();
-            const typeguard = createTypeguard('foo');
-            expect(typeguard({ type: 'foo', id: 1 })).toBe(true);
-            expect(typeguard({ type: 'bar', id: 2 })).toBe(false);
-        });
-        it('typeguard against an array of values', () => {
-            const createTypeguard = (0, typeguard_1.createTypedTypeguardCreator)();
-            const typeguard = createTypeguard(['foo', 'bar']);
-            expect(typeguard({ type: 'foo', id: 1 })).toBe(true);
-            expect(typeguard({ type: 'bar', id: 2 })).toBe(true);
-            expect(typeguard({ type: 'fizz', id: 3 })).toBe(false);
-        });
-    });
-});

package/build/esm/crypto/hex2abc.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=hex2abc.test.d.ts.map

package/build/esm/crypto/hex2abc.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hex2abc.test.d.ts","sourceRoot":"","sources":["../../../src/crypto/hex2abc.test.ts"],"names":[],"mappings":""}

package/build/esm/crypto/hex2abc.test.js

@@ -1,10 +0,0 @@
-import { hex2abc } from './hex2abc.js';
-describe('hex2abc()', () => {
-    it('works', () => {
-        expect(hex2abc('abcdef')).toBe('abcdef');
-        expect(hex2abc('0123456789')).toBe('ghijklmnop');
-    });
-    it('works with 0x prefixes', () => {
-        expect(hex2abc('0xabc123')).toBe('gxabchij');
-    });
-});

package/build/esm/crypto/murmurhash.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=murmurhash.test.d.ts.map

package/build/esm/crypto/murmurhash.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"murmurhash.test.d.ts","sourceRoot":"","sources":["../../../src/crypto/murmurhash.test.ts"],"names":[],"mappings":""}

package/build/esm/crypto/murmurhash.test.js

@@ -1,21 +0,0 @@
-import { MurmurHash } from './murmurhash.js';
-// for second test check (4 byte chunk)
-// const buf_left = Buffer.of(0xff, 0xff, 0xff, 0xff);
-// const buf_right = Buffer.of(0x76, 0x29, 0x3b, 0x50);
-// for third test check (correct endian order)
-// const buf_left_two = Buffer.of(0x21, 0x43, 0x65, 0x87);
-// const buf_right_two = Buffer.of(0xf5, 0x5b, 0x51, 0x6b);
-describe('hash()', () => {
-    it('return a 32-bit hash resulting from the murmurhash3 algorithm', () => {
-        expect(MurmurHash.hash('hello', 0)).toBe('lokkdakm');
-        expect(MurmurHash.hash('hello world', 0)).toBe('kkehkpgl');
-        expect(MurmurHash.hash('helloworld', 0)).toBe('holkilfm');
-        expect(MurmurHash.hash('HELLOWORLD', 0)).toBe('dohkopda');
-        expect(MurmurHash.hash('', 0)).toBe('g'); // not sure why '0000 0000' fails as a test
-        expect(MurmurHash.hash('abc', 0)).toBe('bjddpjfa');
-        expect(MurmurHash.hash('ABC', 0)).toBe('kjchcljl');
-        // from https://github.com/jonahsnider/murmurhash-wasm/blob/main/test/murmur-hash3/hash-32.test.ts
-        // expect(MurmurHash.hash(buf_left.toString('hex'), 0)).to.eql(buf_right.toString('hex'));
-        // expect(MurmurHash.hash(buf_left_two.toString('hex'), 0)).to.eql(buf_right_two.toString('hex'));
-    });
-});

package/build/esm/utils/__fixtures__/name.json

@@ -1,64 +0,0 @@
-{
-    "slots": [
-        {
-            "key": "4i3h3mmi",
-            "name": "slotmans",
-            "type": {
-                "value": "custom"
-            },
-            "color": "#4F9ED1",
-            "inputs": ["tyler", "john", "scott", "michael", "william", "andy", "peter", "frank", "igor", "steven", "jessica"]
-        }
-    ],
-    "intents": [
-        {
-            "key": "3sb53sup",
-            "name": "name_intent",
-            "slots": [
-                {
-                    "id": "4i3h3mmi",
-                    "dialog": {
-                        "prompt": [
-                            {
-                                "text": "",
-                                "slots": []
-                            }
-                        ],
-                        "confirm": [
-                            {
-                                "text": "",
-                                "slots": []
-                            }
-                        ],
-                        "utterances": [
-                            {
-                                "text": "{{[name].4i3h3mmi}} ",
-                                "slots": ["4i3h3mmi"]
-                            }
-                        ],
-                        "confirmEnabled": false
-                    },
-                    "required": false
-                }
-            ],
-            "inputs": [
-                {
-                    "text": "It's {{[slotmans].4i3h3mmi}}",
-                    "slots": ["4i3h3mmi"]
-                },
-                {
-                    "text": "I'm {{[slotmans].4i3h3mmi}}",
-                    "slots": ["4i3h3mmi"]
-                },
-                {
-                    "text": "{{[slotmans].4i3h3mmi}}",
-                    "slots": ["4i3h3mmi"]
-                },
-                {
-                    "text": "my name is {{[slotmans].4i3h3mmi}}",
-                    "slots": ["4i3h3mmi"]
-                }
-            ]
-        }
-    ]
-}

package/build/esm/utils/array.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=array.test.d.ts.map

package/build/esm/utils/array.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.test.d.ts","sourceRoot":"","sources":["../../../src/utils/array.test.ts"],"names":[],"mappings":""}

package/build/esm/utils/array.test.js

@@ -1,235 +0,0 @@
-import { append, createEntries, createMap, diff, filterAndGetLastRemovedValue, filterOutNullish, findUnion, hasIdenticalMembers, head, insert, insertAll, isNotNullish, isNullish, mergeByIdentifier, reorder, replace, separate, tail, toArray, toggleMembership, unique, without, withoutValue, withoutValues, } from './array.js';
-describe('Utils | array', () => {
-    describe('unique()', () => {
-        it('return an array containing one instance of each value from the array passed to it', () => {
-            expect(unique([1, 1, 2, 0, 1, 4, 3, 1, 9, 9, 2])).toEqual([1, 2, 0, 4, 3, 9]);
-        });
-    });
-    describe('without()', () => {
-        it('return an array containing every value from the array passed to it except for the value at the provided index', () => {
-            expect(without([], -1)).toEqual([]);
-            expect(without([], 0)).toEqual([]);
-            expect(without(['a', 'b', 'c', 'd'], -1)).toEqual(['a', 'b', 'c', 'd']);
-            expect(without(['a', 'b', 'c', 'd'], 0)).toEqual(['b', 'c', 'd']);
-            expect(without(['a', 'b', 'c', 'd'], 2)).toEqual(['a', 'b', 'd']);
-            expect(without(['a', 'b', 'c', 'd'], 4)).toEqual(['a', 'b', 'c', 'd']);
-        });
-    });
-    describe('withoutValue()', () => {
-        it('return an array containing every value from the array passed to it except for first value that is directly equal to the provided value', () => {
-            expect(withoutValue([], 'd')).toEqual([]);
-            expect(withoutValue(['a', 'b', 'c', 'd'], 'g')).toEqual(['a', 'b', 'c', 'd']);
-            expect(withoutValue(['a', 'b', 'c', 'd'], 'b')).toEqual(['a', 'c', 'd']);
-        });
-    });
-    describe('withoutValues()', () => {
-        it('return an array containing every value from the array passed to it except for values from a second provided array', () => {
-            expect(withoutValues(['a', 'b', 'c', 'd'], [])).toEqual(['a', 'b', 'c', 'd']);
-            expect(withoutValues([], ['g', 'c', 'b', 'e'])).toEqual([]);
-            expect(withoutValues(['a', 'b', 'c', 'd'], ['g', 'c', 'b', 5])).toEqual(['a', 'd']);
-            expect(withoutValues(['a', 'b', 'c', 'd'], ['g', 'e'])).toEqual(['a', 'b', 'c', 'd']);
-        });
-    });
-    describe('replace()', () => {
-        it('return an array where the value at the provided index has been replaced with the new value', () => {
-            expect(insert([], 8, 'f')).toEqual(['f']);
-            expect(replace(['a', 'b', 'c', 'd'], -1, 'f')).toEqual(['a', 'b', 'c', 'd']);
-            expect(replace(['a', 'b', 'c', 'd'], 8, 'f')).toEqual(['a', 'b', 'c', 'd', 'f']);
-            expect(replace(['a', 'b', 'c', 'd'], 2, 'f')).toEqual(['a', 'b', 'f', 'd']);
-        });
-    });
-    describe('insert()', () => {
-        it('return an array where the provided value has been inserted at the provided index', () => {
-            expect(insert([], 8, 'f')).toEqual(['f']);
-            expect(insert(['a', 'b', 'c', 'd'], -1, 'f')).toEqual(['f', 'a', 'b', 'c', 'd']);
-            expect(insert(['a', 'b', 'c', 'd'], 2, 'f')).toEqual(['a', 'b', 'f', 'c', 'd']);
-            expect(insert(['a', 'b', 'c', 'd'], 8, 'f')).toEqual(['a', 'b', 'c', 'd', 'f']);
-        });
-    });
-    describe('insertAll()', () => {
-        it('return an array where the provided array of values has been inserted at the provided index', () => {
-            expect(insertAll([], 8, ['f', 'g', 'h'])).toEqual(['f', 'g', 'h']);
-            expect(insertAll(['a', 'b', 'c', 'd'], -1, ['f', 'g', 'h'])).toEqual(['f', 'g', 'h', 'a', 'b', 'c', 'd']);
-            expect(insertAll(['a', 'b', 'c', 'd'], 2, ['f', 'g', 'h'])).toEqual(['a', 'b', 'f', 'g', 'h', 'c', 'd']);
-            expect(insertAll(['a', 'b', 'c', 'd'], 8, ['f', 'g', 'h'])).toEqual(['a', 'b', 'c', 'd', 'f', 'g', 'h']);
-        });
-    });
-    describe('append()', () => {
-        it('return an array with the provided value appended, does not add if already exists', () => {
-            expect(append([], 'f')).toEqual(['f']);
-            expect(append(['a', 'b', 'c', 'd'], 'f')).toEqual(['a', 'b', 'c', 'd', 'f']);
-            expect(append(['a', 'b', 'c'], 'c')).toEqual(['a', 'b', 'c']);
-        });
-    });
-    describe('toggleMembership()', () => {
-        it('return an array with the provided value included or excluded, the opposite of the current state', () => {
-            expect(toggleMembership(['a', 'b', 'c'], 'f')).toEqual(['a', 'b', 'c', 'f']);
-            expect(toggleMembership(['a', 'b', 'c', 'f'], 'f')).toEqual(['a', 'b', 'c']);
-        });
-    });
-    describe('head()', () => {
-        it('return the item at the head of the array and an array containing the remaining elements as a tuple pair', () => {
-            expect(head(['a', 'b', 'c', 'd'])).toEqual(['a', ['b', 'c', 'd']]);
-            expect(head(['a'])).toEqual(['a', []]);
-            expect(head([])).toEqual([undefined, []]);
-        });
-    });
-    describe('tail()', () => {
-        it('return the item at the end of the array and an array containing the remaining elements as a tuple pair', () => {
-            expect(tail(['a', 'b', 'c', 'd'])).toEqual([['a', 'b', 'c'], 'd']);
-            expect(tail(['a'])).toEqual([[], 'a']);
-            expect(tail([])).toEqual([[], undefined]);
-        });
-    });
-    describe('filterOutNullish()', () => {
-        it('filters nullish values', () => {
-            expect(filterOutNullish([undefined, 1, null])).toEqual([1]);
-            expect(filterOutNullish([undefined, null])).toEqual([]);
-            expect(filterOutNullish([1])).toEqual([1]);
-        });
-    });
-    describe('isNullish()', () => {
-        it('works', () => {
-            expect(isNullish(null)).toBe(true);
-            expect(isNullish(undefined)).toBe(true);
-            expect(isNullish(0)).toBe(false);
-        });
-    });
-    describe('isNotNullish()', () => {
-        it('works', () => {
-            expect(isNotNullish(null)).toBe(false);
-            expect(isNotNullish(undefined)).toBe(false);
-            expect(isNotNullish(0)).toBe(true);
-        });
-    });
-    describe('toArray()', () => {
-        it('works with arrays', () => {
-            const value = [1];
-            expect(toArray(value)).toEqual([1]);
-        });
-        it('works with non-arrays', () => {
-            const value = 1;
-            expect(toArray(value)).toEqual([1]);
-        });
-    });
-    describe('reorder()', () => {
-        it('should do nothing if from index goes outside array', () => {
-            const array = [1, 2, 3];
-            expect(reorder(array, -1, 1)).toEqual(array);
-            expect(reorder(array, 3, 1)).toEqual(array);
-        });
-        it('should set as first item if toIndex is zero or lower than 0', () => {
-            const array = [1, 2, 3];
-            expect(reorder(array, 2, -1)).toEqual([3, 1, 2]);
-            expect(reorder(array, 2, 0)).toEqual([3, 1, 2]);
-        });
-        it('should set as last item if toIndex is the last or greater than last', () => {
-            const array = [1, 2, 3];
-            expect(reorder(array, 0, 2)).toEqual([2, 3, 1]);
-            expect(reorder(array, 0, 3)).toEqual([2, 3, 1]);
-        });
-        it('should reorder moving forward or backward', () => {
-            const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-            expect(reorder(array, 1, 2)).toEqual([1, 3, 2, 4, 5, 6, 7, 8, 9, 10]);
-            expect(reorder(array, 2, 3)).toEqual([1, 2, 4, 3, 5, 6, 7, 8, 9, 10]);
-            expect(reorder(array, 2, 8)).toEqual([1, 2, 4, 5, 6, 7, 8, 9, 3, 10]);
-            expect(reorder(array, 8, 1)).toEqual([1, 9, 2, 3, 4, 5, 6, 7, 8, 10]);
-            expect(reorder(array, 7, 2)).toEqual([1, 2, 8, 3, 4, 5, 6, 7, 9, 10]);
-        });
-    });
-    describe('separate()', () => {
-        it('separates items that pass and fail a predicate', () => {
-            const [passes, fails] = separate([20, 1, -3, 15, 8, 23, 40, 3], (x) => x > 10);
-            expect(passes).toEqual([20, 15, 23, 40]);
-            expect(fails).toEqual([1, -3, 8, 3]);
-        });
-    });
-    describe('createEntries()', () => {
-        it('creates entries by extracting a key for each item in an array', () => {
-            const entries = createEntries([{ index: 1 }, { index: 3 }, { index: 5 }], ({ index }) => String(index));
-            expect(entries).toEqual([
-                ['1', { index: 1 }],
-                ['3', { index: 3 }],
-                ['5', { index: 5 }],
-            ]);
-        });
-    });
-    describe('createMap()', () => {
-        it('creates object by extracting a key for each item in an array', () => {
-            const obj = createMap([{ index: 1 }, { index: 3 }, { index: 5 }], ({ index }) => String(index));
-            expect(obj).toEqual({
-                1: { index: 1 },
-                3: { index: 3 },
-                5: { index: 5 },
-            });
-        });
-    });
-    describe('findUnion()', () => {
-        it('finds the overlap between two lists', () => {
-            const { lhsOnly, rhsOnly, union } = findUnion([20, 1, -3, 15], [1, 8, 23, -3, 40, 3]);
-            expect(lhsOnly).toEqual([20, 15]);
-            expect(rhsOnly).toEqual([8, 23, 40, 3]);
-            expect(union).toEqual([1, -3]);
-        });
-    });
-    describe('diff()', () => {
-        it('finds items that only occur in one of two lists', () => {
-            expect(diff([20, 1, -3, 15], [1, 8, 23, -3, 40, 3])).toEqual([20, 15, 8, 23, 40, 3]);
-        });
-    });
-    describe('hasIdenticalMembers()', () => {
-        it('returns false if lists have different lengths', () => {
-            expect(hasIdenticalMembers([1, 2, 3], [3, 3, 2, 2, 1])).toBe(false);
-        });
-        it('returns false if either list has a unique member', () => {
-            expect(hasIdenticalMembers([1, 2, 3], [2, 3])).toBe(false);
-        });
-        it('returns true if both lists contain the same members', () => {
-            expect(hasIdenticalMembers([1, 2, 3], [3, 1, 2])).toBe(true);
-        });
-        it('returns true if both lists are empty', () => {
-            expect(hasIdenticalMembers([], [])).toBe(true);
-        });
-    });
-    describe('filterAndGetLastRemovedValue()', () => {
-        it('returns the last item which did not pass the filter predicate', () => {
-            expect(filterAndGetLastRemovedValue([1, 2, 3], () => true)).toEqual([[1, 2, 3], null]);
-            expect(filterAndGetLastRemovedValue([], () => false)).toEqual([[], null]);
-            expect(filterAndGetLastRemovedValue([1, 2, 3], (x) => x !== 2)).toEqual([[1, 3], 2]);
-        });
-    });
-    describe('mergeByIdentifier()', () => {
-        it('test', () => {
-            const array1 = [
-                {
-                    key: 1,
-                    value: [1, 2],
-                },
-            ];
-            const array2 = [
-                {
-                    key: 1,
-                    value: [3],
-                },
-                {
-                    key: 2,
-                    value: [4, 5],
-                },
-            ];
-            const result = mergeByIdentifier(array1, array2, (x) => x.key.toString(), (a, b) => ({
-                ...a,
-                value: [...a.value, ...b.value],
-            }));
-            expect(result).toEqual([
-                {
-                    key: 1,
-                    value: [1, 2, 3],
-                },
-                {
-                    key: 2,
-                    value: [4, 5],
-                },
-            ]);
-        });
-    });
-});

package/build/esm/utils/email.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=email.test.d.ts.map

package/build/esm/utils/email.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"email.test.d.ts","sourceRoot":"","sources":["../../../src/utils/email.test.ts"],"names":[],"mappings":""}

package/build/esm/utils/email.test.js

@@ -1,20 +0,0 @@
-import { getEmailDomain, isValidEmail } from './emails.js';
-describe('Utils | email', () => {
-    describe('isValid()', () => {
-        it('should be valid', () => {
-            const validEmails = ['joe.doe@test.com', 'john.-last@sub.domain.com', 'test+@voiceflow.com', 't-est+34@voice-flow.com'];
-            validEmails.forEach((email) => expect(isValidEmail(email)).toBe(true));
-        });
-        it('should be invalid', () => {
-            const invalidEmails = ['joe@.com', 'joe@', '@voiceflow.com', '', 'voiceflow.com'];
-            invalidEmails.forEach((email) => expect(isValidEmail(email)).toBe(false));
-        });
-    });
-    describe('getEmailDomain()', () => {
-        it('works', () => {
-            expect(getEmailDomain('test@voiceflow.com')).toBe('voiceflow.com');
-            expect(getEmailDomain('')).toBe('');
-            expect(getEmailDomain('totally@invalid@voiceflow.com')).toBe('voiceflow.com');
-        });
-    });
-});

package/build/esm/utils/functional.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=functional.test.d.ts.map

package/build/esm/utils/functional.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"functional.test.d.ts","sourceRoot":"","sources":["../../../src/utils/functional.test.ts"],"names":[],"mappings":""}