@voiceflow/common 8.2.8 → 8.3.1

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":""}

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

@@ -1,137 +0,0 @@
-import { chain, chainAsync, chainVoid, chainVoidAsync, compose, identity, isFunction, noop, stringify, withEffect } from './functional.js';
-import { delay } from './promise.js';
-describe('Utils | functional', () => {
-    describe('isFunction()', () => {
-        it('checks if the provided argument is a function', () => {
-            expect(isFunction(null)).toBe(false);
-            expect(isFunction({})).toBe(false);
-            expect(isFunction(() => null)).toBe(true);
-        });
-    });
-    describe('compose()', () => {
-        it('composes from right-to-left', () => {
-            const add = (x) => x + 1;
-            const div = (x) => x / 3;
-            const mult = (x) => x * 2;
-            expect(compose(mult, div, add)(5)).toBe(4);
-            expect(compose(add, mult, div)(9)).toBe(7);
-            expect(compose(mult, add)(6)).toBe(14);
-            expect(compose(mult)(6)).toBe(12);
-        });
-    });
-    describe('noop()', () => {
-        it('does nothing', () => {
-            expect(noop()).toBeUndefined();
-        });
-    });
-    describe('identity()', () => {
-        it('returns the input', () => {
-            const input = () => null;
-            expect(identity(input)).toEqual(input);
-        });
-    });
-    describe('stringify()', () => {
-        it('returns the input as a string', () => {
-            expect(stringify('foo')).toBe('foo');
-            expect(stringify(123)).toBe('123');
-        });
-    });
-    describe('chain()', () => {
-        it('chains multiple function calls from left to right', () => {
-            let result = 5;
-            const outerArgs = ['a', false, -3];
-            const add = (...args) => {
-                expect(args).toEqual(outerArgs);
-                result += 1;
-            };
-            const div = (...args) => {
-                expect(args).toEqual(outerArgs);
-                result /= 3;
-            };
-            const mult = (...args) => {
-                expect(args).toEqual(outerArgs);
-                result *= 2;
-            };
-            chain(add, div, mult)(...outerArgs);
-            expect(result).toBe(4);
-            result = 5;
-            chain(add, mult)(...outerArgs);
-            expect(result).toBe(12);
-            result = 5;
-            chain(add)(...outerArgs);
-            expect(result).toBe(6);
-        });
-    });
-    describe('chainVoid()', () => {
-        it('chains multiple function calls from left to right', () => {
-            let result = 5;
-            const add = () => {
-                result += 1;
-            };
-            const div = () => {
-                result /= 3;
-            };
-            const mult = () => {
-                result *= 2;
-            };
-            chainVoid(add, div, mult)();
-            expect(result).toBe(4);
-        });
-    });
-    describe('chainAsync()', () => {
-        it('chains multiple async function calls in sequence from left to right', async () => {
-            let result = 5;
-            const outerArgs = ['a', false, -3];
-            const add = async (...args) => {
-                expect(args).toEqual(outerArgs);
-                await delay(1);
-                result += 1;
-            };
-            const div = async (...args) => {
-                expect(args).toEqual(outerArgs);
-                await delay(1);
-                result /= 3;
-            };
-            const mult = async (...args) => {
-                expect(args).toEqual(outerArgs);
-                await delay(1);
-                result *= 2;
-            };
-            await chainAsync(add, div, mult)(...outerArgs);
-            expect(result).toBe(4);
-            result = 5;
-            await chainAsync(add, mult)(...outerArgs);
-            expect(result).toBe(12);
-            result = 5;
-            await chainAsync(add)(...outerArgs);
-            expect(result).toBe(6);
-        });
-    });
-    describe('chainVoidAsync()', () => {
-        it('chains multiple async function calls in sequence from left to right', async () => {
-            let result = 5;
-            const add = async () => {
-                await delay(1);
-                result += 1;
-            };
-            const div = async () => {
-                await delay(1);
-                result /= 3;
-            };
-            const mult = async () => {
-                await delay(1);
-                result *= 2;
-            };
-            await chainVoidAsync(add, div, mult)();
-            expect(result).toBe(4);
-        });
-    });
-    describe('withEffect()', () => {
-        it('apply effect to a value and return the value', () => {
-            const input = 4;
-            const spy = jest.fn();
-            withEffect(spy)(input);
-            expect(spy).toHaveBeenCalledWith(4);
-        });
-    });
-});

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

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

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

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

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

