limit normalize-unicode cache size

This implements a very bare-bones LRU algorithm to prevent the string
normalization cache from growing unbounded.

Fix: #432

Author: isaacs

src/normalize-unicode.ts

@@ -2,11 +2,30 @@
 // This has been meticulously optimized for use
 // within npm install on large package trees.
 // Do not edit without careful benchmarking.
-const normalizeCache = Object.create(null)
-const { hasOwnProperty } = Object.prototype
-export const normalizeUnicode = (s: string) => {
-  if (!hasOwnProperty.call(normalizeCache, s)) {
+const normalizeCache: Record<string, string> = Object.create(null)
+
+// Limit the size of this. Very low-sophistication LRU cache
+const MAX = 10000
+const cache = new Set<string>()
+export const normalizeUnicode = (s: string): string => {
+  if (!cache.has(s)) {
     normalizeCache[s] = s.normalize('NFD')
+  } else {
+    cache.delete(s)
   }
-  return normalizeCache[s]
+  cache.add(s)
+
+  const ret = normalizeCache[s] as string
+
+  let i = cache.size - MAX
+  // only prune when we're 10% over the max
+  if (i > MAX / 10) {
+    for (const s of cache) {
+      cache.delete(s)
+      delete normalizeCache[s]
+      if (--i <= 0) break
+    }
+  }
+
+  return ret
 }

test/normalize-unicode.js

@@ -53,6 +53,26 @@ if (fakePlatform === 'win32') {
   })
 }
 
+t.test('blow out the cache', t => {
+  const cafBuf = Buffer.from([0x63, 0x61, 0x66])
+  const e1 = Buffer.from([0x65, 0xcc, 0x81])
+  const e2 = Buffer.from([0xc3, 0xa9])
+  let cafe1 = cafBuf
+  let cafe2 = cafBuf
+  for (let i = 0; i < 11_001; i++) {
+    cafe1 = Buffer.concat([cafe1, e1])
+    cafe2 = Buffer.concat([cafe2, e2])
+
+    const n1 = normalizeUnicode(cafe1.toString())
+    const n2 = normalizeUnicode(cafe2.toString())
+    // don't test all of these, too noisy
+    if (!(i % 500)) {
+      t.equal(n1, n2)
+    }
+  }
+  t.end()
+})
+
 if (fakePlatform !== 'win32') {
   t.spawn(process.execPath, [__filename, 'win32'], {
     env: {