@connecttomahdi/rxdb 17.0.0-beta.17 → 17.1.0

package/src/plugins/local-documents/local-documents.ts

@@ -60,24 +60,33 @@ export async function insertLocal<DocData extends Record<string, any> = any, Rea
  * save the local-document-data
  * overwrites existing if exists
  */
-export function upsertLocal<DocData extends Record<string, any> = any, Reactivity = unknown>(
+export async function upsertLocal<DocData extends Record<string, any> = any, Reactivity = unknown>(
     this: any,
     id: string,
     data: DocData
 ): Promise<RxLocalDocument<DocData, any, Reactivity>> {
-    return this.getLocal(id)
-        .then((existing: RxDocument) => {
-            if (!existing) {
-                // create new one
-                const docPromise = this.insertLocal(id, data);
-                return docPromise;
-            } else {
-                // update existing
-                return existing.incrementalModify(() => {
-                    return data;
-                });
+    const existing = await this.getLocal(id);
+    if (!existing) {
+        // create new one
+        return this.insertLocal(id, data);
+    } else if (existing.deleted) {
+        // document was deleted before, un-delete it via the write queue
+        const state = await getLocalDocStateByParent(this);
+        const writeResult = await state.incrementalWriteQueue.addWrite(
+            (existing as any)._data,
+            (docData: any) => {
+                docData.data = data;
+                docData._deleted = false;
+                return docData;
             }
+        );
+        return state.docCache.getCachedRxDocument(writeResult) as any;
+    } else {
+        // update existing
+        return existing.incrementalModify(() => {
+            return data;
         });
+    }
 }
 
 export async function getLocal<DocData = any, Reactivity = unknown>(this: any, id: string): Promise<RxLocalDocument<DocData, any, Reactivity> | null> {

package/src/plugins/migration-schema/migration-helpers.ts

@@ -70,6 +70,8 @@ export function migrateDocumentData(
     const attachmentsBefore = flatClone(docData._attachments);
     const mutateableDocData = clone(docData);
     const meta = mutateableDocData._meta;
+    const deleted = mutateableDocData._deleted;
+    delete mutateableDocData._deleted;
     delete mutateableDocData._meta;
     mutateableDocData._attachments = attachmentsBefore;
 
@@ -95,6 +97,7 @@ export function migrateDocumentData(
         if (meta) {
             doc._meta = meta;
         }
+        doc._deleted = deleted;
         return doc;
     });
 }

package/src/plugins/migration-schema/rx-migration-state.ts

@@ -329,7 +329,7 @@ export class RxMigrationState {
                 for (const oneHandler of useHandlers) {
                     status = oneHandler(status);
                 }
-                status.count.percent = Math.round((status.count.handled / status.count.total) * 100);
+                status.count.percent = status.count.total === 0 ? 100 : Math.round((status.count.handled / status.count.total) * 100);
 
                 if (
                     newDoc && previous &&

package/src/plugins/pipeline/rx-pipeline.ts

@@ -172,6 +172,8 @@ export class RxPipeline<RxDocType> {
                     done = true;
                 }
             }
+        }).catch(err => {
+            this.error = err;
         });
     }
 
@@ -205,11 +207,14 @@ export class RxPipeline<RxDocType> {
      * Remove the pipeline and all metadata which it has stored
      */
     async remove() {
+        await this.close();
         const insternalStore = this.destination.database.internalStore;
         const checkpointDoc = await getCheckpointDoc(this);
         if (checkpointDoc) {
             const newDoc: RxDocumentData<InternalStoreDocType> = clone(checkpointDoc);
             newDoc._deleted = true;
+            newDoc._meta.lwt = now();
+            newDoc._rev = createRevision(this.destination.database.token, checkpointDoc);
             const writeResult = await insternalStore.bulkWrite([{
                 previous: checkpointDoc,
                 document: newDoc,
@@ -218,7 +223,6 @@ export class RxPipeline<RxDocType> {
                 throw writeResult.error;
             }
         }
-        return this.close();
     }
 }
 

package/src/plugins/query-builder/mquery/nosql-query-builder.ts

@@ -92,7 +92,10 @@ export class NoSqlQueryBuilderClass<DocType> {
     equals(val: any): NoSqlQueryBuilder<DocType> {
         this._ensurePath('equals');
         const path = this._path;
-        (this._conditions as any)[path] = val;
+        const conds = (this._conditions as any)[path] !== null && typeof (this._conditions as any)[path] === 'object' ?
+            (this._conditions as any)[path] :
+            ((this._conditions as any)[path] = {});
+        conds.$eq = val;
         return this as any;
     }
 
@@ -103,7 +106,10 @@ export class NoSqlQueryBuilderClass<DocType> {
     eq(val: any): NoSqlQueryBuilder<DocType> {
         this._ensurePath('eq');
         const path = this._path;
-        (this._conditions as any)[path] = val;
+        const conds = (this._conditions as any)[path] !== null && typeof (this._conditions as any)[path] === 'object' ?
+            (this._conditions as any)[path] :
+            ((this._conditions as any)[path] = {});
+        conds.$eq = val;
         return this as any;
     }
 

package/src/plugins/replication/index.ts

@@ -237,7 +237,7 @@ export class RxReplicationState<RxDocType, CheckpointType> {
             waitBeforePersist: this.push ? this.push.waitBeforePersist : undefined,
             replicationHandler: {
                 masterChangeStream$: this.remoteEvents$.asObservable().pipe(
-                    filter((_v: RxReplicationPullStreamItem<RxDocType, CheckpointType>) => !!this.pull),
+                    filter((_v: RxReplicationPullStreamItem<RxDocType, CheckpointType>) => !!this.pull || _v === 'RESYNC'),
                     mergeMap(async (ev: RxReplicationPullStreamItem<RxDocType, CheckpointType>) => {
                         if (ev === 'RESYNC') {
                             return ev;
@@ -548,6 +548,20 @@ export class RxReplicationState<RxDocType, CheckpointType> {
         this.subjects.received.complete();
         this.subjects.sent.complete();
 
+        /**
+         * Remove from the REPLICATION_STATE_BY_COLLECTION registry
+         * so that the cleanup plugin does not try to access a stopped
+         * replication's meta instance, and to prevent memory leaks
+         * from accumulating canceled replication state objects.
+         */
+        const states = REPLICATION_STATE_BY_COLLECTION.get(this.collection as any);
+        if (states) {
+            const idx = states.indexOf(this);
+            if (idx !== -1) {
+                states.splice(idx, 1);
+            }
+        }
+
         return Promise.all(promises);
     }
 
@@ -555,8 +569,32 @@ export class RxReplicationState<RxDocType, CheckpointType> {
         this.startQueue = this.startQueue.then(async () => {
             const metaInfo = await this.metaInfoPromise;
             await this._cancel(true);
-            await ensureNotFalsy(this.internalReplicationState).checkpointQueue
-                .then(() => ensureNotFalsy(this.metaInstance).remove());
+
+            /**
+             * If the replication was never started (e.g. autoStart: false
+             * and start() was never called), we still have to
+             * create the meta storage instance and then remove its data.
+             * This is required so that old meta data from a previous
+             * replication with the same identifier is properly deleted.
+             */
+            if (!this.metaInstance) {
+                const database = this.collection.database;
+                this.metaInstance = await database.storage.createStorageInstance<RxStorageReplicationMeta<RxDocType, CheckpointType>>({
+                    databaseName: database.name,
+                    collectionName: metaInfo.collectionName,
+                    databaseInstanceToken: database.token,
+                    multiInstance: database.multiInstance,
+                    options: {},
+                    schema: metaInfo.schema,
+                    password: database.password,
+                    devMode: overwritable.isDevMode()
+                });
+            }
+
+            if (this.internalReplicationState) {
+                await this.internalReplicationState.checkpointQueue;
+            }
+            await ensureNotFalsy(this.metaInstance).remove();
             await removeConnectedStorageFromCollection(
                 this.collection,
                 metaInfo.collectionName,

package/src/plugins/replication-google-drive/document-handling.ts

@@ -29,7 +29,7 @@ export async function getDocumentFiles(
     const params = new URLSearchParams({
         q,
         pageSize: MAX_DRIVE_PAGE_SIZE + '',
-        fields: "nextPageToken, files(id,name,mimeType,parents,modifiedTime,size)",
+        fields: "nextPageToken, files(id,name,mimeType,parents,modifiedTime,size,etag)",
         // Shared drives support (safe to include always)
         includeItemsFromAllDrives: "true",
         supportsAllDrives: "true",
@@ -109,7 +109,7 @@ export async function updateDocumentFiles<DocType>(
     googleDriveOptions: GoogleDriveOptionsWithDefaults,
     primaryPath: keyof DocType,
     docs: DocType[],
-    fileIdByDocId: Record<string, string>,
+    fileMetaByDocId: Record<string, { fileId: string; etag: string }>,
     concurrency = 5
 ) {
     const queue = docs.slice(0);
@@ -119,22 +119,34 @@ export async function updateDocumentFiles<DocType>(
         while (queue.length) {
             const doc = queue.shift()!;
             const docId = (doc as any)[primaryPath] as string;
-            const fileId = ensureNotFalsy(fileIdByDocId[docId]);
+            const meta = ensureNotFalsy(fileMetaByDocId[docId]);
+            const fileId = meta.fileId;
+            const etag = meta.etag;
 
             const url =
                 googleDriveOptions.apiEndpoint +
-                `/upload/drive/v3/files/${encodeURIComponent(fileId)}` +
+                `/upload/drive/v2/files/${encodeURIComponent(fileId)}` +
                 `?uploadType=media&supportsAllDrives=true&fields=id`;
 
             const res = await fetch(url, {
-                method: "PATCH",
+                method: "PUT",
                 headers: {
                     Authorization: `Bearer ${googleDriveOptions.authToken}`,
                     "Content-Type": "application/json; charset=UTF-8",
+                    "If-Match": etag,
                 },
                 body: JSON.stringify(doc),
             });
 
+            if (res.status === 412) {
+                throw newRxError('GDR20', {
+                    args: {
+                        docId,
+                        fileId
+                    }
+                });
+            }
+
             if (!res.ok) {
                 throw await newRxFetchError(res, {
                     args: {

package/src/plugins/replication-google-drive/google-drive-helper.ts

@@ -392,7 +392,7 @@ export async function insertMultipartFile<T>(
     const metadata = {
         name: filename,
         mimeType: 'application/json',
-        parents: folderId,
+        parents: [folderId],
     };
 
     const postData = createMultipartBody(

package/src/plugins/replication-google-drive/google-drive-types.ts

@@ -26,6 +26,7 @@ export interface DriveFileMetadata {
     modifiedTime?: string;
     size?: string; // Drive returns size as string
     fileSize?: string; // v2
+    etag?: string;
 }
 
 export type GoogleDriveOptions = {

package/src/plugins/replication-google-drive/signaling.ts

@@ -144,7 +144,9 @@ export class SignalingState {
 
     async pingPeers(message: SIGNAL) {
         Array.from(this.peerBySenderId.values()).forEach(peer => {
-            peer.send(message);
+            if (peer.connected) {
+                peer.send(message);
+            }
         });
     }
 
@@ -195,6 +197,7 @@ export class SignalingState {
                     });
                     peer.on('connect', () => {
                         this._resync$.next();
+                        peer.send('RESYNC');
                     });
                     peer.on('data', (dataBuffer: any) => {
                         const data = dataBuffer + '';

package/src/plugins/replication-google-drive/upstream.ts

@@ -213,18 +213,21 @@ export async function processWalFile<RxDocType>(
         init,
         docIds as string[]
     );
-    const fileIdByDocId: Record<string, string> = {};
+    const fileMetaByDocId: Record<string, { fileId: string; etag: string }> = {};
 
     docFiles.files.forEach(file => {
         const docId = file.name.split('.')[0] as any;
-        fileIdByDocId[docId] = file.id;
+        fileMetaByDocId[docId] = {
+            fileId: file.id,
+            etag: ensureNotFalsy(file.etag),
+        };
     });
 
     const toInsert: WithDeletedAndAttachments<RxDocType>[] = [];
     const toUpdate: WithDeletedAndAttachments<RxDocType>[] = [];
     content.rows.filter(row => {
         const docId = row.newDocumentState[primaryPath];
-        const fileExists = fileIdByDocId[docId as any];
+        const fileExists = fileMetaByDocId[docId as any];
         if (!fileExists) {
             toInsert.push(row.newDocumentState);
         } else {
@@ -243,7 +246,7 @@ export async function processWalFile<RxDocType>(
             googleDriveOptions,
             primaryPath,
             toUpdate,
-            fileIdByDocId,
+            fileMetaByDocId,
         )
     ]);
 

package/src/plugins/replication-microsoft-onedrive/signaling.ts

@@ -152,7 +152,9 @@ export class SignalingState {
 
     async pingPeers(message: SIGNAL) {
         Array.from(this.peerBySenderId.values()).forEach(peer => {
-            peer.send(message);
+            if (peer.connected) {
+                peer.send(message);
+            }
         });
     }
 
@@ -203,6 +205,7 @@ export class SignalingState {
                     });
                     peer.on('connect', () => {
                         this._resync$.next();
+                        peer.send('RESYNC');
                     });
                     peer.on('data', (dataBuffer: any) => {
                         const data = dataBuffer + '';

package/src/plugins/state/rx-state.ts

@@ -27,7 +27,8 @@ import {
     clone,
     randomToken,
     deepEqual,
-    getFromMapOrCreate
+    getFromMapOrCreate,
+    promiseWait
 } from '../utils/index.ts';
 import {
     RX_STATE_COLLECTION_SCHEMA,
@@ -148,7 +149,7 @@ export class RxStateBase<T, Reactivity = unknown> {
                     const ops: RxStateOperation[] = [];
                     for (let index = 0; index < useWrites.length; index++) {
                         const writeRow = useWrites[index];
-                        const value = getProperty(newState, writeRow.path);
+                        const value = writeRow.path === '' ? newState : getProperty(newState, writeRow.path);
                         const newValue = writeRow.modifier(value);
                         /**
                          * Here we have to clone the value because
@@ -182,6 +183,12 @@ export class RxStateBase<T, Reactivity = unknown> {
                     if ((err as RxError).code !== 'CONFLICT') {
                         throw err;
                     }
+                    /**
+                     * Yield to the event loop so that cross-instance
+                     * change events can be processed and the _lastIdQuery
+                     * cache gets updated before retrying.
+                     */
+                    await promiseWait(0);
                 }
             }
         }).catch(error => {
@@ -328,7 +335,7 @@ export async function createRxState<T>(
         } else {
             for (let index = 0; index < documents.length; index++) {
                 const document = documents[index];
-                mergeOperationsIntoState(rxState._state, document.ops);
+                rxState._state = mergeOperationsIntoState(rxState._state, document.ops);
             }
         }
     }
@@ -378,9 +385,14 @@ export async function createRxState<T>(
 export function mergeOperationsIntoState<T>(
     state: T,
     operations: RxStateOperation[]
-) {
+): T {
     for (let index = 0; index < operations.length; index++) {
         const operation = operations[index];
-        setProperty(state, operation.k, clone(operation.v));
+        if (operation.k === '') {
+            state = clone(operation.v);
+        } else {
+            setProperty(state, operation.k, clone(operation.v));
+        }
     }
+    return state;
 }

package/src/plugins/storage-dexie/rx-storage-instance-dexie.ts

@@ -5,10 +5,6 @@ import {
 import {
     now,
     ensureNotFalsy,
-    defaultHashSha256,
-    RXDB_UTILS_GLOBAL,
-    PREMIUM_FLAG_HASH,
-    hasPremiumFlag
 } from '../utils/index.ts';
 import type {
     RxStorageInstance,
@@ -47,8 +43,6 @@ import { newRxError } from '../../rx-error.ts';
 
 let instanceId = now();
 
-let shownNonPremiumLog = false;
-
 
 export class RxStorageInstanceDexie<RxDocType> implements RxStorageInstance<
     RxDocType,
@@ -80,27 +74,6 @@ export class RxStorageInstanceDexie<RxDocType> implements RxStorageInstance<
     ): Promise<RxStorageBulkWriteResponse<RxDocType>> {
         ensureNotClosed(this);
 
-        if (
-            !shownNonPremiumLog &&
-            !(await hasPremiumFlag())
-        ) {
-            console.warn(
-                [
-                    '-------------- RxDB Open Core RxStorage -------------------------------',
-                    'You are using the free Dexie.js based RxStorage implementation from RxDB https://rxdb.info/rx-storage-dexie.html?console=dexie ',
-                    'While this is a great option, we want to let you know that there are faster storage solutions available in our premium plugins.',
-                    'For professional users and production environments, we highly recommend considering these premium options to enhance performance and reliability.',
-                    ' https://rxdb.info/premium/?console=dexie ',
-                    'If you already purchased premium access you can disable this log by calling the setPremiumFlag() function from rxdb-premium/plugins/shared.',
-                    '---------------------------------------------------------------------'
-                ].join('\n')
-            );
-            shownNonPremiumLog = true;
-        } else {
-            shownNonPremiumLog = true;
-        }
-
-
         /**
          * Check some assumptions to ensure RxDB
          * does not call the storage with an invalid write.

package/src/plugins/storage-memory/binary-search-bounds.ts

@@ -1,22 +1,21 @@
 /**
- * Everything in this file was copied and adapted from
- * @link https://github.com/mikolalysenko/binary-search-bounds
- *
- * We should use the original npm module instead when this bug is fixed:
- * @link https://github.com/mikolalysenko/binary-search-bounds/pull/14
+ * Optimized binary search functions for the memory storage.
+ * Based on https://github.com/mikolalysenko/binary-search-bounds
+ * but with performance improvements:
+ * - Removed unnecessary undefined checks for comparator
+ * - Inlined the norm() wrapper to avoid extra function calls
+ * - Added string-specialized variants to avoid temporary array allocations
  */
 
-
-
 type Compare<T> = ((a: T, b: T) => number | null | undefined);
 
-function ge<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {
+export function boundGE<T>(a: T[], y: T, c: Compare<T>, lo?: any, hi?: any): number {
+    let l: number = lo === undefined ? 0 : lo | 0;
+    let h: number = hi === undefined ? a.length - 1 : hi | 0;
     let i: number = h + 1;
     while (l <= h) {
         const m = (l + h) >>> 1;
-        const x: any = a[m];
-        const p: any = (c !== undefined) ? c(x, y) : (x - (y as any));
-        if (p >= 0) {
+        if ((c(a[m], y) as number) >= 0) {
             i = m; h = m - 1;
         } else {
             l = m + 1;
@@ -25,13 +24,13 @@ function ge<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {
     return i;
 }
 
-function gt<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {
+export function boundGT<T>(a: T[], y: T, c: Compare<T>, lo?: any, hi?: any): number {
+    let l: number = lo === undefined ? 0 : lo | 0;
+    let h: number = hi === undefined ? a.length - 1 : hi | 0;
     let i = h + 1;
     while (l <= h) {
         const m = (l + h) >>> 1;
-        const x = a[m];
-        const p: any = (c !== undefined) ? c(x, y) : ((x as any) - (y as any));
-        if (p > 0) {
+        if ((c(a[m], y) as number) > 0) {
             i = m; h = m - 1;
         } else {
             l = m + 1;
@@ -40,12 +39,13 @@ function gt<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {
     return i;
 }
 
-function lt<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {
+export function boundLT<T>(a: T[], y: T, c: Compare<T>, lo?: any, hi?: any): number {
+    let l: number = lo === undefined ? 0 : lo | 0;
+    let h: number = hi === undefined ? a.length - 1 : hi | 0;
     let i = l - 1;
     while (l <= h) {
-        const m = (l + h) >>> 1, x = a[m];
-        const p: any = (c !== undefined) ? c(x, y) : ((x as any) - (y as any));
-        if (p < 0) {
+        const m = (l + h) >>> 1;
+        if ((c(a[m], y) as number) < 0) {
             i = m; l = m + 1;
         } else {
             h = m - 1;
@@ -54,12 +54,13 @@ function lt<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {
     return i;
 }
 
-function le<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {
+export function boundLE<T>(a: T[], y: T, c: Compare<T>, lo?: any, hi?: any): number {
+    let l: number = lo === undefined ? 0 : lo | 0;
+    let h: number = hi === undefined ? a.length - 1 : hi | 0;
     let i = l - 1;
     while (l <= h) {
-        const m = (l + h) >>> 1, x = a[m];
-        const p: any = (c !== undefined) ? c(x, y) : ((x as any) - (y as any));
-        if (p <= 0) {
+        const m = (l + h) >>> 1;
+        if ((c(a[m], y) as number) <= 0) {
             i = m; l = m + 1;
         } else {
             h = m - 1;
@@ -68,10 +69,12 @@ function le<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {
     return i;
 }
 
-function eq<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {
+export function boundEQ<T>(a: T[], y: T, c: Compare<T>, lo?: any, hi?: any): number {
+    let l: number = lo === undefined ? 0 : lo | 0;
+    let h: number = hi === undefined ? a.length - 1 : hi | 0;
     while (l <= h) {
-        const m = (l + h) >>> 1, x = a[m];
-        const p: any = (c !== undefined) ? c(x, y) : ((x as any) - (y as any));
+        const m = (l + h) >>> 1;
+        const p = c(a[m], y) as number;
         if (p === 0) {
             return m;
         }
@@ -84,23 +87,85 @@ function eq<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {
     return -1;
 }
 
-function norm<T>(a: T[], y: T, c: Compare<T>, l: any, h: any, f: any) {
-    return f(a, y, c, (l === undefined) ? 0 : l | 0, (h === undefined) ? a.length - 1 : h | 0);
+/**
+ * Specialized binary search functions that compare DocWithIndexString
+ * entries directly against an index string, avoiding temporary array allocations.
+ * Used in query() and count() hot paths.
+ */
+export function boundGEByIndexString<T extends [string, ...any[]]>(a: T[], indexString: string): number {
+    let l = 0;
+    let h = a.length - 1;
+    let i: number = h + 1;
+    while (l <= h) {
+        const m = (l + h) >>> 1;
+        if (a[m][0] >= indexString) {
+            i = m; h = m - 1;
+        } else {
+            l = m + 1;
+        }
+    }
+    return i;
 }
 
-
-export function boundGE<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any) {
-    return norm(a, y, c, l, h, ge);
-}
-export function boundGT<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any) {
-    return norm(a, y, c, l, h, gt);
+export function boundGTByIndexString<T extends [string, ...any[]]>(a: T[], indexString: string): number {
+    let l = 0;
+    let h = a.length - 1;
+    let i = h + 1;
+    while (l <= h) {
+        const m = (l + h) >>> 1;
+        if (a[m][0] > indexString) {
+            i = m; h = m - 1;
+        } else {
+            l = m + 1;
+        }
+    }
+    return i;
 }
-export function boundLT<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any) {
-    return norm(a, y, c, l, h, lt);
+
+export function boundEQByIndexString<T extends [string, ...any[]]>(a: T[], indexString: string): number {
+    let l = 0;
+    let h = a.length - 1;
+    while (l <= h) {
+        const m = (l + h) >>> 1;
+        const s = a[m][0];
+        if (s === indexString) {
+            return m;
+        }
+        if (s < indexString) {
+            l = m + 1;
+        } else {
+            h = m - 1;
+        }
+    }
+    return -1;
 }
-export function boundLE<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any) {
-    return norm(a, y, c, l, h, le);
+
+export function boundLTByIndexString<T extends [string, ...any[]]>(a: T[], indexString: string): number {
+    let l = 0;
+    let h = a.length - 1;
+    let i = l - 1;
+    while (l <= h) {
+        const m = (l + h) >>> 1;
+        if (a[m][0] < indexString) {
+            i = m; l = m + 1;
+        } else {
+            h = m - 1;
+        }
+    }
+    return i;
 }
-export function boundEQ<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any) {
-    return norm(a, y, c, l, h, eq);
+
+export function boundLEByIndexString<T extends [string, ...any[]]>(a: T[], indexString: string): number {
+    let l = 0;
+    let h = a.length - 1;
+    let i = l - 1;
+    while (l <= h) {
+        const m = (l + h) >>> 1;
+        if (a[m][0] <= indexString) {
+            i = m; l = m + 1;
+        } else {
+            h = m - 1;
+        }
+    }
+    return i;
 }