@@ -1,64 +0,0 @@
-import { remapObjectIDs } from './id.js';
-// sample ObjectIds
-const Sample = {
-    A: 'aaaaaaaaaaaaaaaaaaaaaaaa',
-    B: 'bbbbbbbbbbbbbbbbbbbbbbbb',
-    C: 'cccccccccccccccccccccccc',
-    REAL: '61dcebb839fc80002d048dbd',
-};
-describe('Utils | id', () => {
-    describe('remapObjectIDs()', () => {
-        it('shallow nested', () => {
-            const map = { [Sample.A]: Sample.B };
-            expect(remapObjectIDs({ cool: Sample.A }, map)).toEqual({ cool: Sample.B });
-        });
-        it('converts string', () => {
-            const map = { [Sample.A]: Sample.B };
-            expect(remapObjectIDs(Sample.A, map)).toBe(Sample.B);
-        });
-        it('converts multiple', () => {
-            const map = { [Sample.A]: Sample.B, [Sample.REAL]: Sample.C };
-            expect(remapObjectIDs({ 1: Sample.A, 2: Sample.REAL }, map)).toEqual({ 1: Sample.B, 2: Sample.C });
-            expect(remapObjectIDs({ 1: { 2: { 3: Sample.A, 4: [Sample.REAL] } } }, map)).toEqual({ 1: { 2: { 3: Sample.B, 4: [Sample.C] } } });
-        });
-        it('converts multiple maps', () => {
-            const map = new Map([
-                [Sample.A, Sample.B],
-                [Sample.REAL, Sample.C],
-            ]);
-            expect(remapObjectIDs({ 1: Sample.A, 2: Sample.REAL }, map)).toEqual({ 1: Sample.B, 2: Sample.C });
-            expect(remapObjectIDs({ 1: { 2: { 3: Sample.A, 4: [Sample.REAL] } } }, map)).toEqual({ 1: { 2: { 3: Sample.B, 4: [Sample.C] } } });
-        });
-        it('converts very nested', () => {
-            const object = {
-                a: { b: { c: { d: { e: 'id1' } } } },
-                id1: {
-                    id2: {
-                        id3: {
-                            id4: ['id5'],
-                        },
-                    },
-                    b: 'id2',
-                },
-            };
-            const map = {
-                id1: 'new1',
-                id2: 'new2',
-                id3: 'new3',
-                id4: 'new4',
-                id5: 'new5',
-            };
-            expect(remapObjectIDs(object, map)).toEqual({
-                a: { b: { c: { d: { e: 'new1' } } } },
-                new1: {
-                    new2: {
-                        new3: {
-                            new4: ['new5'],
-                        },
-                    },
-                    b: 'new2',
-                },
-            });
-        });
-    });
-});

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

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

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

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

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

