@px-petals/roku.motion-web 1.0.0 → 1.1.0

package/script/luau/lib/string/string.pattern.js

@@ -0,0 +1,505 @@
+/**
+ * Lua patterns: a port of the matcher in Lua 5.1's `lstrlib.c`, which Luau's
+ * `string.find`, `match`, `gmatch` and `gsub` use. Positions are 0-based
+ * indices into the byte string; `-1` means no match.
+ *
+ * Supported: `.`, character classes `%a %c %d %l %p %s %u %w %x` and their
+ * upper-case negations, sets `[...]` with ranges and `^`, the quantifiers
+ * `* + - ?`, anchors `^` and `$`, captures `(...)` and position captures
+ * `()`, back-references `%1`-`%9`, balanced matches `%b()` and frontiers `%f[set]`.
+ */
+
+import { fail } from '../../vm/vm.value.js'
+
+const CAP_UNFINISHED = -1
+const CAP_POSITION = -2
+const MAX_CAPTURES = 32
+const MAX_DEPTH = 200
+
+// Character classes
+// ■■■■■■■■■■■■■■■■■
+
+/** @param {number} c */
+const isAlpha = (c) => (c >= 65 && c <= 90) || (c >= 97 && c <= 122)
+/** @param {number} c */
+const isDigit = (c) => c >= 48 && c <= 57
+/** @param {number} c */
+const isLower = (c) => c >= 97 && c <= 122
+/** @param {number} c */
+const isUpper = (c) => c >= 65 && c <= 90
+/** @param {number} c */
+const isSpace = (c) => c === 32 || (c >= 9 && c <= 13)
+/** @param {number} c */
+const isCntrl = (c) => c < 32 || c === 127
+/** @param {number} c */
+const isPunct = (c) => (c >= 33 && c <= 47) || (c >= 58 && c <= 64) || (c >= 91 && c <= 96) || (c >= 123 && c <= 126)
+/** @param {number} c */
+const isXDigit = (c) => isDigit(c) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102)
+
+/**
+ * Whether char code `c` is in the class named by the letter `cl` (`a`, `D`, ...); any other letter matches itself.
+ *
+ * @param   {number} c
+ * @param   {number} cl
+ * @returns {boolean}
+ */
+function matchClass(c, cl) {
+  let res
+  switch (cl | 32) {
+    case 97: res = isAlpha(c); break
+    case 99: res = isCntrl(c); break
+    case 100: res = isDigit(c); break
+    case 108: res = isLower(c); break
+    case 112: res = isPunct(c); break
+    case 115: res = isSpace(c); break
+    case 117: res = isUpper(c); break
+    case 119: res = isAlpha(c) || isDigit(c); break
+    case 120: res = isXDigit(c); break
+    default: return cl === c
+  }
+  return isUpper(cl) ? !res : res
+}
+
+// Matcher
+// ■■■■■■■
+
+/** The state of one match attempt */
+export class MatchState {
+  /**
+   * @param {string} src
+   * @param {string} pat
+   */
+  constructor(src, pat) {
+    this.src = src
+    this.pat = pat
+    this.level = 0
+    this.depth = 0
+    /** @type {number[]} */
+    this.capInit = []
+    /** @type {number[]} */
+    this.capLen = []
+  }
+
+  reset() {
+    this.level = 0
+    this.depth = 0
+  }
+
+  /**
+   * The index just past the single-character class that starts at `p`.
+   *
+   * @param   {number} p
+   * @returns {number}
+   */
+  classEnd(p) {
+    const pat = this.pat
+    const c = pat.charCodeAt(p++)
+    if (c === 37) {
+      if (p >= pat.length) throw fail("malformed pattern (ends with '%')")
+      return p + 1
+    }
+    if (c === 91) {
+      if (pat.charCodeAt(p) === 94) p++
+      do {
+        if (p >= pat.length) throw fail("malformed pattern (missing ']')")
+        const d = pat.charCodeAt(p++)
+        if (d === 37 && p < pat.length) p++
+      } while (pat.charCodeAt(p) !== 93)
+      return p + 1
+    }
+    return p
+  }
+
+  /**
+   * @param   {number} c   char code
+   * @param   {number} p   index of the `[`
+   * @param   {number} ec  index of the closing `]`
+   * @returns {boolean}
+   */
+  matchBracketClass(c, p, ec) {
+    const pat = this.pat
+    let sig = true
+    if (pat.charCodeAt(p + 1) === 94) {
+      sig = false
+      p++
+    }
+    while (++p < ec) {
+      const pc = pat.charCodeAt(p)
+      if (pc === 37) {
+        p++
+        if (matchClass(c, pat.charCodeAt(p))) return sig
+      } else if (pat.charCodeAt(p + 1) === 45 && p + 2 < ec) {
+        p += 2
+        if (pc <= c && c <= pat.charCodeAt(p)) return sig
+      } else if (pc === c) return sig
+    }
+    return !sig
+  }
+
+  /**
+   * @param   {number} s
+   * @param   {number} p
+   * @param   {number} ep  the end of the class at p
+   * @returns {boolean}
+   */
+  singleMatch(s, p, ep) {
+    if (s >= this.src.length) return false
+    const c = this.src.charCodeAt(s)
+    const pc = this.pat.charCodeAt(p)
+    switch (pc) {
+      case 46: return true
+      case 37: return matchClass(c, this.pat.charCodeAt(p + 1))
+      case 91: return this.matchBracketClass(c, p, ep - 1)
+      default: return pc === c
+    }
+  }
+
+  /**
+   * @param   {number} s
+   * @param   {number} p  index just past `%b`
+   * @returns {number}
+   */
+  matchBalance(s, p) {
+    if (p + 1 >= this.pat.length) throw fail("missing arguments to '%b'")
+    const src = this.src
+    if (s >= src.length || src.charCodeAt(s) !== this.pat.charCodeAt(p)) return -1
+    const b = this.pat.charCodeAt(p)
+    const e = this.pat.charCodeAt(p + 1)
+    let cont = 1
+    while (++s < src.length) {
+      const c = src.charCodeAt(s)
+      if (c === e) {
+        if (--cont === 0) return s + 1
+      } else if (c === b) cont++
+    }
+    return -1
+  }
+
+  /**
+   * @param   {number} s
+   * @param   {number} p
+   * @param   {number} ep
+   * @returns {number}
+   */
+  maxExpand(s, p, ep) {
+    let i = 0
+    while (this.singleMatch(s + i, p, ep)) i++
+    while (i >= 0) {
+      const res = this.match(s + i, ep + 1)
+      if (res !== -1) return res
+      i--
+    }
+    return -1
+  }
+
+  /**
+   * @param   {number} s
+   * @param   {number} p
+   * @param   {number} ep
+   * @returns {number}
+   */
+  minExpand(s, p, ep) {
+    for (;;) {
+      const res = this.match(s, ep + 1)
+      if (res !== -1) return res
+      if (this.singleMatch(s, p, ep)) s++
+      else return -1
+    }
+  }
+
+  /**
+   * @param   {number} s
+   * @param   {number} p
+   * @param   {number} what  CAP_UNFINISHED or CAP_POSITION
+   * @returns {number}
+   */
+  startCapture(s, p, what) {
+    if (this.level >= MAX_CAPTURES) throw fail('too many captures')
+    this.capInit[this.level] = s
+    this.capLen[this.level] = what
+    this.level++
+    const res = this.match(s, p)
+    if (res === -1) this.level--
+    return res
+  }
+
+  /**
+   * @param   {number} s
+   * @param   {number} p
+   * @returns {number}
+   */
+  endCapture(s, p) {
+    let l = this.level - 1
+    while (l >= 0 && this.capLen[l] !== CAP_UNFINISHED) l--
+    if (l < 0) throw fail('invalid pattern capture')
+    this.capLen[l] = s - this.capInit[l]
+    const res = this.match(s, p)
+    if (res === -1) this.capLen[l] = CAP_UNFINISHED
+    return res
+  }
+
+  /**
+   * @param   {number} s
+   * @param   {number} digit  the char code of the digit after `%`
+   * @returns {number}
+   */
+  matchCapture(s, digit) {
+    const l = digit - 49
+    if (l < 0 || l >= this.level || this.capLen[l] === CAP_UNFINISHED) throw fail('invalid capture index %' + (l + 1))
+    const len = this.capLen[l]
+    const src = this.src
+    if (src.length - s >= len && src.substr(this.capInit[l], len) === src.substr(s, len)) return s + len
+    return -1
+  }
+
+  /**
+   * Tries to match the pattern from `p` at `s`.
+   *
+   * @param   {number} s
+   * @param   {number} p
+   * @returns {number} the index after the match, or -1
+   */
+  match(s, p) {
+    if (++this.depth > MAX_DEPTH) throw fail('pattern too complex')
+    try {
+      const pat = this.pat
+      for (;;) {
+        if (p >= pat.length) return s
+        const pc = pat.charCodeAt(p)
+        let plain = false
+        switch (pc) {
+          case 40: // (
+            if (pat.charCodeAt(p + 1) === 41) return this.startCapture(s, p + 2, CAP_POSITION)
+            return this.startCapture(s, p + 1, CAP_UNFINISHED)
+          case 41: // )
+            return this.endCapture(s, p + 1)
+          case 36: // $
+            if (p + 1 === pat.length) return s === this.src.length ? s : -1
+            plain = true
+            break
+          case 37: { // %
+            const next = pat.charCodeAt(p + 1)
+            if (next === 98) { // b
+              s = this.matchBalance(s, p + 2)
+              if (s !== -1) {
+                p += 4
+                continue
+              }
+              return -1
+            }
+            if (next === 102) { // f
+              p += 2
+              if (pat.charCodeAt(p) !== 91) throw fail("missing '[' after '%f' in pattern")
+              const ep = this.classEnd(p)
+              const prev = s === 0 ? 0 : this.src.charCodeAt(s - 1)
+              const cur = s < this.src.length ? this.src.charCodeAt(s) : 0
+              if (!this.matchBracketClass(prev, p, ep - 1) && this.matchBracketClass(cur, p, ep - 1)) {
+                p = ep
+                continue
+              }
+              return -1
+            }
+            if (next >= 48 && next <= 57) {
+              s = this.matchCapture(s, next)
+              if (s !== -1) {
+                p += 2
+                continue
+              }
+              return -1
+            }
+            plain = true
+            break
+          }
+          default:
+            plain = true
+        }
+        if (!plain) return -1
+        const ep = this.classEnd(p)
+        const epc = pat.charCodeAt(ep)
+        if (!this.singleMatch(s, p, ep)) {
+          if (epc === 42 || epc === 63 || epc === 45) { // * ? -
+            p = ep + 1
+            continue
+          }
+          return -1
+        }
+        if (epc === 63) { // ?
+          const res = this.match(s + 1, ep + 1)
+          if (res !== -1) return res
+          p = ep + 1
+          continue
+        }
+        if (epc === 43) return this.maxExpand(s + 1, p, ep) // +
+        if (epc === 42) return this.maxExpand(s, p, ep) // *
+        if (epc === 45) return this.minExpand(s, p, ep) // -
+        s++
+        p = ep
+      }
+    } finally {
+      this.depth--
+    }
+  }
+
+  /**
+   * Capture `i` of the last match, which spanned `s` to `e`.
+   *
+   * @param   {number} i
+   * @param   {number} s
+   * @param   {number} e
+   * @returns {string | number}
+   */
+  capture(i, s, e) {
+    if (i >= this.level) {
+      if (i === 0) return this.src.substring(s, e)
+      throw fail('invalid capture index')
+    }
+    const l = this.capLen[i]
+    if (l === CAP_UNFINISHED) throw fail('unfinished capture')
+    if (l === CAP_POSITION) return this.capInit[i] + 1
+    return this.src.substr(this.capInit[i], l)
+  }
+
+  /**
+   * All the captures of the last match, or the whole match when the pattern has none.
+   *
+   * @param   {number}  s
+   * @param   {number}  e
+   * @param   {boolean} wholeIfNone
+   * @returns {(string | number)[]}
+   */
+  captures(s, e, wholeIfNone) {
+    const n = this.level === 0 && wholeIfNone ? 1 : this.level
+    const out = []
+    for (let i = 0; i < n; i++) out.push(this.capture(i, s, e))
+    return out
+  }
+}
+
+// Search
+// ■■■■■■
+
+/** Pattern characters that make a pattern more than a literal */
+const SPECIALS = /[\^$*+.?()[\]%-]/
+
+/**
+ * `string.find` and `string.match`.
+ *
+ * @param   {string}  s
+ * @param   {string}  pat
+ * @param   {number}  init   1-based start, negative counts from the end
+ * @param   {boolean} plain  search for pat as text
+ * @param   {boolean} isFind
+ * @returns {any[] | undefined}  the results, or undefined for nil
+ */
+export function find(s, pat, init, plain, isFind) {
+  const len = s.length
+  let start = init > 0 ? init - 1 : init === 0 ? 0 : Math.max(len + init, 0)
+  if (start > len) return undefined
+  if (isFind && (plain || !SPECIALS.test(pat))) {
+    const at = s.indexOf(pat, start)
+    return at < 0 ? undefined : [ at + 1, at + pat.length ]
+  }
+  const anchor = pat.charCodeAt(0) === 94
+  const ms = new MatchState(s, pat)
+  const p = anchor ? 1 : 0
+  do {
+    ms.reset()
+    const e = ms.match(start, p)
+    if (e !== -1) {
+      if (isFind) return /** @type {any[]} */ ([ start + 1, e ]).concat(ms.captures(start, e, false))
+      return ms.captures(start, e, true)
+    }
+    start++
+  } while (start <= len && !anchor)
+  return undefined
+}
+
+/**
+ * The iterator behind `string.gmatch`.
+ *
+ * @param   {string} s
+ * @param   {string} pat
+ * @returns {() => (string | number)[] | undefined}  each call gives the next match's captures, then undefined
+ */
+export function gmatch(s, pat) {
+  const ms = new MatchState(s, pat)
+  let pos = 0
+  return function () {
+    for (let start = pos; start <= s.length; start++) {
+      ms.reset()
+      const e = ms.match(start, 0)
+      if (e !== -1) {
+        pos = e === start ? e + 1 : e
+        return ms.captures(start, e, true)
+      }
+    }
+    pos = s.length + 1
+    return undefined
+  }
+}
+
+/**
+ * `string.gsub`.
+ *
+ * @param   {string} s
+ * @param   {string} pat
+ * @param   {(captures: (string | number)[]) => string | number | boolean | undefined} replace  the replacement for a match, given its captures; false or undefined keeps the match
+ * @param   {string | null} template  a replacement string with `%1` escapes, or null to use `replace`
+ * @param   {number} max
+ * @returns {[string, number]}
+ */
+export function gsub(s, pat, replace, template, max) {
+  const anchor = pat.charCodeAt(0) === 94
+  const p = anchor ? 1 : 0
+  const ms = new MatchState(s, pat)
+  let out = ''
+  let pos = 0
+  let n = 0
+  while (n < max) {
+    ms.reset()
+    const e = ms.match(pos, p)
+    if (e !== -1) {
+      n++
+      const whole = s.substring(pos, e)
+      if (template !== null) out += expand(ms, template, pos, e)
+      else {
+        const r = replace(ms.captures(pos, e, true))
+        if (r === undefined || r === false) out += whole
+        else out += r
+      }
+    }
+    if (e !== -1 && e > pos) pos = e
+    else if (pos < s.length) out += s.charAt(pos++)
+    else break
+    if (anchor) break
+  }
+  return [ out + s.substring(pos), n ]
+}
+
+/**
+ * A replacement string with its `%` escapes filled in.
+ *
+ * @param   {MatchState} ms
+ * @param   {string} template
+ * @param   {number} s
+ * @param   {number} e
+ * @returns {string}
+ */
+function expand(ms, template, s, e) {
+  let out = ''
+  for (let i = 0; i < template.length; i++) {
+    const c = template.charAt(i)
+    if (c !== '%') {
+      out += c
+      continue
+    }
+    i++
+    const d = template.charAt(i)
+    if (d === '%') out += '%'
+    else if (d >= '0' && d <= '9') {
+      const cap = d === '0' ? ms.src.substring(s, e) : ms.capture(d.charCodeAt(0) - 49, s, e)
+      out += cap
+    } else throw fail("invalid use of '%' in replacement string")
+  }
+  return out
+}