grammar-composer 0.4.0 → 0.6.0

package/src/tests/test-grammars/RegExpGrammar.ts

@@ -5,7 +5,14 @@ export class RegExpGrammar {
 	//////////////////////////////////////////////////////////////////////////////////////////////
 	// High-level productions
 	//////////////////////////////////////////////////////////////////////////////////////////////
-	root = () => this.sequenceOrDisjunction
+	root = () => this.disjunctionOrSequence
+
+	disjunctionOrSequence = () => [
+		G.anyOf(
+			this.disjunction,
+			this.sequence,
+		)
+	]
 
 	disjunction = () => [
 		this.sequence,
@@ -20,11 +27,27 @@ export class RegExpGrammar {
 		G.zeroOrMore(this.sequenceElement)
 	)
 
-	sequenceOrDisjunction = [
+	sequenceElement = () => G.anyOf(
+		this.anchor,
+		this.lookaround,
+		this.quantifiedExpression,
+		this.quantifiableExpression,
+	)
+
+	//////////////////////////////////////////////////////////////////////////////////////////////
+	// Quantifiable expression
+	//////////////////////////////////////////////////////////////////////////////////////////////
+	quantifiableExpression = () => G.cached(
 		G.anyOf(
-			this.disjunction,
-			this.sequence,
+			this.group,
+			this.backReference,
+			this.singleCharExpression
 		)
+	)
+
+	quantifiedExpression = () => [
+		this.quantifiableExpression,
+		this.quantifier,
 	]
 
 	//////////////////////////////////////////////////////////////////////////////////////////////
@@ -86,7 +109,7 @@ export class RegExpGrammar {
 	//////////////////////////////////////////////////////////////////////////////////////////////
 	uncapturedGroup = () => [
 		'(?:',
-		this.sequenceOrDisjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
@@ -96,17 +119,17 @@ export class RegExpGrammar {
 			R.oneOrMore(identifierChar))
 		),
 		'>',
-		this.sequenceOrDisjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
 	unnamedCaptureGroup = () => [
 		'(',
-		this.sequenceOrDisjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
-	group = G.anyOf(
+	group = () => G.anyOf(
 		this.uncapturedGroup,
 		this.namedCaptureGroup,
 		this.unnamedCaptureGroup,
@@ -132,7 +155,7 @@ export class RegExpGrammar {
 			'>',
 		])
 
-	backReference = G.anyOf(
+	backReference = () => G.anyOf(
 		this.unnamedBackreference,
 		this.namedBackreference,
 	)
@@ -142,29 +165,29 @@ export class RegExpGrammar {
 	//////////////////////////////////////////////////////////////////////////////////////////////
 	positiveLookahead = () => [
 		'(?=',
-		this.sequenceOrDisjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
 	negativeLookahead = () => [
 		'(?!',
-		this.sequenceOrDisjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
 	positiveLookbehind = () => [
 		'(?<=',
-		this.sequenceOrDisjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
 	negativeLookbehind = () => [
 		'(?<!',
-		this.sequenceOrDisjunction,
+		this.disjunctionOrSequence,
 		')',
 	]
 
-	lookaround = G.anyOf(
+	lookaround = () => G.anyOf(
 		this.positiveLookahead,
 		this.negativeLookahead,
 		this.positiveLookbehind,
@@ -244,17 +267,17 @@ export class RegExpGrammar {
 		'}',
 	])
 
-	unicodeProperty = () => G.pattern([
+	unicodeProperty = () => [
 		'\\p',
 		this.unicodePropertyBodyPattern,
-	])
+	]
 
-	notUnicodeProperty = () => G.pattern([
+	notUnicodeProperty = () => [
 		'\\P',
 		this.unicodePropertyBodyPattern,
-	])
+	]
 
-	unicodePropertyBodyPattern: R.Pattern = [
+	unicodePropertyBodyPattern = () => G.pattern([
 		'{',
 		R.captureAs('property',
 			R.oneOrMore(R.anyOf(letter, digit, '_', '-'))
@@ -266,7 +289,7 @@ export class RegExpGrammar {
 			),
 		]),
 		'}',
-	]
+	])
 
 	charClass = () => [
 		'[',
@@ -283,7 +306,7 @@ export class RegExpGrammar {
 		']',
 	]
 
-	charcodeOrEscapedChar = G.anyOf(
+	charcodeOrEscapedChar = () => G.anyOf(
 		this.codepoint,
 		this.hexCharcode,
 		this.controlCharcode,
@@ -297,7 +320,7 @@ export class RegExpGrammar {
 		)
 	)
 
-	charRangeElement = G.anyOf(
+	charRangeElement = () => G.anyOf(
 		this.charcodeOrEscapedChar,
 		this.charClassLiteral,
 	)
@@ -321,7 +344,8 @@ export class RegExpGrammar {
 
 	anyCharWildcard = () => '.'
 
-	anchor = G.anyOf(this.inputStartAnchor, this.inputEndAnchor)
+	anchor = () =>
+		G.anyOf(this.inputStartAnchor, this.inputEndAnchor)
 
 	escapedCharacterClass = () => G.pattern(R.anyOf(
 		R.captureAs('whitespace', escapedChars.whitespace),
@@ -339,29 +363,6 @@ export class RegExpGrammar {
 		R.captureAs('verticalTab', escapedChars.verticalTab),
 		R.captureAs('backwardSlash', escapedChars.backwardSlash),
 	))
-
-	//////////////////////////////////////////////////////////////////////////////////////////////
-	// Sequence elements (positioned here due to TypeScript class member ordering requirements)
-	//////////////////////////////////////////////////////////////////////////////////////////////
-	quantifiableExpression = G.cached(
-		G.anyOf(
-			this.group,
-			this.backReference,
-			this.singleCharExpression
-		)
-	)
-
-	quantifiedExpression = () => [
-		this.quantifiableExpression,
-		this.quantifier,
-	]
-
-	sequenceElement = G.anyOf(
-		this.anchor,
-		this.lookaround,
-		this.quantifiedExpression,
-		this.quantifiableExpression,
-	)
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
@@ -391,3 +392,21 @@ const escapedChars = {
 	verticalTab: '\\v',
 	backwardSlash: '\\\\'
 }
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// Wrapped nonterminal names
+//////////////////////////////////////////////////////////////////////////////////////////////
+export const regExpGrammarUnwrappedNonterminalNames: G.GrammarNonterminalNames<RegExpGrammar> = [
+	'disjunctionOrSequence',
+	'group',
+	'backReference',
+	'lookaround',
+	'unicodeProperty',
+	'notUnicodeProperty',
+	'unicodePropertyBodyPattern',
+	'charcodeOrEscapedChar',
+	'charRangeElement',
+	'anchor',
+	'quantifiableExpression',
+	'sequenceElement',
+]

package/src/tests/test-grammars/XmlGrammar.ts

@@ -14,7 +14,7 @@ export class XmlGrammar {
 		)
 	]
 
-	textFragment = G.pattern([
+	textFragment = () => G.pattern([
 		R.oneOrMore(R.notAnyOfChars('<'))
 	])
 
@@ -26,7 +26,7 @@ export class XmlGrammar {
 		this.tagEnd
 	]
 
-	openingTagStart = G.pattern([
+	openingTagStart = () => G.pattern([
 		'<',
 
 		R.possibly('?'),
@@ -38,7 +38,7 @@ export class XmlGrammar {
 		R.zeroOrMore(R.whitespace),
 	])
 
-	tagEnd = G.pattern([
+	tagEnd = () => G.pattern([
 		R.zeroOrMore(R.whitespace),
 
 		R.possibly(R.anyOf('/', '?')),
@@ -46,7 +46,7 @@ export class XmlGrammar {
 		'>'
 	])
 
-	attribute = G.pattern([
+	attribute = () => G.pattern([
 		R.zeroOrMore(R.whitespace),
 
 		R.captureAs('attributeName',
@@ -66,7 +66,7 @@ export class XmlGrammar {
 		])
 	])
 
-	closingTag = G.pattern([
+	closingTag = () => G.pattern([
 		'</',
 
 		R.zeroOrMore(R.whitespace),
@@ -88,7 +88,7 @@ export class XmlGrammar {
 		this.tagEnd
 	]
 
-	declarationTagOpening = G.pattern([
+	declarationTagOpening = () => G.pattern([
 		'<!',
 
 		R.captureAs('tagName',
@@ -98,7 +98,7 @@ export class XmlGrammar {
 		R.zeroOrMore(R.whitespace)
 	])
 
-	declarationTagAttribute = G.pattern([
+	declarationTagAttribute = () => G.pattern([
 		R.zeroOrMore(R.whitespace),
 
 		R.anyOf(
@@ -112,7 +112,7 @@ export class XmlGrammar {
 		R.zeroOrMore(R.whitespace),
 	])
 
-	comment = G.pattern([
+	comment = () => G.pattern([
 		'<!--',
 
 		R.captureAs('commentBody',
@@ -123,6 +123,9 @@ export class XmlGrammar {
 	])
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////////
+// Helper regular expressions
+//////////////////////////////////////////////////////////////////////////////////////////////
 const quotedString = R.anyOf(
 	[
 		'"',
@@ -139,3 +142,12 @@ const quotedString = R.anyOf(
 		"'"
 	],
 )
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// Wrapped nonterminal names
+//////////////////////////////////////////////////////////////////////////////////////////////
+export const xmlGrammarUnwrappedNonterminalNames: G.GrammarNonterminalNames<XmlGrammar> = [
+	'openingTagStart',
+	'tagEnd',
+	'declarationTagOpening',
+]

package/src/utilities/LineAndColumn.ts

@@ -0,0 +1,61 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Position helpers
+/////////////////////////////////////////////////////////////////////////////////////////////////
+export function getLineAndColumn(input: string, offset: number): { line: number, column: number } {
+	let line = 1
+	let lineStartOffset = 0
+
+	for (let i = 0; i < offset && i < input.length; i++) {
+		if (input[i] === '\n') {
+			line += 1
+			lineStartOffset = i + 1
+		}
+	}
+
+	return {
+		line,
+		column: offset - lineStartOffset + 1
+	}
+}
+
+const tabSize = 4
+
+export function expandTabs(text: string): string {
+	let result = ''
+	let column = 0
+
+	for (const char of text) {
+		if (char === '\t') {
+			const spacesToNextTabStop = tabSize - (column % tabSize)
+
+			result += ' '.repeat(spacesToNextTabStop)
+			column += spacesToNextTabStop
+		} else {
+			result += char
+			column += 1
+		}
+	}
+
+	return result
+}
+
+export function buildCaretSpacing(text: string, caretColumn: number): string {
+	let spacing = ''
+	let column = 0
+
+	for (let i = 0; i < caretColumn - 1 && i < text.length; i++) {
+		const char = text[i]
+
+		if (char === '\t') {
+			const spacesToNextTabStop = tabSize - (column % tabSize)
+
+			spacing += ' '.repeat(spacesToNextTabStop)
+			column += spacesToNextTabStop
+		} else {
+			spacing += ' '
+			column += 1
+		}
+	}
+
+	return spacing
+}

package/src/utilities/Timer.ts

@@ -1,95 +1,97 @@
-import { roundToDigits } from './Utilities.js'
+export class Timer {
+	private readonly logger: TimerLogger
 
-declare const chrome: any
-declare const process: any
+	private startTime = 0
 
-export class Timer {
-	startTime = 0
+	constructor(logger?: TimerLogger) {
+		if (logger) {
+			this.logger = logger
+		} else {
+			this.logger = console.log
+		}
 
-	constructor() {
 		this.restart()
 	}
 
-	restart() {
+	// Resets the timer to the current time.
+	restart(): void {
 		this.startTime = Timer.currentTime
 	}
 
+	// Elapsed time in milliseconds (monotonic where supported).
 	get elapsedTime(): number {
-		// Elapsed time (milliseconds)
 		return Timer.currentTime - this.startTime
 	}
 
+	// Elapsed time in seconds.
 	get elapsedTimeSeconds(): number {
-		// Elapsed time (seconds)
 		return this.elapsedTime / 1000
 	}
 
+	// Returns elapsed ms and restarts the timer.
 	getElapsedTimeAndRestart(): number {
-		const elapsedTime = this.elapsedTime
+		const elapsed = this.elapsedTime
 		this.restart()
 
-		return elapsedTime
+		return elapsed
 	}
 
+	// Logs elapsed time (in ms) and restarts the timer.
 	logAndRestart(title: string, timePrecision = 3): number {
-		const elapsedTime = this.elapsedTime
-
-		//
-		const message = `${title}: ${roundToDigits(elapsedTime, timePrecision)}ms`
-
-		console.log(message)
-		//
-
+		const elapsedMs = this.elapsedTime
+		this.logger(`${title}: ${roundToDigits(elapsedMs, timePrecision)}ms`)
 		this.restart()
 
-		return elapsedTime
+		return elapsedMs
 	}
 
+	// Current high-resolution timestamp in milliseconds since Unix epoch.
 	static get currentTime(): number {
-		if (!this.timestampFunc) {
-			this.createGlobalTimestampFunction()
-		}
-
 		return this.timestampFunc()
 	}
 
+	// Current timestamp in microseconds (integer).
 	static get microsecondTimestamp(): number {
 		return Math.floor(Timer.currentTime * 1000)
 	}
 
-	private static createGlobalTimestampFunction() {
-		if (typeof process === 'object' && typeof process.hrtime === 'function') {
-			let baseTimestamp = 0
+	// Private Static Clock Setup
+	private static timestampFunc: () => number = Timer.createTimestampFunction()
 
-			this.timestampFunc = () => {
-				const nodeTimeStamp = process.hrtime()
-				const millisecondTime = (nodeTimeStamp[0] * 1000) + (nodeTimeStamp[1] / 1000000)
+	private static createTimestampFunction(): () => number {
+		const g = globalThis as any
 
-				return baseTimestamp + millisecondTime
-			}
+		// 1. Modern standard: performance.now() (Browsers & Node 16+)
+		if (typeof g.performance === 'object' && typeof g.performance.now === 'function') {
+			const timeOrigin =
+				g.performance.timeOrigin ?? (Date.now() - g.performance.now())
 
-			baseTimestamp = Date.now() - this.timestampFunc()
+			return () => timeOrigin + g.performance.now()
 		}
-		else if (typeof chrome === 'object' && chrome.Interval) {
-			const baseTimestamp = Date.now()
 
-			const chromeIntervalObject = new chrome.Interval()
-			chromeIntervalObject.start()
+		// 2. Node.js high resolution timer (BigInt variant, Node 10.4+)
+		if (typeof g.process === 'object' && typeof g.process.hrtime === 'function') {
+			const startNs = g.process.hrtime.bigint()
 
-			this.timestampFunc = () => baseTimestamp + chromeIntervalObject.microseconds() / 1000
-		}
-		else if (typeof performance === 'object' && performance.now) {
-			const baseTimestamp = Date.now() - performance.now()
+			const epochBaseMs = Date.now() - (Number(startNs) / 1e6)
 
-			this.timestampFunc = () => baseTimestamp + performance.now()
-		}
-		else if (Date.now) {
-			this.timestampFunc = () => Date.now()
+			return () =>
+				epochBaseMs + Number(g.process.hrtime.bigint()) / 1e6
 		}
-		else {
-			this.timestampFunc = () => (new Date()).getTime()
+
+		// 3. Last-resort fallback (non-monotonic)
+		if (typeof Date.now === 'function') {
+			return () => Date.now()
 		}
+
+		return () => new Date().getTime()
 	}
+}
+
+export function roundToDigits(value: number, digits: number): number {
+	const factor = 10 ** digits
 
-	private static timestampFunc: () => number
+	return Math.round(value * factor) / factor
 }
+
+type TimerLogger = (msg: string) => void