feat(parser): support \uYYYY and \xYY

Author: gruhn

src/code-point-range.ts

@@ -42,10 +42,14 @@ export function strictlyDisjoint(rangeA: CodePointRange, rangeB: CodePointRange)
   return isStrictlyBefore(rangeA, rangeB) || isStrictlyAfter(rangeA, rangeB)
 }
 
-export function singleton(char: string): CodePointRange {
-  const codePoint = char.codePointAt(0) 
-  assert(codePoint !== undefined && char.length <= 1, `Invalid character: ${char}`)
-  return { start: codePoint, end: codePoint }
+export function singleton(char: string | number): CodePointRange {
+  if (typeof char === 'number') {
+    return { start: char, end: char }
+  } else {
+    const codePoint = char.codePointAt(0) 
+    assert(codePoint !== undefined && char.length <= 1, `Invalid character: ${char}`)
+    return { start: codePoint, end: codePoint }
+  }
 }
 
 export function size(range: CodePointRange): number {

src/parser.ts

@@ -1,4 +1,4 @@
-import { identity, checkedAllCases } from './utils'
+import { identity, checkedAllCases, assert } from './utils'
 
 export type ParseResult<T> = { value: T, restInput: string }
 
@@ -144,6 +144,17 @@ export function some<T>(parser: Parser<T>): Parser<[T, ...T[]]> {
     )
 }
 
+export function count<T>(n: number, parser: Parser<T>): Parser<T[]> {
+  assert(Number.isInteger(n) && n >= 0)
+
+  if (n === 0) 
+    return pure([])
+  else // n > 0
+    return parser.andThen(first => count(n-1, parser)
+      .map(rest => [first, ...rest])
+    )
+}
+
 export function optional<T>(parser: Parser<T>): Parser<T | undefined> {
   return new Parser(input => {
     try {
@@ -179,16 +190,14 @@ export function satisfy(predicate: (char: string) => boolean): Parser<string> {
   })
 }
 
-export const digitChar: Parser<string> = satisfy(char => char.match(/^[0-9]$/) !== null)
+export const digitChar: Parser<string> = satisfy(char => /^[0-9]$/.test(char))
 
-export const anyChar: Parser<string> = satisfy(_ => true)
+export const hexChar: Parser<string> = satisfy(char => /^[0-9a-fA-F]$/.test(char))
 
-function digitsToDecimal(digits: number[]): number {
-  return digits.reduce((acc, digit) => 10*acc + digit, 0)
-}
+export const anyChar: Parser<string> = satisfy(_ => true)
 
 export const decimal: Parser<number> = some(digitChar).map(
-  digits => digitsToDecimal(digits.map(digit => parseInt(digit)))
+  digits => parseInt(digits.join(''), 10)
 )
 
 /**

src/regex-parser.ts

@@ -46,27 +46,31 @@ const unescapedCharInsideBrackets = P.satisfy(Range.mustBeEscapedOrInBrackets)
 
 export class UnsupportedSyntaxError extends Error {}
 
-const escapeSequence = P.string('\\').andThen(_ => P.anyChar).map(escapedChar => {
+const escapeSequence = P.string('\\').andThen(_ => P.anyChar).andThen(escapedChar => {
   switch (escapedChar) {
-    case 'w': return CharSet.wordChars
-    case 'W': return CharSet.nonWordChars
-    case 's': return CharSet.whiteSpaceChars
-    case 'S': return CharSet.nonWhiteSpaceChars
-    case 'd': return CharSet.digitChars
-    case 'D': return CharSet.nonDigitChars
-    case 't': return CharSet.singleton('\t') // horizontal tab
-    case 'r': return CharSet.singleton('\r') // carriage return
-    case 'n': return CharSet.singleton('\n') // line feed
-    case 'v': return CharSet.singleton('\v') // vertical tab
-    case 'f': return CharSet.singleton('\f') // form feed
-    case '0': return CharSet.singleton('\0') // NUL character
+    case 'w': return P.pure(CharSet.wordChars)
+    case 'W': return P.pure(CharSet.nonWordChars)
+    case 's': return P.pure(CharSet.whiteSpaceChars)
+    case 'S': return P.pure(CharSet.nonWhiteSpaceChars)
+    case 'd': return P.pure(CharSet.digitChars)
+    case 'D': return P.pure(CharSet.nonDigitChars)
+    case 't': return P.pure(CharSet.singleton('\t')) // horizontal tab
+    case 'r': return P.pure(CharSet.singleton('\r')) // carriage return
+    case 'n': return P.pure(CharSet.singleton('\n')) // line feed
+    case 'v': return P.pure(CharSet.singleton('\v')) // vertical tab
+    case 'f': return P.pure(CharSet.singleton('\f')) // form feed
+    case '0': return P.pure(CharSet.singleton('\0')) // NUL character
     case 'b': throw new UnsupportedSyntaxError('\b word-boundary assertion not supported')
     case 'c': throw new UnsupportedSyntaxError('\cX control characters not supported')
-    case 'x': throw new UnsupportedSyntaxError('\\x not supported')
-    case 'u': throw new UnsupportedSyntaxError('\\u not supported')
+    case 'x': return P.count(2, P.hexChar).map(chars => 
+                CharSet.fromRange(Range.singleton(parseInt(chars.join(''), 16)))
+              )
+    case 'u': return P.count(4, P.hexChar).map(chars =>
+                CharSet.fromRange(Range.singleton(parseInt(chars.join(''), 16)))
+              )
     case 'p': throw new UnsupportedSyntaxError('\\p not supported')
     case 'P': throw new UnsupportedSyntaxError('\\P not supported')
-    default: return CharSet.singleton(escapedChar) // match character literally
+    default: return P.pure(CharSet.singleton(escapedChar)) // match character literally
   }
 })