Still pass if constructor key is a primitive

is-plain-object.js

@@ -9,14 +9,33 @@ function isObject(o) {
   return Object.prototype.toString.call(o) === '[object Object]';
 }
 
+/**
+ * Returns if the encountered value is a native value that we can parse
+ * or process. This is basically the javascript typeof but with added
+ * support for null.
+ *
+ * @param {*} value
+ *
+ * @returns {boolean}
+ */
+function isPrimitive (value) {
+  if (value === null) {
+    return true;
+  }
+  return ['undefined', 'boolean', 'number', 'string', 'bigint'].includes(
+    typeof value
+  );
+}
+
+
 export function isPlainObject(o) {
   var ctor,prot;
 
   if (isObject(o) === false) return false;
 
   // If has modified constructor
   ctor = o.constructor;
-  if (ctor === undefined) return true;
+  if (ctor === undefined || isPrimitive(ctor)) return true;
 
   // If has modified prototype
   prot = ctor.prototype;

test/server.js

@@ -13,12 +13,13 @@ describe('Same-Realm Server Tests', function() {
     assert(isPlainObject(Object.create({})));
     assert(isPlainObject(Object.create(Object.prototype)));
     assert(isPlainObject({foo: 'bar'}));
+    assert(isPlainObject({constructor: 'not actually a constructor'}));
     assert(isPlainObject({}));
     assert(isPlainObject(Object.create(null)));
   });
 
   it('should return `false` if the object is not created by the `Object` constructor.', function() {
-    function Foo() {this.abc = {};};
+    function Foo() {this.abc = {};}
 
     assert(!isPlainObject(/foo/));
     assert(!isPlainObject(function() {}));