v0.1.0

Author: krismuniz

CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to this library will be documented in this file.
+
+## 0.1.0 - 2020-07-02
+
+### 🚨 Breaking Changes
+
+- Throw errors instead of returning `{ parse_error: ... }` objects
+- Migrate from `@babel/parser` to `meriyah` (all error messages changed slightly)
+- Return `null` when input is empty script
+- Ignore `'use strict'` and other directives
+
+## 0.0.1 to 0.0.5 - 2002-01-12
+
+- Early Releases

README.md

@@ -86,11 +86,17 @@ Notes:
 
 - If a specific syntactic JS feature is not specified in the table above, it's likely that it isn't supported. If you have an idea on how to support said feature, feel free to file a GitHub Issue.
 
+### In Plans to Support
+
+- Optional Chaining
+- Nullish Coalescing
+
 ### Unsupported Syntax
 
 The following syntactic features are not supported by this module.
 
 - Class Declarations
+- Private name expressions `#myPrivateProperty`
 - Update Expressions (`i++`, `i--`, etc.)
 - Assignment Expressions
 - Tagged Template Expressions

lib/index.js

@@ -1,4 +1,4 @@
-const { parse } = require('@babel/parser')
+const { parseScript: parse } = require('meriyah')
 
 const processOp = (operator) => {
   switch (operator) {
@@ -27,31 +27,22 @@ const replaceVariable = (name) => (rule) => {
   }
 }
 
-function processError ({ loc }, message) {
-  return {
-    parsing_error: {
-      message,
-      at: loc
-    }
-  }
+function processError ({ loc, at }, message) {
+  const error = new Error(message)
+  error.at = at || loc
+  throw error
 }
 
 function processNode (node, valueOnly = false) {
+  if (!node) return null
+
   switch (node.type) {
-    case 'File': {
-      return processNode(node.program)
-    }
     case 'Program': {
-      if (node.directives.length > 0) {
-        return node.directives.length > 1
-          ? processError(node, 'Only one expression statement allowed.')
-          : processNode(node.directives[0])
-      }
-
       return node.body.length > 1
-        ? processError(node, 'Block statements can only have one expression statement.')
+        ? processError(node, 'Only one expression statement allowed.')
         : processNode(node.body[0])
     }
+
     case 'TemplateLiteral': {
       const nodes = []
       const expressions = node.expressions
@@ -74,29 +65,19 @@ function processNode (node, valueOnly = false) {
         cat: nodes
       }
     }
-    case 'Directive': {
-      // directives will be parsed as strings to allow rules to be just a plain string
-      return processNode(node.value)
-    }
-    case 'DirectiveLiteral':
-    case 'BooleanLiteral':
-    case 'StringLiteral':
-    case 'NumericLiteral': {
-      return node.value
-    }
 
-    case 'NullLiteral': {
-      return null
+    case 'Literal': {
+      if (node.value instanceof RegExp) {
+        return [node.value.source, node.value.flags]
+      }
+
+      return node.value
     }
 
     case 'SpreadElement': {
       return processNode(node.argument)
     }
 
-    case 'RegExpLiteral': {
-      return [node.pattern, node.flags]
-    }
-
     case 'ArrayExpression': {
       // handle spread operators [1, 2, ...myArray]
       if (node.elements.some((node) => node.type === 'SpreadElement')) {
@@ -157,7 +138,7 @@ function processNode (node, valueOnly = false) {
         }
       }
 
-      if (node.operator === '-' && node.argument.type === 'NumericLiteral') {
+      if (node.operator === '-' && typeof node.argument.value === 'number') {
         return node.argument.value * -1
       }
 
@@ -246,6 +227,9 @@ function processNode (node, valueOnly = false) {
     case 'AssignmentExpression': {
       return processError(node, 'Assignments not supported.')
     }
+    case 'PrivateName': {
+      return processError(node, 'Private names are not supported. Unexpected character \'#\'')
+    }
     /** catch other unsupported features */
     default: {
       return processError(node, `Invalid node '${node.type}'. Not supported.`)
@@ -255,13 +239,29 @@ function processNode (node, valueOnly = false) {
 
 const transformJS = (code) => {
   try {
-    return processNode(parse(code, { strictMode: true, errorRecovery: true }))
+    return processNode(
+      parse(code, {
+        loc: true,
+        next: true,
+        module: false,
+        impliedStrict: true,
+        directives: false
+      })
+    )
   } catch (e) {
     return processError({
-      loc: {
-        start: e.loc,
-        end: e.loc
-      }
+      at: e.loc
+        ? ({
+          start: {
+            line: e.loc.line,
+            column: e.loc.column
+          },
+          end: {
+            line: e.loc.line,
+            column: e.loc.column
+          }
+        })
+        : e.at
     }, `Could not parse code. ${e.message}`)
   }
 }