hermes-parser 0.5.0 → 0.8.0

package/dist/HermesParserDeserializer.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -12,48 +12,28 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
+exports.default = void 0;
 
 var _HermesParserDecodeUTF8String = _interopRequireDefault(require("./HermesParserDecodeUTF8String"));
 
 var _HermesParserNodeDeserializers = _interopRequireDefault(require("./HermesParserNodeDeserializers"));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var HermesParserDeserializer = /*#__PURE__*/function () {
+class HermesParserDeserializer {
   // Matches StoredComment::Kind enum in JSLexer.h
   // Matches TokenType enum in HermesParserJSSerializer.h
-  function HermesParserDeserializer(programBuffer, positionBuffer, positionBufferSize, wasmParser, options) {
-    _classCallCheck(this, HermesParserDeserializer);
-
-    _defineProperty(this, "programBufferIdx", void 0);
-
-    _defineProperty(this, "positionBufferIdx", void 0);
-
-    _defineProperty(this, "positionBufferSize", void 0);
-
-    _defineProperty(this, "locMap", void 0);
-
-    _defineProperty(this, "HEAPU8", void 0);
-
-    _defineProperty(this, "HEAPU32", void 0);
-
-    _defineProperty(this, "HEAPF64", void 0);
-
-    _defineProperty(this, "options", void 0);
-
-    _defineProperty(this, "commentTypes", ['CommentLine', 'CommentBlock', 'InterpreterDirective']);
-
-    _defineProperty(this, "tokenTypes", ['Boolean', 'Identifier', 'Keyword', 'Null', 'Numeric', 'Punctuator', 'String', 'RegularExpression', 'Template', 'JSXText']);
-
+  constructor(programBuffer, positionBuffer, positionBufferSize, wasmParser, options) {
+    this.programBufferIdx = void 0;
+    this.positionBufferIdx = void 0;
+    this.positionBufferSize = void 0;
+    this.locMap = void 0;
+    this.HEAPU8 = void 0;
+    this.HEAPU32 = void 0;
+    this.HEAPF64 = void 0;
+    this.options = void 0;
+    this.commentTypes = ['CommentLine', 'CommentBlock', 'InterpreterDirective'];
+    this.tokenTypes = ['Boolean', 'Identifier', 'Keyword', 'Null', 'Numeric', 'BigInt', 'Punctuator', 'String', 'RegularExpression', 'Template', 'JSXText'];
     // Program and position buffer are memory addresses, so we must convert
     // into indices into HEAPU32 (an array of 4-byte integers).
     this.programBufferIdx = programBuffer / 4;
@@ -70,208 +50,194 @@ var HermesParserDeserializer = /*#__PURE__*/function () {
    */
 
 
-  _createClass(HermesParserDeserializer, [{
-    key: "next",
-    value: function next() {
-      var num = this.HEAPU32[this.programBufferIdx++];
-      return num;
-    }
-  }, {
-    key: "deserialize",
-    value: function deserialize() {
-      var program = {
-        type: 'Program',
-        loc: this.addEmptyLoc(),
-        body: this.deserializeNodeList(),
-        comments: this.deserializeComments()
-      };
-
-      if (this.options.tokens === true) {
-        program.tokens = this.deserializeTokens();
-      }
+  next() {
+    const num = this.HEAPU32[this.programBufferIdx++];
+    return num;
+  }
 
-      this.fillLocs();
-      return program;
-    }
-    /**
-     * Booleans are serialized as a single 4-byte integer.
-     */
-
-  }, {
-    key: "deserializeBoolean",
-    value: function deserializeBoolean() {
-      return Boolean(this.next());
-    }
-    /**
-     * Numbers are serialized directly into program buffer, taking up 8 bytes
-     * preceded by 4 bytes of alignment padding if necessary.
-     */
-
-  }, {
-    key: "deserializeNumber",
-    value: function deserializeNumber() {
-      var floatIdx; // Numbers are aligned on 8-byte boundaries, so skip padding if we are at
-      // an odd index into the 4-byte aligned program buffer.
-
-      if (this.programBufferIdx % 2 === 0) {
-        floatIdx = this.programBufferIdx / 2;
-        this.programBufferIdx += 2;
-      } else {
-        floatIdx = (this.programBufferIdx + 1) / 2;
-        this.programBufferIdx += 3;
-      }
+  deserialize() {
+    const program = {
+      type: 'Program',
+      loc: this.addEmptyLoc(),
+      body: this.deserializeNodeList(),
+      comments: this.deserializeComments()
+    };
 
-      return this.HEAPF64[floatIdx];
+    if (this.options.tokens === true) {
+      program.tokens = this.deserializeTokens();
     }
-    /**
-     * Strings are serialized as a 4-byte pointer into the heap, followed
-     * by their size as a 4-byte integer. The size is only present if the
-     * pointer is non-null.
-     */
-
-  }, {
-    key: "deserializeString",
-    value: function deserializeString() {
-      var ptr = this.next();
-
-      if (ptr === 0) {
-        return null;
-      }
 
-      var size = this.next();
-      return (0, _HermesParserDecodeUTF8String["default"])(ptr, size, this.HEAPU8);
+    this.fillLocs();
+    return program;
+  }
+  /**
+   * Booleans are serialized as a single 4-byte integer.
+   */
+
+
+  deserializeBoolean() {
+    return Boolean(this.next());
+  }
+  /**
+   * Numbers are serialized directly into program buffer, taking up 8 bytes
+   * preceded by 4 bytes of alignment padding if necessary.
+   */
+
+
+  deserializeNumber() {
+    let floatIdx; // Numbers are aligned on 8-byte boundaries, so skip padding if we are at
+    // an odd index into the 4-byte aligned program buffer.
+
+    if (this.programBufferIdx % 2 === 0) {
+      floatIdx = this.programBufferIdx / 2;
+      this.programBufferIdx += 2;
+    } else {
+      floatIdx = (this.programBufferIdx + 1) / 2;
+      this.programBufferIdx += 3;
     }
-    /**
-     * Nodes are serialized as a 4-byte integer denoting their node kind,
-     * followed by a 4-byte loc ID, followed by serialized node properties.
-     *
-     * If the node kind is 0 the node is null, otherwise the node kind - 1 is an
-     * index into the array of node deserialization functions.
-     */
-
-  }, {
-    key: "deserializeNode",
-    value: function deserializeNode() {
-      var nodeType = this.next();
-
-      if (nodeType === 0) {
-        return null;
-      }
 
-      var nodeDeserializer = _HermesParserNodeDeserializers["default"][nodeType - 1].bind(this);
+    return this.HEAPF64[floatIdx];
+  }
+  /**
+   * Strings are serialized as a 4-byte pointer into the heap, followed
+   * by their size as a 4-byte integer. The size is only present if the
+   * pointer is non-null.
+   */
+
 
-      return nodeDeserializer();
+  deserializeString() {
+    const ptr = this.next();
+
+    if (ptr === 0) {
+      return null;
     }
-    /**
-     * Node lists are serialized as a 4-byte integer denoting the number of
-     * elements in the list, followed by the serialized elements.
-     */
-
-  }, {
-    key: "deserializeNodeList",
-    value: function deserializeNodeList() {
-      var size = this.next();
-      var nodeList = [];
-
-      for (var i = 0; i < size; i++) {
-        nodeList.push(this.deserializeNode());
-      }
 
-      return nodeList;
+    const size = this.next();
+    return (0, _HermesParserDecodeUTF8String.default)(ptr, size, this.HEAPU8);
+  }
+  /**
+   * Nodes are serialized as a 4-byte integer denoting their node kind,
+   * followed by a 4-byte loc ID, followed by serialized node properties.
+   *
+   * If the node kind is 0 the node is null, otherwise the node kind - 1 is an
+   * index into the array of node deserialization functions.
+   */
+
+
+  deserializeNode() {
+    const nodeType = this.next();
+
+    if (nodeType === 0) {
+      return null;
     }
-    /**
-     * Comments are serialized as a node list, where each comment is serialized
-     * as a 4-byte integer denoting comment type, followed by a 4-byte value
-     * denoting the loc ID, followed by a serialized string for the comment value.
-     */
-
-  }, {
-    key: "deserializeComments",
-    value: function deserializeComments() {
-      var size = this.next();
-      var comments = [];
-
-      for (var i = 0; i < size; i++) {
-        var commentType = this.commentTypes[this.next()];
-        var loc = this.addEmptyLoc();
-        var value = this.deserializeString();
-        comments.push({
-          type: commentType,
-          loc: loc,
-          value: value
-        });
-      }
 
-      return comments;
+    const nodeDeserializer = _HermesParserNodeDeserializers.default[nodeType - 1].bind(this);
+
+    return nodeDeserializer();
+  }
+  /**
+   * Node lists are serialized as a 4-byte integer denoting the number of
+   * elements in the list, followed by the serialized elements.
+   */
+
+
+  deserializeNodeList() {
+    const size = this.next();
+    const nodeList = [];
+
+    for (let i = 0; i < size; i++) {
+      nodeList.push(this.deserializeNode());
     }
-  }, {
-    key: "deserializeTokens",
-    value: function deserializeTokens() {
-      var size = this.next();
-      var tokens = [];
-
-      for (var i = 0; i < size; i++) {
-        var tokenType = this.tokenTypes[this.next()];
-        var loc = this.addEmptyLoc();
-        var value = this.deserializeString();
-        tokens.push({
-          type: tokenType,
-          loc: loc,
-          value: value
-        });
-      }
 
-      return tokens;
+    return nodeList;
+  }
+  /**
+   * Comments are serialized as a node list, where each comment is serialized
+   * as a 4-byte integer denoting comment type, followed by a 4-byte value
+   * denoting the loc ID, followed by a serialized string for the comment value.
+   */
+
+
+  deserializeComments() {
+    const size = this.next();
+    const comments = [];
+
+    for (let i = 0; i < size; i++) {
+      const commentType = this.commentTypes[this.next()];
+      const loc = this.addEmptyLoc();
+      const value = this.deserializeString();
+      comments.push({
+        type: commentType,
+        loc,
+        value
+      });
     }
-    /**
-     * While deserializing the AST locations are represented by
-     * a 4-byte loc ID. This is used to create a map of loc IDs to empty loc
-     * objects that are filled after the AST has been deserialized.
-     */
-
-  }, {
-    key: "addEmptyLoc",
-    value: function addEmptyLoc() {
-      // $FlowExpectedError
-      var loc = {};
-      this.locMap[this.next()] = loc;
-      return loc;
+
+    return comments;
+  }
+
+  deserializeTokens() {
+    const size = this.next();
+    const tokens = [];
+
+    for (let i = 0; i < size; i++) {
+      const tokenType = this.tokenTypes[this.next()];
+      const loc = this.addEmptyLoc();
+      const value = this.deserializeString();
+      tokens.push({
+        type: tokenType,
+        loc,
+        value
+      });
     }
-    /**
-     * Positions are serialized as a loc ID which denotes which loc it is associated with,
-     * followed by kind which denotes whether it is a start or end position,
-     * followed by line, column, and offset (4-bytes each).
-     */
-
-  }, {
-    key: "fillLocs",
-    value: function fillLocs() {
-      for (var i = 0; i < this.positionBufferSize; i++) {
-        var locId = this.HEAPU32[this.positionBufferIdx++];
-        var kind = this.HEAPU32[this.positionBufferIdx++];
-        var line = this.HEAPU32[this.positionBufferIdx++];
-        var column = this.HEAPU32[this.positionBufferIdx++];
-        var offset = this.HEAPU32[this.positionBufferIdx++];
-        var loc = this.locMap[locId];
-
-        if (kind === 0) {
-          loc.start = {
-            line: line,
-            column: column
-          };
-          loc.rangeStart = offset;
-        } else {
-          loc.end = {
-            line: line,
-            column: column
-          };
-          loc.rangeEnd = offset;
-        }
+
+    return tokens;
+  }
+  /**
+   * While deserializing the AST locations are represented by
+   * a 4-byte loc ID. This is used to create a map of loc IDs to empty loc
+   * objects that are filled after the AST has been deserialized.
+   */
+
+
+  addEmptyLoc() {
+    // $FlowExpectedError
+    const loc = {};
+    this.locMap[this.next()] = loc;
+    return loc;
+  }
+  /**
+   * Positions are serialized as a loc ID which denotes which loc it is associated with,
+   * followed by kind which denotes whether it is a start or end position,
+   * followed by line, column, and offset (4-bytes each).
+   */
+
+
+  fillLocs() {
+    for (let i = 0; i < this.positionBufferSize; i++) {
+      const locId = this.HEAPU32[this.positionBufferIdx++];
+      const kind = this.HEAPU32[this.positionBufferIdx++];
+      const line = this.HEAPU32[this.positionBufferIdx++];
+      const column = this.HEAPU32[this.positionBufferIdx++];
+      const offset = this.HEAPU32[this.positionBufferIdx++];
+      const loc = this.locMap[locId];
+
+      if (kind === 0) {
+        loc.start = {
+          line,
+          column
+        };
+        loc.rangeStart = offset;
+      } else {
+        loc.end = {
+          line,
+          column
+        };
+        loc.rangeEnd = offset;
       }
     }
-  }]);
+  }
 
-  return HermesParserDeserializer;
-}();
+}
 
-exports["default"] = HermesParserDeserializer;
+exports.default = HermesParserDeserializer;

package/dist/HermesParserDeserializer.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -46,6 +46,7 @@ export default class HermesParserDeserializer {
     'Keyword',
     'Null',
     'Numeric',
+    'BigInt',
     'Punctuator',
     'String',
     'RegularExpression',