hermes-parser 0.28.1 → 0.29.1

package/dist/src/HermesParserDecodeUTF8String.js

@@ -0,0 +1,68 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+'use strict';
+/**
+ * Decode a UTF-8 encoded string from Hermes with a known length.
+ * Based on Emscripten's UTF8ToString with the following differences:
+ * - Always reads all bytes up to the given length, including null bytes. This
+ *   means that we can decode strings that contain null bytes in the middle.
+ * - Allow UTF-8 encoded code points that are part of a surrogate pair, even though
+ *   this is technically invalid UTF-8 that UTF8ToString would convert to 0xfffd.
+ */
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = HermesParserDecodeUTF8String;
+
+function HermesParserDecodeUTF8String(ptrIn, length, heap) {
+  let ptr = ptrIn;
+  const endPtr = ptr + length;
+  let str = '';
+
+  while (ptr < endPtr) {
+    // ASCII characters fit in single byte code point
+    let u0 = heap[ptr++];
+
+    if (!(u0 & 0x80)) {
+      str += String.fromCharCode(u0);
+      continue;
+    } // Two byte code point
+
+
+    const u1 = heap[ptr++] & 0x3f;
+
+    if ((u0 & 0xe0) === 0xc0) {
+      str += String.fromCharCode((u0 & 0x1f) << 6 | u1);
+      continue;
+    }
+
+    const u2 = heap[ptr++] & 0x3f;
+
+    if ((u0 & 0xf0) === 0xe0) {
+      // Three byte code point
+      u0 = (u0 & 0x0f) << 12 | u1 << 6 | u2;
+    } else {
+      // Four byte code point
+      u0 = (u0 & 0x07) << 18 | u1 << 12 | u2 << 6 | heap[ptr++] & 0x3f;
+    }
+
+    if (u0 < 0x10000) {
+      // Code point fits into a single UTF-16 code unit
+      str += String.fromCharCode(u0);
+    } else {
+      // Code point does not fit into single UTF-16 code unit so convert to surrogate pair
+      u0 -= 0x10000;
+      str += String.fromCharCode(0xd800 | u0 >> 10, 0xdc00 | u0 & 0x3ff);
+    }
+  }
+
+  return str;
+}

package/dist/src/HermesParserDeserializer.js

@@ -0,0 +1,243 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _HermesParserDecodeUTF8String = _interopRequireDefault(require("./HermesParserDecodeUTF8String"));
+
+var _HermesParserNodeDeserializers = _interopRequireDefault(require("./HermesParserNodeDeserializers"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class HermesParserDeserializer {
+  // Matches StoredComment::Kind enum in JSLexer.h
+  // Matches TokenType enum in HermesParserJSSerializer.h
+  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;
+    this.positionBufferIdx = positionBuffer / 4;
+    this.positionBufferSize = positionBufferSize;
+    this.locMap = {};
+    this.HEAPU8 = wasmParser.HEAPU8;
+    this.HEAPU32 = wasmParser.HEAPU32;
+    this.HEAPF64 = wasmParser.HEAPF64;
+    this.options = options;
+  }
+  /**
+   * Consume and return the next 4 bytes in the program buffer.
+   */
+
+
+  next() {
+    const num = this.HEAPU32[this.programBufferIdx++];
+    return num;
+  }
+
+  deserialize() {
+    const program = {
+      type: 'Program',
+      loc: this.addEmptyLoc(),
+      body: this.deserializeNodeList(),
+      comments: this.deserializeComments()
+    };
+
+    if (this.options.tokens === true) {
+      program.tokens = this.deserializeTokens();
+    }
+
+    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;
+    }
+
+    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.
+   */
+
+
+  deserializeString() {
+    const ptr = this.next();
+
+    if (ptr === 0) {
+      return null;
+    }
+
+    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;
+    }
+
+    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());
+    }
+
+    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
+      });
+    }
+
+    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
+      });
+    }
+
+    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;
+      }
+    }
+  }
+
+}
+
+exports.default = HermesParserDeserializer;