Adds NaN checks for comparison operators

Author: TotalTechGeek

compiler.js

@@ -11,7 +11,7 @@ import {
 import asyncIterators from './async_iterators.js'
 import { coerceArray } from './utilities/coerceArray.js'
 import { countArguments } from './utilities/countArguments.js'
-import { precoerceNumber, assertSize } from './utilities/downgrade.js'
+import { precoerceNumber, assertSize, compareCheck } from './utilities/downgrade.js'
 
 /**
  * Provides a simple way to compile logic into a function that can be run.
@@ -315,12 +315,12 @@ function processBuiltString (method, str, buildState) {
     str = str.replace(`__%%%${x}%%%__`, item)
   })
 
-  const final = `(values, methods, notTraversed, asyncIterators, engine, above, coerceArray, precoerceNumber, assertSize) => ${buildState.asyncDetected ? 'async' : ''} (context ${buildState.extraArguments ? ',' + buildState.extraArguments : ''}) => { ${str.includes('prev') ? 'let prev;' : ''} const result = ${str}; return result }`
+  const final = `(values, methods, notTraversed, asyncIterators, engine, above, coerceArray, precoerceNumber, assertSize, compareCheck) => ${buildState.asyncDetected ? 'async' : ''} (context ${buildState.extraArguments ? ',' + buildState.extraArguments : ''}) => { ${str.includes('prev') ? 'let prev;' : ''} const result = ${str}; return result }`
   // console.log(str)
   // console.log(final)
   // eslint-disable-next-line no-eval
   return Object.assign(
-    (typeof globalThis !== 'undefined' ? globalThis : global).eval(final)(values, methods, notTraversed, asyncIterators, engine, above, coerceArray, precoerceNumber, assertSize), {
+    (typeof globalThis !== 'undefined' ? globalThis : global).eval(final)(values, methods, notTraversed, asyncIterators, engine, above, coerceArray, precoerceNumber, assertSize, compareCheck), {
       [Sync]: !buildState.asyncDetected,
       aboveDetected: typeof str === 'string' && str.includes(', above')
     })

defaultMethods.js

@@ -793,21 +793,45 @@ function createComparator (name, func) {
   return {
     method: (args, context, above, engine) => {
       if (!Array.isArray(args) || args.length <= 1) throw INVALID_ARGUMENTS
-      if (args.length === 2) return func(runOptimizedOrFallback(args[0], engine, context, above), runOptimizedOrFallback(args[1], engine, context, above))
+      if (args.length === 2) {
+        const a = runOptimizedOrFallback(args[0], engine, context, above)
+        const b = runOptimizedOrFallback(args[1], engine, context, above)
+        if (typeof a !== typeof b) {
+          if (typeof a === 'string' && Number.isNaN(+a)) throw NaN
+          if (typeof b === 'string' && Number.isNaN(+b)) throw NaN
+        }
+        return func(a, b)
+      }
       let prev = runOptimizedOrFallback(args[0], engine, context, above)
       for (let i = 1; i < args.length; i++) {
         const current = runOptimizedOrFallback(args[i], engine, context, above)
+        if (typeof current !== typeof prev) {
+          if (typeof current === 'string' && Number.isNaN(+current)) throw NaN
+          if (i === 1 && typeof prev === 'string' && Number.isNaN(+prev)) throw NaN
+        }
         if (!func(prev, current)) return false
         prev = current
       }
       return true
     },
     asyncMethod: async (args, context, above, engine) => {
       if (!Array.isArray(args) || args.length <= 1) throw INVALID_ARGUMENTS
-      if (args.length === 2) return func(await runOptimizedOrFallback(args[0], engine, context, above), await runOptimizedOrFallback(args[1], engine, context, above))
+      if (args.length === 2) {
+        const a = await runOptimizedOrFallback(args[0], engine, context, above)
+        const b = await runOptimizedOrFallback(args[1], engine, context, above)
+        if (typeof a !== typeof b) {
+          if (typeof a === 'string' && Number.isNaN(+a)) throw NaN
+          if (typeof b === 'string' && Number.isNaN(+b)) throw NaN
+        }
+        return func(a, b)
+      }
       let prev = await runOptimizedOrFallback(args[0], engine, context, above)
       for (let i = 1; i < args.length; i++) {
         const current = await runOptimizedOrFallback(args[i], engine, context, above)
+        if (typeof current !== typeof prev) {
+          if (typeof current === 'string' && Number.isNaN(+current)) throw NaN
+          if (i === 1 && typeof prev === 'string' && Number.isNaN(+prev)) throw NaN
+        }
         if (!func(prev, current)) return false
         prev = current
       }
@@ -816,9 +840,9 @@ function createComparator (name, func) {
     compile: (data, buildState) => {
       if (!Array.isArray(data)) return false
       if (data.length < 2) return false
-      if (data.length === 2) return buildState.compile`(${data[0]} ${opStr} ${data[1]})`
-      let res = buildState.compile`(${data[0]} ${opStr} (prev = ${data[1]}))`
-      for (let i = 2; i < data.length; i++) res = buildState.compile`(${res} && prev ${opStr} (prev = ${data[i]}))`
+      if (data.length === 2) return buildState.compile`((prev = ${data[0]}) ${opStr} compareCheck(${data[1]}, prev))`
+      let res = buildState.compile`((prev = ${data[0]}) ${opStr} (prev = compareCheck(${data[1]}, prev)))`
+      for (let i = 2; i < data.length; i++) res = buildState.compile`(${res} && prev ${opStr} (prev = compareCheck(${data[i]}, prev)))`
       return res
     },
     [OriginalImpl]: true,

optimizer.js

@@ -117,7 +117,16 @@ function checkIdioms (logic, engine, above) {
   // Hyper-Optimizations for Comparison Operators.
   for (const comparison in comparisons) {
     if (logic[comparison] && Array.isArray(logic[comparison]) && engine.methods[comparison][OriginalImpl]) {
-      const comparisonFunc = comparisons[comparison]
+      const _comparisonFunc = comparisons[comparison]
+
+      function comparisonFunc (a, b) {
+        if (typeof a !== typeof b) {
+          if (typeof a === 'string' && Number.isNaN(+a)) throw NaN
+          if (typeof b === 'string' && Number.isNaN(+b)) throw NaN
+        }
+        return _comparisonFunc(a, b)
+      }
+
       if (logic[comparison].length === 2) {
         const [a, b] = logic[comparison]
         const A = optimize(a, engine, above)