@verdant-web/common 1.15.2 → 1.15.3-next.0

package/dist/esm/indexes.js

@@ -1,131 +1,131 @@
-import { isIndexed, } from './index.js';
-// unlikely to be used unicode character
-export const COMPOUND_INDEX_SEPARATOR = '\uFFFFFE';
-// 1 lower than separator
-export const COMPOUND_INDEX_LOWER_BOUND_SEPARATOR = '\u0000';
-// 1 higher than separator
-export const COMPOUND_INDEX_UPPER_BOUND_SEPARATOR = '\uFFFFFF';
-export function createCompoundIndexValue(...fields) {
-    const value = expandArrayIndex(fields);
-    if (value.length === 1) {
-        return value[0];
-    }
-    return value;
-}
-export function createUpperBoundIndexValue(...fields) {
-    return (fields.join(COMPOUND_INDEX_SEPARATOR) +
-        `${COMPOUND_INDEX_UPPER_BOUND_SEPARATOR}`);
-}
-export function createLowerBoundIndexValue(...fields) {
-    return (fields.join(COMPOUND_INDEX_SEPARATOR) +
-        `${COMPOUND_INDEX_SEPARATOR}${COMPOUND_INDEX_LOWER_BOUND_SEPARATOR}`);
-}
-/**
- * Whenever an array value is included in a compound index, we have to expand
- * the value to include all permutations of values in the array.
- * For example if we had an index id + tags on a document
- *
- * {
- *   id: '1',
- *   tags: ['a', 'b']
- * }
- *
- * we want to create an index:
- *
- * id_tags: ['1#a', '1#b']
- *
- * If multiple arrays are indexed we have to exponentially expand...
- *
- * id_tags_tags2: ['1#a#a', '1#a#b', '1#b#a', '1#b#b']
- *
- * To generalize this we construct a 2-level array of strings.
- * Iterating over indexed values, we expand each item into N items if
- * the current value is an array.
- *
- * Then we combine all nested arrays into compound index values.
- * This will produce an array of 1 element if none of the indexed values
- * were arrays. The caller should unwrap that.
- *
- * This function also deduplicates values.
- */
-function expandArrayIndex(fields) {
-    let value = [[]];
-    for (const field of fields) {
-        if (Array.isArray(field)) {
-            const newValue = [];
-            for (const previousValue of value) {
-                for (const fieldValue of field) {
-                    newValue.push(previousValue.concat(fieldValue));
-                }
-            }
-            value = newValue;
-        }
-        else {
-            for (const item of value) {
-                item.push(`${field}`);
-            }
-        }
-    }
-    return Array.from(new Set(value.map((item) => {
-        return item.join(COMPOUND_INDEX_SEPARATOR);
-    })));
-}
-export function isDirectSynthetic(index) {
-    return !!index.field;
-}
-export function computeSynthetics(schema, obj) {
-    const result = {};
-    for (const [name, property] of Object.entries(schema.indexes || {})) {
-        const index = property;
-        if (isDirectSynthetic(index)) {
-            result[name] = sanitizeIndexValue(obj[index.field]);
-        }
-        else {
-            result[name] = sanitizeIndexValue(index.compute(obj));
-        }
-    }
-    return result;
-}
-export function computeCompoundIndices(schema, doc) {
-    return Object.entries(schema.compounds || {}).reduce((acc, [indexKey, index]) => {
-        acc[indexKey] = createCompoundIndexValue(...index.of.map((key) => doc[key]));
-        return acc;
-    }, {});
-}
-function computeIndexedFields(schema, doc) {
-    return Object.entries(schema.fields).reduce((acc, [key, field]) => {
-        if (isIndexed(field)) {
-            acc[key] = sanitizeIndexValue(doc[key]);
-        }
-        return acc;
-    }, {});
-}
-export function getIndexValues(schema, doc) {
-    return Object.assign(Object.assign(Object.assign(Object.assign({ [schema.primaryKey]: doc[schema.primaryKey] }, computeIndexedFields(schema, doc)), computeSynthetics(schema, doc)), computeCompoundIndices(schema, doc)), { '@@@snapshot': doc });
-}
-export function assignIndexValues(schema, doc) {
-    Object.assign(doc, computeSynthetics(schema, doc));
-    Object.assign(doc, computeCompoundIndices(schema, doc));
-    return doc;
-}
-export const NULL_INDEX_VALUE = 'null';
-export function sanitizeIndexValue(value) {
-    if (value === null) {
-        return NULL_INDEX_VALUE;
-    }
-    if (typeof value === 'string' || typeof value === 'number') {
-        return value;
-    }
-    if (typeof value === 'boolean' || value === null) {
-        return `${value}`;
-    }
-    if (value === undefined) {
-        // this shouldn't happen ,but for resiliency...
-        return 'undefined';
-    }
-    if (Array.isArray(value)) {
-        return value.map(sanitizeIndexValue);
-    }
-    throw new Error(`Unsupported index value: ${value}`);
-}
+import { isIndexed, } from './index.js';
+// unlikely to be used unicode character
+export const COMPOUND_INDEX_SEPARATOR = '\uFFFFFE';
+// 1 lower than separator
+export const COMPOUND_INDEX_LOWER_BOUND_SEPARATOR = '\u0000';
+// 1 higher than separator
+export const COMPOUND_INDEX_UPPER_BOUND_SEPARATOR = '\uFFFFFF';
+export function createCompoundIndexValue(...fields) {
+    const value = expandArrayIndex(fields);
+    if (value.length === 1) {
+        return value[0];
+    }
+    return value;
+}
+export function createUpperBoundIndexValue(...fields) {
+    return (fields.join(COMPOUND_INDEX_SEPARATOR) +
+        `${COMPOUND_INDEX_UPPER_BOUND_SEPARATOR}`);
+}
+export function createLowerBoundIndexValue(...fields) {
+    return (fields.join(COMPOUND_INDEX_SEPARATOR) +
+        `${COMPOUND_INDEX_SEPARATOR}${COMPOUND_INDEX_LOWER_BOUND_SEPARATOR}`);
+}
+/**
+ * Whenever an array value is included in a compound index, we have to expand
+ * the value to include all permutations of values in the array.
+ * For example if we had an index id + tags on a document
+ *
+ * {
+ *   id: '1',
+ *   tags: ['a', 'b']
+ * }
+ *
+ * we want to create an index:
+ *
+ * id_tags: ['1#a', '1#b']
+ *
+ * If multiple arrays are indexed we have to exponentially expand...
+ *
+ * id_tags_tags2: ['1#a#a', '1#a#b', '1#b#a', '1#b#b']
+ *
+ * To generalize this we construct a 2-level array of strings.
+ * Iterating over indexed values, we expand each item into N items if
+ * the current value is an array.
+ *
+ * Then we combine all nested arrays into compound index values.
+ * This will produce an array of 1 element if none of the indexed values
+ * were arrays. The caller should unwrap that.
+ *
+ * This function also deduplicates values.
+ */
+function expandArrayIndex(fields) {
+    let value = [[]];
+    for (const field of fields) {
+        if (Array.isArray(field)) {
+            const newValue = [];
+            for (const previousValue of value) {
+                for (const fieldValue of field) {
+                    newValue.push(previousValue.concat(fieldValue));
+                }
+            }
+            value = newValue;
+        }
+        else {
+            for (const item of value) {
+                item.push(`${field}`);
+            }
+        }
+    }
+    return Array.from(new Set(value.map((item) => {
+        return item.join(COMPOUND_INDEX_SEPARATOR);
+    })));
+}
+export function isDirectSynthetic(index) {
+    return !!index.field;
+}
+export function computeSynthetics(schema, obj) {
+    const result = {};
+    for (const [name, property] of Object.entries(schema.indexes || {})) {
+        const index = property;
+        if (isDirectSynthetic(index)) {
+            result[name] = sanitizeIndexValue(obj[index.field]);
+        }
+        else {
+            result[name] = sanitizeIndexValue(index.compute(obj));
+        }
+    }
+    return result;
+}
+export function computeCompoundIndices(schema, doc) {
+    return Object.entries(schema.compounds || {}).reduce((acc, [indexKey, index]) => {
+        acc[indexKey] = createCompoundIndexValue(...index.of.map((key) => doc[key]));
+        return acc;
+    }, {});
+}
+function computeIndexedFields(schema, doc) {
+    return Object.entries(schema.fields).reduce((acc, [key, field]) => {
+        if (isIndexed(field)) {
+            acc[key] = sanitizeIndexValue(doc[key]);
+        }
+        return acc;
+    }, {});
+}
+export function getIndexValues(schema, doc) {
+    return Object.assign(Object.assign(Object.assign(Object.assign({ [schema.primaryKey]: doc[schema.primaryKey] }, computeIndexedFields(schema, doc)), computeSynthetics(schema, doc)), computeCompoundIndices(schema, doc)), { '@@@snapshot': doc });
+}
+export function assignIndexValues(schema, doc) {
+    Object.assign(doc, computeSynthetics(schema, doc));
+    Object.assign(doc, computeCompoundIndices(schema, doc));
+    return doc;
+}
+export const NULL_INDEX_VALUE = 'null';
+export function sanitizeIndexValue(value) {
+    if (value === null) {
+        return NULL_INDEX_VALUE;
+    }
+    if (typeof value === 'string' || typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'boolean' || value === null) {
+        return `${value}`;
+    }
+    if (value === undefined) {
+        // this shouldn't happen ,but for resiliency...
+        return 'undefined';
+    }
+    if (Array.isArray(value)) {
+        return value.map(sanitizeIndexValue);
+    }
+    throw new Error(`Unsupported index value: ${value}`);
+}
 //# sourceMappingURL=indexes.js.map

