Experimentally expose OffsetMap from matchers/normalized

Author: lionel-rowe

deno.jsonc

@@ -1,7 +1,7 @@
 {
 	"lock": false,
 	"name": "@li/irregex",
-	"version": "0.7.5",
+	"version": "0.7.6",
 	"exports": {
 		".": "./src/mod.ts",
 		"./irregex": "./src/irregex.ts",
@@ -16,6 +16,7 @@
 		"@std/assert": "jsr:@std/assert@^1.0.3",
 		"@li/irregex": "./mod.ts",
 		"@std/cli": "jsr:@std/cli@^1.0.6",
+		"@std/collections": "jsr:@std/collections@^1.1.3",
 		"@std/testing": "jsr:@std/testing@^1.0.10",
 		"string-dedent": "https://esm.sh/string-dedent@3.0.1"
 	},

src/asRegExp.test.ts

@@ -3,7 +3,7 @@ import { Irregex } from '../src/irregex.ts'
 
 class Irre extends Irregex {
 	re = /./g
-	override trackLastIndex = [this.re]
+	protected override trackLastIndex = [this.re]
 
 	protected override getMatch(str: string) {
 		return this.re.exec(str)

src/irregex.test.ts

@@ -45,7 +45,7 @@ Deno.test('throw match', () => {
 
 	class ThrowMatcher extends Irregex {
 		#re = /./g
-		override trackLastIndex = [this.#re]
+		protected override trackLastIndex = [this.#re]
 
 		protected override getMatch(str: string) {
 			if (this.lastIndex) throw new ThrowMatcherError()
@@ -151,4 +151,41 @@ Deno.test('zero-length matches', async (t) => {
 			assertEquals(matcher.lastIndex, 0)
 		})
 	})
+
+	await t.step('fromIter iterated/cursor tracking of lastIndex', () => {
+		const ir = new (class extends Irregex {
+			#re = /./g
+			protected override trackLastIndex = [this.#re]
+			protected override getMatch(str: string) {
+				return this.fromIter(str, function* () {
+					for (const x of str.matchAll(this.#re)) {
+						yield x
+					}
+				})
+			}
+		})()
+
+		const str = 'abc'
+
+		const next = () => ir.exec(str)?.[0] ?? null
+
+		assertEquals(next(), 'a')
+		assertEquals(next(), 'b')
+		assertEquals(next(), 'c')
+		assertEquals(next(), null)
+
+		assertEquals(next(), 'a')
+		assertEquals(next(), 'b')
+		assertEquals(next(), 'c')
+		assertEquals(next(), null)
+
+		ir.lastIndex = 2
+		assertEquals(next(), 'c')
+		ir.lastIndex = 1
+		assertEquals(next(), 'b')
+		ir.lastIndex = 500
+		assertEquals(next(), null)
+		ir.lastIndex = 0
+		assertEquals(next(), 'a')
+	})
 })

src/irregex.ts

@@ -1,4 +1,5 @@
 import { replaceValueToReplacer } from './replace.ts'
+import { binarySearch } from '@std/collections/unstable-binary-search'
 
 /**
  * A contract fulfilled by both `RegExp`s and `Irregex`s. The `Irregex` class implements these properties and methods of
@@ -61,19 +62,21 @@ export abstract class Irregex<T = unknown> implements IrregexCompatible {
 	 * A list of matchers that should have their `lastIndex` property kept in sync with the parent `Irregex`'s
 	 *  `lastIndex` property. Useful for keeping internally-used regexes (or other matchers) in sync.
 	 */
-	trackLastIndex?: Pick<Matcher, 'lastIndex'>[]
+	protected trackLastIndex?: { lastIndex: number }[]
 
 	exec(str: string): (RegExpExecArray & T) | null {
 		const match = this.getMatch(str)
 		this.lastIndex = match ? match.index + match[0].length : 0
 		return match
 	}
 
-	#lastCached?: {
-		input: string
+	static #MAX_CACHE_SIZE = 10
+	#lastCached = new Map<string, {
 		iterated: (RegExpExecArray & T)[]
 		iterator: Iterator<RegExpExecArray & T>
-	}
+		cursor: number
+		indices: number[]
+	}>()
 
 	/**
 	 * Convenience method for converting an iterator function to a match getter suitable for use with `getMatch`.
@@ -87,24 +90,61 @@ export abstract class Irregex<T = unknown> implements IrregexCompatible {
 		str: string,
 		getter: (this: this) => Iterable<RegExpExecArray & T>,
 	): (RegExpExecArray & T) | null {
-		if (this.#lastCached?.input !== str) {
+		let lastCached = this.#lastCached.get(str)
+
+		if (lastCached == null) {
 			const iterator = getter.call(this)[Symbol.iterator]()
 
-			this.#lastCached = {
-				input: str,
-				iterated: [],
-				iterator,
+			this.#lastCached.set(
+				str,
+				lastCached = {
+					iterated: [],
+					iterator,
+					cursor: 0,
+					indices: [],
+				},
+			)
+
+			if (this.#lastCached.size > Irregex.#MAX_CACHE_SIZE) {
+				this.#lastCached.delete(this.#lastCached.keys().next().value!)
 			}
 		}
 
-		for (const x of this.#lastCached.iterated) {
-			if (x.index >= this.lastIndex) return x
+		if (this.lastIndex === 0) lastCached.cursor = 0
+
+		// if we've already iterated past the current lastIndex, the result is already in the `iterated` array
+		if ((lastCached.iterated.at(-1)?.index ?? -1) >= this.lastIndex) {
+			// check after the cursor first (assuming usually iterated sequentially)
+			for (let i = lastCached.cursor; i < lastCached.iterated.length; ++i) {
+				const x = lastCached.iterated[i]!
+				const prev = lastCached.iterated[i - 1]
+				if (x.index >= this.lastIndex && (prev?.index ?? -1) < this.lastIndex) {
+					lastCached.cursor = i
+					return x
+				}
+			}
+
+			const { cursor } = lastCached
+			lastCached.cursor = 0
+
+			// const indices = lastCached.iterated.map(x=>x.index).slice(0, cursor)
+
+			// throw '!'
+
+			const i = binarySearch(
+				lastCached.indices.slice(0, cursor),
+				this.lastIndex,
+			)
+			return lastCached.iterated[i < 0 ? ~i : i]!
 		}
+
 		while (true) {
-			const next = this.#lastCached.iterator.next()
+			const next = lastCached.iterator.next()
 			if (next.done) return null
 			const x = next.value
-			this.#lastCached.iterated.push(x)
+
+			lastCached.cursor = lastCached.iterated.push(x) - 1
+			lastCached.indices.push(x.index)
 			if (x.index >= this.lastIndex) return x
 		}
 	}

src/matchers/normalized.test.ts

@@ -1,6 +1,6 @@
 import dedent from 'string-dedent'
 import { assertEquals } from '@std/assert'
-import { NormalizedMatcher } from './normalized.ts'
+import { NormalizedMatcher, OffsetMap } from './normalized.ts'
 
 Deno.test(NormalizedMatcher.name, async (t) => {
 	await t.step('`g` and `d` flags', () => {
@@ -187,8 +187,6 @@ Deno.test(NormalizedMatcher.name, async (t) => {
 	})
 })
 
-const OffsetMap = NormalizedMatcher['OffsetMap']
-
 Deno.test(OffsetMap.name, () => {
 	const offsetMap = new OffsetMap([[2, 3], [4, 2], [10, 5]])
 

src/matchers/normalized.ts

@@ -17,12 +17,13 @@ type OffsetMapState = Readonly<{
 	increment: number
 }>
 
-class OffsetMap {
+/** @experimental */
+export class OffsetMap {
 	#cursor = 0
 	#increment = 0
 
 	#latestIncrement = 0
-	get latestIncrement() {
+	get latestIncrement(): number {
 		return this.#latestIncrement
 	}
 
@@ -45,7 +46,7 @@ class OffsetMap {
 		this.#increment = increment
 	}
 
-	remapToOriginal(offset: number) {
+	remapToOriginal(offset: number): number {
 		this.#latestIncrement = 0
 
 		for (; this.#cursor < this.offsets.length; ++this.#cursor) {
@@ -83,7 +84,7 @@ export class NormalizedMatcher extends Irregex {
 		return this.fromIter(input, function* () {
 			let replacementIncrement = 0
 
-			let offsetMap = new NormalizedMatcher.OffsetMap([])
+			let offsetMap = new OffsetMap([])
 			let inputNormalized = input
 
 			for (const { selector, replacer } of this.#normalizers) {
@@ -114,7 +115,7 @@ export class NormalizedMatcher extends Irregex {
 					}),
 				)
 
-				offsetMap = new NormalizedMatcher.OffsetMap([
+				offsetMap = new OffsetMap([
 					...offsetMap.offsets,
 					...offsets,
 				].sort(([a], [b]) => a - b))
@@ -193,6 +194,4 @@ export class NormalizedMatcher extends Irregex {
 			}
 		})
 	}
-
-	private static OffsetMap = OffsetMap
 }

src/matchers/physicalLineBoundary.ts

@@ -3,6 +3,7 @@ import { Irregex } from '../irregex.ts'
 
 export class PhysicalLineBoundaryMatcher extends Irregex {
 	colWidth: number
+	stringWidth = unicodeWidth
 
 	constructor(colWidth: number) {
 		super()
@@ -18,9 +19,8 @@ export class PhysicalLineBoundaryMatcher extends Irregex {
 				const rest = str.slice(prevLineBreak?.index ?? 0, m.index)
 				const line = rest.slice(rest.lastIndexOf('\n') + 1)
 
-				if (unicodeWidth(line) > this.colWidth) {
-					if (prevWordBreak != null) yield prevWordBreak
-					prevLineBreak = prevWordBreak
+				if (this.stringWidth(line) > this.colWidth && prevWordBreak != null) {
+					yield prevLineBreak = prevWordBreak
 				}
 
 				prevWordBreak = m

src/matchers/word.test.ts

@@ -8,7 +8,7 @@ Deno.test(WordMatcher.name, async (t) => {
 		const replacer = '($<abbr>)'
 		const expected = '(Mon), (Tue), (Wed), (Thu), (Fri), (Sat), (Sun)'
 
-		for (let i = 0; i < 2; ++i) {
+		for (let i = 0; i < 3; ++i) {
 			assertEquals(matcher[Symbol.replace](input, replacer), expected)
 		}
 	})
@@ -17,7 +17,7 @@ Deno.test(WordMatcher.name, async (t) => {
 		const input = '此地无银三百两'
 		const expected = ['此地', '无', '银', '三百', '两']
 
-		for (let i = 0; i < 2; ++i) {
+		for (let i = 0; i < 3; ++i) {
 			assertEquals(matcher[Symbol.match](input), expected)
 		}
 	})

src/replace.ts

@@ -7,15 +7,17 @@ export type NativeReplacerFn = (substring: string, ...args: unknown[]) => string
  *
  * @example Index
  * ```ts
+ * import { assertEquals } from '@std/assert'
  * assertEquals(
- * 	'Hello world'.replace(/\w+/g, createReplacerFunction((m) => `${m.index}:${m[0]}`)),
+ * 	'Hello world'.replace(/\w+/g, convertReplacerFunction((m) => `${m.index}:${m[0]}`)),
  * 	'0:Hello 6:world',
  * )
  * ```
  * @example Named capture groups
  * ```ts
+ * import { assertEquals } from '@std/assert'
  * assertEquals(
- * 	'Hello world'.replace(/(?<initial>\w)\w+/g, createReplacerFunction((m) => m.groups!.initial)),
+ * 	'Hello world'.replace(/(?<initial>\w)\w+/g, convertReplacerFunction((m) => m.groups!.initial!)),
  * 	'H w',
  * )
  * ```