@@ -1,75 +0,0 @@
-import * as data from './__fixtures__/name.json';
-import { injectUtteranceSpaces, utteranceEntityPermutations } from './intent.js';
-describe('utteranceEntityPermutations unit tests', () => {
-    it('works correctly', async () => {
-        const utterances = data.intents[0].inputs.map(({ text }) => text);
-        const entitiesByID = Object.fromEntries(data.slots.map((slot) => [slot.key, slot]));
-        const key = '4i3h3mmi';
-        const luisUtterances = utteranceEntityPermutations({ utterances, entitiesByID });
-        expect(luisUtterances.length).toBe(Math.min(entitiesByID[key].inputs.length, 22));
-        // Check that each slot value is within one of the utterances
-        entitiesByID[key].inputs.forEach((input, i) => {
-            if (i < 22) {
-                expect(luisUtterances.filter((utt) => utt.text?.includes(input)).length).toBeGreaterThan(0);
-            }
-        });
-        // Check that a fake name is not within the utterances
-        expect(luisUtterances.filter((utt) => utt.text?.includes('fakeName')).length).toBe(0);
-    });
-    it('with replacer', async () => {
-        const utterances = [
-            '{{[slot].4i3h3mmi}} testing {{[slotmans].4i3h3mmi}} {{[third].third}}',
-            'close {{[slotmans].4i3h3mmi}}{{[third].third}} together',
-        ];
-        const entitiesByID = {
-            '4i3h3mmi': { name: 'slotmans', inputs: ['value1', 'value_super_long', 'v3'] },
-            third: { name: 'third', inputs: ['thirdvalue'] },
-        };
-        // this generates the rasa format
-        const replacer = (sample, entityID) => {
-            return `[${sample}](${entitiesByID[entityID].name})`;
-        };
-        const replacedUtterances = utteranceEntityPermutations({ utterances, entitiesByID, replacer });
-        expect(replacedUtterances.map(({ text }) => text)).toEqual([
-            '[value1](slotmans) testing [value_super_long](slotmans) [thirdvalue](third)',
-            'close [v3](slotmans)[thirdvalue](third) together',
-        ]);
-    });
-});
-describe('injectUtteranceSpaces', () => {
-    const testUtterances = [
-        '',
-        '{{[slot].4i3h3mmi}}',
-        '{{[slot].4i3h3mmi}}{{[slotmans].4i3h3mmi}}',
-        'hello there {{[slotmans].4i3h3mma}}',
-        'hello there {{[slotmans].4i3h3mmb}} words',
-        'hello there{{[slotmans].4i3h3mmc}} words',
-        'hello there {{[slotmans].4i3h3mmd}}words',
-        'hello there{{[slotmans].4i3h3mme}}words',
-        'hello there {{[slotmans].4i3h3mmf}}, words',
-        'hello there:{{[slotmans].4i3h3mmg}},words',
-        '{{[slot].4i3h3mmi}}and{{[third].third}}',
-        '{{[slot].4i3h3mmi}}{{[slotmans].4i3h3mmi}}{{[third].third}}',
-        'multiple{{[slotmans].4i3h3mmi}}slots{{[slotmans].4i3h3mmi}}words{{[slotmans].4i3h3mmi}}',
-    ];
-    const expectedResults = [
-        '',
-        '{{[slot].4i3h3mmi}}',
-        '{{[slot].4i3h3mmi}} {{[slotmans].4i3h3mmi}}',
-        'hello there {{[slotmans].4i3h3mma}}',
-        'hello there {{[slotmans].4i3h3mmb}} words',
-        'hello there {{[slotmans].4i3h3mmc}} words',
-        'hello there {{[slotmans].4i3h3mmd}} words',
-        'hello there {{[slotmans].4i3h3mme}} words',
-        'hello there {{[slotmans].4i3h3mmf}}, words',
-        'hello there:{{[slotmans].4i3h3mmg}},words',
-        '{{[slot].4i3h3mmi}} and {{[third].third}}',
-        '{{[slot].4i3h3mmi}} {{[slotmans].4i3h3mmi}} {{[third].third}}',
-        'multiple {{[slotmans].4i3h3mmi}} slots {{[slotmans].4i3h3mmi}} words {{[slotmans].4i3h3mmi}}',
-    ];
-    it('add spaces around slots if needed', () => {
-        for (let i = 0; i < testUtterances.length; ++i) {
-            expect(injectUtteranceSpaces(testUtterances[i])).toBe(expectedResults[i]);
-        }
-    });
-});

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

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

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

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

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

@@ -1,20 +0,0 @@
-import { getOrDefault } from './map.js';
-describe('Utils | map', () => {
-    describe('getOrDefault', () => {
-        it('returns the value at the given key if it exists in the map', () => {
-            const map = new Map([['key', 'value']]);
-            const value = getOrDefault(map, 'key', 'other');
-            expect(value).toBe('value');
-        });
-        it('inserts and returns the default value if key does not exist in the map', () => {
-            const map = new Map();
-            const value = getOrDefault(map, 'key', 'other');
-            expect(value).toBe('other');
-        });
-        it('inserts and returns the result of the default value function if key does not exist in the map', () => {
-            const map = new Map();
-            const value = getOrDefault(map, 'key', () => 'other');
-            expect(value).toBe('other');
-        });
-    });
-});

package/build/esm/utils/object/common.test.d.ts

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

package/build/esm/utils/object/common.test.d.ts.map

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