package/dist/esm/indexes.test.d.ts

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

package/dist/esm/indexes.test.js

@@ -1,126 +1,126 @@
-import { describe, expect, it } from 'vitest';
-import { COMPOUND_INDEX_LOWER_BOUND_SEPARATOR, COMPOUND_INDEX_SEPARATOR, COMPOUND_INDEX_UPPER_BOUND_SEPARATOR, createCompoundIndexValue, createLowerBoundIndexValue, createUpperBoundIndexValue, } from './indexes.js';
-describe('compound indexes', () => {
-    it('can be created from two string values', () => {
-        expect(createCompoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b`);
-    });
-    it('can be created from two number values', () => {
-        expect(createCompoundIndexValue(1, 2)).toEqual(`1${COMPOUND_INDEX_SEPARATOR}2`);
-    });
-    it('can be created from an array and string value', () => {
-        expect(createCompoundIndexValue(['a', 'b'], 'c')).toEqual([
-            `a${COMPOUND_INDEX_SEPARATOR}c`,
-            `b${COMPOUND_INDEX_SEPARATOR}c`,
-        ]);
-    });
-    it('can be created from a string and array of numbers', () => {
-        expect(createCompoundIndexValue('a', [1, 2])).toEqual([
-            `a${COMPOUND_INDEX_SEPARATOR}1`,
-            `a${COMPOUND_INDEX_SEPARATOR}2`,
-        ]);
-    });
-    it('can be created from an array of strings and an array of booleans', () => {
-        expect(createCompoundIndexValue(['a', 'b'], [true, false])).toEqual([
-            `a${COMPOUND_INDEX_SEPARATOR}true`,
-            `a${COMPOUND_INDEX_SEPARATOR}false`,
-            `b${COMPOUND_INDEX_SEPARATOR}true`,
-            `b${COMPOUND_INDEX_SEPARATOR}false`,
-        ]);
-    });
-    it('remove duplicate array compound index values', () => {
-        expect(createCompoundIndexValue(['a', 'b', 'b'], [true, false, true])).toEqual([
-            `a${COMPOUND_INDEX_SEPARATOR}true`,
-            `a${COMPOUND_INDEX_SEPARATOR}false`,
-            `b${COMPOUND_INDEX_SEPARATOR}true`,
-            `b${COMPOUND_INDEX_SEPARATOR}false`,
-        ]);
-    });
-    it('creates lower bound value for multi-value indexes', () => {
-        expect(createLowerBoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b${COMPOUND_INDEX_SEPARATOR}${COMPOUND_INDEX_LOWER_BOUND_SEPARATOR}`);
-    });
-    it('creates upper bound value for multi-value indexes', () => {
-        expect(createUpperBoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b${COMPOUND_INDEX_UPPER_BOUND_SEPARATOR}`);
-    }),
-        it('will always be grouped by the first item', () => {
-            expect([
-                createCompoundIndexValue('aaaaaa', 'b'),
-                createCompoundIndexValue('aaaaaa', 'c'),
-                createCompoundIndexValue('aaaaaa', 'd'),
-                createCompoundIndexValue('aaaaaa', 'e'),
-                // extra nefarious!
-                createCompoundIndexValue('aaaaaaa', 'no!'),
-                createCompoundIndexValue('aaaaaa ', 'no!'),
-                createCompoundIndexValue(`aaaaaa😎`, 'no!'),
-                createCompoundIndexValue(`aaaaaa😎😎`, 'no!'),
-                createCompoundIndexValue('aaa', 'no!'),
-                createCompoundIndexValue(`aaaaaaa😎no!`, 'no!'),
-            ].sort()).toEqual([
-                `aaaaaa ${COMPOUND_INDEX_SEPARATOR}no!`,
-                `aaaaaaa😎no!${COMPOUND_INDEX_SEPARATOR}no!`,
-                `aaaaaaa${COMPOUND_INDEX_SEPARATOR}no!`,
-                `aaaaaa😎😎${COMPOUND_INDEX_SEPARATOR}no!`,
-                `aaaaaa😎${COMPOUND_INDEX_SEPARATOR}no!`,
-                // this is the contiguous block of relevant values
-                `aaaaaa${COMPOUND_INDEX_SEPARATOR}b`,
-                `aaaaaa${COMPOUND_INDEX_SEPARATOR}c`,
-                `aaaaaa${COMPOUND_INDEX_SEPARATOR}d`,
-                `aaaaaa${COMPOUND_INDEX_SEPARATOR}e`,
-                // here ends the block
-                `aaa${COMPOUND_INDEX_SEPARATOR}no!`,
-            ]);
-        });
-    it('will be bounded by upper and lower bound values', () => {
-        const match = 'aaaaaa';
-        const sorted = [
-            createCompoundIndexValue(match, 'b'),
-            createCompoundIndexValue(match, 'c'),
-            createCompoundIndexValue(match, 'd'),
-            createCompoundIndexValue(match, 'e'),
-            // extra nefarious!
-            createCompoundIndexValue(`${match}a`, 'no!'),
-            createCompoundIndexValue(`${match} `, 'no!'),
-            createCompoundIndexValue(`${match}😎`, 'no!'),
-            createCompoundIndexValue(`${match}😎😎`, 'no!'),
-            createCompoundIndexValue('aaa', 'no!'),
-            createCompoundIndexValue(`${match}a😎no!`, 'no!'),
-        ].sort();
-        const boundedBlock = sorted.filter((value) => value > createLowerBoundIndexValue(match) &&
-            value < createUpperBoundIndexValue(match));
-        expect(boundedBlock).toEqual([
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}b`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}c`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}d`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}e`,
-        ]);
-    });
-    it('will be bounded by upper and lower bounds when matching multiple sections', () => {
-        const match1 = 'aaaaaa';
-        const match2 = 'bbbbbb';
-        const sorted = [
-            createCompoundIndexValue(match1, match2, 'b'),
-            createCompoundIndexValue(match1, match2, 'c'),
-            createCompoundIndexValue(match1, match2, 'd'),
-            createCompoundIndexValue(match1, match2, 'e'),
-            // extra nefarious!
-            createCompoundIndexValue(`${match1}a`, match2, 'no!'),
-            createCompoundIndexValue(`${match1} `, match2, 'no!'),
-            createCompoundIndexValue(`${match1}😎`, match2, 'no!'),
-            createCompoundIndexValue(`${match1}😎😎`, match2, 'no!'),
-            createCompoundIndexValue('aaa', match2, 'no!'),
-            createCompoundIndexValue(`${match1}a😎no!`, match2, 'no!'),
-            createCompoundIndexValue(match1, `${match2}a😎no!`, 'no!'),
-            createCompoundIndexValue(match1, `${match2} `, 'no!'),
-            createCompoundIndexValue(match1, ' ', 'no!'),
-            createCompoundIndexValue(match1, '\u00001', 'no!'),
-            createCompoundIndexValue(match1, '\uE007f', 'no!'),
-        ].sort();
-        expect(sorted.filter((value) => value > createLowerBoundIndexValue(match1, match2) &&
-            value < createUpperBoundIndexValue(match1, match2))).toEqual([
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}b`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}c`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}d`,
-            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}e`,
-        ]);
-    });
-});
+import { describe, expect, it } from 'vitest';
+import { COMPOUND_INDEX_LOWER_BOUND_SEPARATOR, COMPOUND_INDEX_SEPARATOR, COMPOUND_INDEX_UPPER_BOUND_SEPARATOR, createCompoundIndexValue, createLowerBoundIndexValue, createUpperBoundIndexValue, } from './indexes.js';
+describe('compound indexes', () => {
+    it('can be created from two string values', () => {
+        expect(createCompoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b`);
+    });
+    it('can be created from two number values', () => {
+        expect(createCompoundIndexValue(1, 2)).toEqual(`1${COMPOUND_INDEX_SEPARATOR}2`);
+    });
+    it('can be created from an array and string value', () => {
+        expect(createCompoundIndexValue(['a', 'b'], 'c')).toEqual([
+            `a${COMPOUND_INDEX_SEPARATOR}c`,
+            `b${COMPOUND_INDEX_SEPARATOR}c`,
+        ]);
+    });
+    it('can be created from a string and array of numbers', () => {
+        expect(createCompoundIndexValue('a', [1, 2])).toEqual([
+            `a${COMPOUND_INDEX_SEPARATOR}1`,
+            `a${COMPOUND_INDEX_SEPARATOR}2`,
+        ]);
+    });
+    it('can be created from an array of strings and an array of booleans', () => {
+        expect(createCompoundIndexValue(['a', 'b'], [true, false])).toEqual([
+            `a${COMPOUND_INDEX_SEPARATOR}true`,
+            `a${COMPOUND_INDEX_SEPARATOR}false`,
+            `b${COMPOUND_INDEX_SEPARATOR}true`,
+            `b${COMPOUND_INDEX_SEPARATOR}false`,
+        ]);
+    });
+    it('remove duplicate array compound index values', () => {
+        expect(createCompoundIndexValue(['a', 'b', 'b'], [true, false, true])).toEqual([
+            `a${COMPOUND_INDEX_SEPARATOR}true`,
+            `a${COMPOUND_INDEX_SEPARATOR}false`,
+            `b${COMPOUND_INDEX_SEPARATOR}true`,
+            `b${COMPOUND_INDEX_SEPARATOR}false`,
+        ]);
+    });
+    it('creates lower bound value for multi-value indexes', () => {
+        expect(createLowerBoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b${COMPOUND_INDEX_SEPARATOR}${COMPOUND_INDEX_LOWER_BOUND_SEPARATOR}`);
+    });
+    it('creates upper bound value for multi-value indexes', () => {
+        expect(createUpperBoundIndexValue('a', 'b')).toEqual(`a${COMPOUND_INDEX_SEPARATOR}b${COMPOUND_INDEX_UPPER_BOUND_SEPARATOR}`);
+    }),
+        it('will always be grouped by the first item', () => {
+            expect([
+                createCompoundIndexValue('aaaaaa', 'b'),
+                createCompoundIndexValue('aaaaaa', 'c'),
+                createCompoundIndexValue('aaaaaa', 'd'),
+                createCompoundIndexValue('aaaaaa', 'e'),
+                // extra nefarious!
+                createCompoundIndexValue('aaaaaaa', 'no!'),
+                createCompoundIndexValue('aaaaaa ', 'no!'),
+                createCompoundIndexValue(`aaaaaa😎`, 'no!'),
+                createCompoundIndexValue(`aaaaaa😎😎`, 'no!'),
+                createCompoundIndexValue('aaa', 'no!'),
+                createCompoundIndexValue(`aaaaaaa😎no!`, 'no!'),
+            ].sort()).toEqual([
+                `aaaaaa ${COMPOUND_INDEX_SEPARATOR}no!`,
+                `aaaaaaa😎no!${COMPOUND_INDEX_SEPARATOR}no!`,
+                `aaaaaaa${COMPOUND_INDEX_SEPARATOR}no!`,
+                `aaaaaa😎😎${COMPOUND_INDEX_SEPARATOR}no!`,
+                `aaaaaa😎${COMPOUND_INDEX_SEPARATOR}no!`,
+                // this is the contiguous block of relevant values
+                `aaaaaa${COMPOUND_INDEX_SEPARATOR}b`,
+                `aaaaaa${COMPOUND_INDEX_SEPARATOR}c`,
+                `aaaaaa${COMPOUND_INDEX_SEPARATOR}d`,
+                `aaaaaa${COMPOUND_INDEX_SEPARATOR}e`,
+                // here ends the block
+                `aaa${COMPOUND_INDEX_SEPARATOR}no!`,
+            ]);
+        });
+    it('will be bounded by upper and lower bound values', () => {
+        const match = 'aaaaaa';
+        const sorted = [
+            createCompoundIndexValue(match, 'b'),
+            createCompoundIndexValue(match, 'c'),
+            createCompoundIndexValue(match, 'd'),
+            createCompoundIndexValue(match, 'e'),
+            // extra nefarious!
+            createCompoundIndexValue(`${match}a`, 'no!'),
+            createCompoundIndexValue(`${match} `, 'no!'),
+            createCompoundIndexValue(`${match}😎`, 'no!'),
+            createCompoundIndexValue(`${match}😎😎`, 'no!'),
+            createCompoundIndexValue('aaa', 'no!'),
+            createCompoundIndexValue(`${match}a😎no!`, 'no!'),
+        ].sort();
+        const boundedBlock = sorted.filter((value) => value > createLowerBoundIndexValue(match) &&
+            value < createUpperBoundIndexValue(match));
+        expect(boundedBlock).toEqual([
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}b`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}c`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}d`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}e`,
+        ]);
+    });
+    it('will be bounded by upper and lower bounds when matching multiple sections', () => {
+        const match1 = 'aaaaaa';
+        const match2 = 'bbbbbb';
+        const sorted = [
+            createCompoundIndexValue(match1, match2, 'b'),
+            createCompoundIndexValue(match1, match2, 'c'),
+            createCompoundIndexValue(match1, match2, 'd'),
+            createCompoundIndexValue(match1, match2, 'e'),
+            // extra nefarious!
+            createCompoundIndexValue(`${match1}a`, match2, 'no!'),
+            createCompoundIndexValue(`${match1} `, match2, 'no!'),
+            createCompoundIndexValue(`${match1}😎`, match2, 'no!'),
+            createCompoundIndexValue(`${match1}😎😎`, match2, 'no!'),
+            createCompoundIndexValue('aaa', match2, 'no!'),
+            createCompoundIndexValue(`${match1}a😎no!`, match2, 'no!'),
+            createCompoundIndexValue(match1, `${match2}a😎no!`, 'no!'),
+            createCompoundIndexValue(match1, `${match2} `, 'no!'),
+            createCompoundIndexValue(match1, ' ', 'no!'),
+            createCompoundIndexValue(match1, '\u00001', 'no!'),
+            createCompoundIndexValue(match1, '\uE007f', 'no!'),
+        ].sort();
+        expect(sorted.filter((value) => value > createLowerBoundIndexValue(match1, match2) &&
+            value < createUpperBoundIndexValue(match1, match2))).toEqual([
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}b`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}c`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}d`,
+            `aaaaaa${COMPOUND_INDEX_SEPARATOR}bbbbbb${COMPOUND_INDEX_SEPARATOR}e`,
+        ]);
+    });
+});
 //# sourceMappingURL=indexes.test.js.map