first commit

build/node_modules/prepack/lib/methods/construct.js

@@ -0,0 +1,231 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MakeConstructor = MakeConstructor;
+exports.Construct = Construct;
+exports.SpeciesConstructor = SpeciesConstructor;
+exports.MakeClassConstructor = MakeClassConstructor;
+exports.ConstructorMethod = ConstructorMethod;
+exports.NonConstructorMethodDefinitions = NonConstructorMethodDefinitions;
+
+var _index = require("../values/index.js");
+
+var _is = require("./is.js");
+
+var _get = require("./get.js");
+
+var _has = require("./has.js");
+
+var _singletons = require("../singletons.js");
+
+var _invariant = require("../invariant.js");
+
+var _invariant2 = _interopRequireDefault(_invariant);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// ECMA262 9.2.8
+function MakeConstructor(realm, F, writablePrototype, prototype) {
+  // 1. Assert: F is an ECMAScript function object.
+  (0, _invariant2.default)(F instanceof _index.ECMAScriptSourceFunctionValue, "expected function value");
+
+  // 2. Assert: F has a [[Construct]] internal method.
+  (0, _invariant2.default)(F.$Construct !== undefined, "expected construct internal method");
+
+  // 3. Assert: F is an extensible object that does not have a prototype own property.
+  (0, _invariant2.default)(F.getExtensible(), "expected extensible object that doesn't have prototype own property");
+
+  // 4. If the writablePrototype argument was not provided, let writablePrototype be true.
+  if (writablePrototype === null || writablePrototype === undefined) {
+    writablePrototype = true;
+  }
+
+  // 5. If the prototype argument was not provided, then
+  if (!prototype) {
+    // a. Let prototype be ObjectCreate(%ObjectPrototype%).
+    prototype = _singletons.Create.ObjectCreate(realm, realm.intrinsics.ObjectPrototype);
+    prototype.originalConstructor = F;
+
+    // b. Perform ! DefinePropertyOrThrow(prototype, "constructor", PropertyDescriptor{[[Value]]: F, [[Writable]]: writablePrototype, [[Enumerable]]: false, [[Configurable]]: true }).
+    _singletons.Properties.DefinePropertyOrThrow(realm, prototype, "constructor", {
+      value: F,
+      writable: writablePrototype,
+      enumerable: false,
+      configurable: true
+    });
+  }
+
+  // 6. Perform ! DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: writablePrototype, [[Enumerable]]: false, [[Configurable]]: false}).
+  _singletons.Properties.DefinePropertyOrThrow(realm, F, "prototype", {
+    value: prototype,
+    writable: writablePrototype,
+    enumerable: false,
+    configurable: false
+  });
+
+  // 7. Return NormalCompletion(undefined).
+  return realm.intrinsics.undefined;
+}
+
+// ECMA262 7.3.13
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+function Construct(realm, F, argumentsList, newTarget) {
+  // If newTarget was not passed, let newTarget be F.
+  if (!newTarget) newTarget = F;
+
+  // If argumentsList was not passed, let argumentsList be a new empty List.
+  if (!argumentsList) argumentsList = [];
+
+  // Assert: IsConstructor(F) is true.
+  (0, _invariant2.default)((0, _is.IsConstructor)(realm, F), "expected constructor");
+
+  // Assert: IsConstructor(newTarget) is true.
+  (0, _invariant2.default)((0, _is.IsConstructor)(realm, newTarget), "expected constructor");
+
+  // Return ? F.[[Construct]](argumentsList, newTarget).
+  (0, _invariant2.default)(F.$Construct !== undefined, "no construct method on realm value");
+  return F.$Construct(argumentsList, newTarget);
+}
+
+// ECMA262 7.3.20
+function SpeciesConstructor(realm, O, defaultConstructor) {
+  // 1. Assert: Type(O) is Object.
+  (0, _invariant2.default)(O instanceof _index.ObjectValue, "Type(O) is Object");
+
+  // 2. Let C be ? Get(O, "constructor").
+  var C = (0, _get.Get)(realm, O, "constructor");
+
+  // 3. If C is undefined, return defaultConstructor.
+  if (C instanceof _index.UndefinedValue) return defaultConstructor;
+
+  // 4. If Type(C) is not Object, throw a TypeError exception.
+  if (C.mightNotBeObject()) {
+    if (C.mightBeObject()) C.throwIfNotConcrete();
+    throw realm.createErrorThrowCompletion(realm.intrinsics.TypeError, "Type(C) is not an object");
+  }
+  (0, _invariant2.default)(C instanceof _index.ObjectValue || C instanceof _index.AbstractObjectValue);
+
+  // 5. Let S be ? Get(C, @@species).
+  var S = (0, _get.Get)(realm, C, realm.intrinsics.SymbolSpecies);
+
+  // 6. If S is either undefined or null, return defaultConstructor.
+  if ((0, _has.HasSomeCompatibleType)(S, _index.UndefinedValue, _index.NullValue)) return defaultConstructor;
+
+  // 7. If IsConstructor(S) is true, return S.
+  if ((0, _is.IsConstructor)(realm, S)) {
+    (0, _invariant2.default)(S instanceof _index.ObjectValue);
+    return S;
+  }
+
+  // 8. Throw a TypeError exception.
+  throw realm.createErrorThrowCompletion(realm.intrinsics.TypeError, "Throw a TypeError exception");
+}
+
+// ECMA 9.2.9
+function MakeClassConstructor(realm, F) {
+  // 1. Assert: F is an ECMAScript function object.
+  (0, _invariant2.default)(F instanceof _index.ECMAScriptSourceFunctionValue, "expected function value");
+
+  // 2. Assert: F’s [[FunctionKind]] internal slot is "normal".
+  (0, _invariant2.default)(F.$FunctionKind === "normal");
+
+  // 3. Set F’s [[FunctionKind]] internal slot to "classConstructor".
+  F.$FunctionKind = "classConstructor";
+
+  // 4. Return NormalCompletion(undefined).
+  return realm.intrinsics.undefined;
+}
+
+// ECMA 14.5.3
+function ConstructorMethod(realm, ClassElementList) {
+  var ClassElement = void 0;
+  // ClassElementList : ClassElement
+  if (ClassElementList.length === 1) {
+    ClassElement = ClassElementList[0];
+    // 1. If ClassElement is the production ClassElement : ; , return empty.
+    // It looks like Babel parses out ClassElements that are only ;
+
+    // 2. If IsStatic of ClassElement is true, return empty.
+    if ((0, _is.IsStatic)(ClassElement)) {
+      return realm.intrinsics.empty;
+    }
+    // 3. If PropName of ClassElement is not "constructor", return empty.
+    if (ClassElement.key.name !== "constructor") {
+      return realm.intrinsics.empty;
+    }
+
+    // 4. Return ClassElement.
+    return ClassElement;
+  } else {
+    // ClassElementList : ClassElementList ClassElement
+    // 1. Let head be ConstructorMethod of ClassElementList.
+    var head = ConstructorMethod(realm, ClassElementList.slice(0, -1));
+    // 2. If head is not empty, return head.
+    if (!(head instanceof _index.EmptyValue)) {
+      return head;
+    }
+
+    ClassElement = ClassElementList[ClassElementList.length - 1];
+    // 3. If ClassElement is the production ClassElement : ; , return empty.
+    // It looks like Babel parses out ClassElements that are only ;
+
+    // 4. If IsStatic of ClassElement is true, return empty.
+    if ((0, _is.IsStatic)(ClassElement)) {
+      return realm.intrinsics.empty;
+    }
+    // If PropName of ClassElement is not "constructor", return empty.
+    if (ClassElement.key.name !== "constructor") {
+      return realm.intrinsics.empty;
+    }
+
+    // Return ClassElement.
+    return ClassElement;
+  }
+}
+
+// ECMA 14.5.10
+function NonConstructorMethodDefinitions(realm, ClassElementList) {
+  var ClassElement = void 0;
+  // ClassElementList : ClassElement
+  if (ClassElementList.length === 1) {
+    ClassElement = ClassElementList[0];
+    // If ClassElement is the production ClassElement : ; , return a new empty List.
+
+    // If IsStatic of ClassElement is false and PropName of ClassElement is "constructor", return a new empty List.
+    if (!(0, _is.IsStatic)(ClassElement) && ClassElement.key.name === "constructor") {
+      return [];
+    }
+    // Return a List containing ClassElement.
+    return [ClassElement];
+  } else {
+    // ClassElementList : ClassElementList ClassElement
+    ClassElement = ClassElementList[ClassElementList.length - 1];
+
+    // Let list be NonConstructorMethodDefinitions of ClassElementList.
+    var list = NonConstructorMethodDefinitions(realm, ClassElementList.slice(0, -1));
+
+    // If ClassElement is the production ClassElement : ; , return list.
+
+    // If IsStatic of ClassElement is false and PropName of ClassElement is "constructor", return list.
+    if (!(0, _is.IsStatic)(ClassElement) && ClassElement.key.name === "constructor") {
+      return list;
+    }
+
+    // Append ClassElement to the end of list.
+    list.push(ClassElement);
+
+    // Return list.
+    return list;
+  }
+}
+//# sourceMappingURL=construct.js.map