update packages to latest version

node_modules/domexception/lib/DOMException.js

@@ -3,203 +3,220 @@
 const conversions = require("webidl-conversions");
 const utils = require("./utils.js");
 
-const impl = utils.implSymbol;
-const ctorRegistry = utils.ctorRegistrySymbol;
+const implSymbol = utils.implSymbol;
+const ctorRegistrySymbol = utils.ctorRegistrySymbol;
 
-const iface = {
-  // When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
-  // method into this array. It allows objects that directly implements *those* interfaces to be recognized as
-  // implementing this mixin interface.
-  _mixedIntoPredicates: [],
-  is(obj) {
-    if (obj) {
-      if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
-        return true;
-      }
-      for (const isMixedInto of module.exports._mixedIntoPredicates) {
-        if (isMixedInto(obj)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  },
-  isImpl(obj) {
-    if (obj) {
-      if (obj instanceof Impl.implementation) {
-        return true;
-      }
+const interfaceName = "DOMException";
 
-      const wrapper = utils.wrapperForImpl(obj);
-      for (const isMixedInto of module.exports._mixedIntoPredicates) {
-        if (isMixedInto(wrapper)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  },
-  convert(obj, { context = "The provided value" } = {}) {
-    if (module.exports.is(obj)) {
-      return utils.implForWrapper(obj);
-    }
-    throw new TypeError(`${context} is not of type 'DOMException'.`);
-  },
-
-  create(globalObject, constructorArgs, privateData) {
-    if (globalObject[ctorRegistry] === undefined) {
-      throw new Error("Internal error: invalid global object");
-    }
-
-    const ctor = globalObject[ctorRegistry]["DOMException"];
-    if (ctor === undefined) {
-      throw new Error("Internal error: constructor DOMException is not installed on the passed global object");
-    }
-
-    let obj = Object.create(ctor.prototype);
-    obj = iface.setup(obj, globalObject, constructorArgs, privateData);
-    return obj;
-  },
-  createImpl(globalObject, constructorArgs, privateData) {
-    const obj = iface.create(globalObject, constructorArgs, privateData);
-    return utils.implForWrapper(obj);
-  },
-  _internalSetup(obj) {},
-  setup(obj, globalObject, constructorArgs = [], privateData = {}) {
-    privateData.wrapper = obj;
-
-    iface._internalSetup(obj);
-    Object.defineProperty(obj, impl, {
-      value: new Impl.implementation(globalObject, constructorArgs, privateData),
-      configurable: true
-    });
-
-    obj[impl][utils.wrapperSymbol] = obj;
-    if (Impl.init) {
-      Impl.init(obj[impl], privateData);
-    }
-    return obj;
-  },
-
-  install(globalObject) {
-    class DOMException {
-      constructor() {
-        const args = [];
-        {
-          let curArg = arguments[0];
-          if (curArg !== undefined) {
-            curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'DOMException': parameter 1" });
-          } else {
-            curArg = "";
-          }
-          args.push(curArg);
-        }
-        {
-          let curArg = arguments[1];
-          if (curArg !== undefined) {
-            curArg = conversions["DOMString"](curArg, { context: "Failed to construct 'DOMException': parameter 2" });
-          } else {
-            curArg = "Error";
-          }
-          args.push(curArg);
-        }
-        return iface.setup(Object.create(new.target.prototype), globalObject, args);
-      }
-
-      get name() {
-        if (!this || !module.exports.is(this)) {
-          throw new TypeError("Illegal invocation");
-        }
-
-        return this[impl]["name"];
-      }
-
-      get message() {
-        if (!this || !module.exports.is(this)) {
-          throw new TypeError("Illegal invocation");
-        }
-
-        return this[impl]["message"];
-      }
-
-      get code() {
-        if (!this || !module.exports.is(this)) {
-          throw new TypeError("Illegal invocation");
-        }
-
-        return this[impl]["code"];
-      }
-    }
-    Object.defineProperties(DOMException.prototype, {
-      name: { enumerable: true },
-      message: { enumerable: true },
-      code: { enumerable: true },
-      [Symbol.toStringTag]: { value: "DOMException", configurable: true },
-      INDEX_SIZE_ERR: { value: 1, enumerable: true },
-      DOMSTRING_SIZE_ERR: { value: 2, enumerable: true },
-      HIERARCHY_REQUEST_ERR: { value: 3, enumerable: true },
-      WRONG_DOCUMENT_ERR: { value: 4, enumerable: true },
-      INVALID_CHARACTER_ERR: { value: 5, enumerable: true },
-      NO_DATA_ALLOWED_ERR: { value: 6, enumerable: true },
-      NO_MODIFICATION_ALLOWED_ERR: { value: 7, enumerable: true },
-      NOT_FOUND_ERR: { value: 8, enumerable: true },
-      NOT_SUPPORTED_ERR: { value: 9, enumerable: true },
-      INUSE_ATTRIBUTE_ERR: { value: 10, enumerable: true },
-      INVALID_STATE_ERR: { value: 11, enumerable: true },
-      SYNTAX_ERR: { value: 12, enumerable: true },
-      INVALID_MODIFICATION_ERR: { value: 13, enumerable: true },
-      NAMESPACE_ERR: { value: 14, enumerable: true },
-      INVALID_ACCESS_ERR: { value: 15, enumerable: true },
-      VALIDATION_ERR: { value: 16, enumerable: true },
-      TYPE_MISMATCH_ERR: { value: 17, enumerable: true },
-      SECURITY_ERR: { value: 18, enumerable: true },
-      NETWORK_ERR: { value: 19, enumerable: true },
-      ABORT_ERR: { value: 20, enumerable: true },
-      URL_MISMATCH_ERR: { value: 21, enumerable: true },
-      QUOTA_EXCEEDED_ERR: { value: 22, enumerable: true },
-      TIMEOUT_ERR: { value: 23, enumerable: true },
-      INVALID_NODE_TYPE_ERR: { value: 24, enumerable: true },
-      DATA_CLONE_ERR: { value: 25, enumerable: true }
-    });
-    Object.defineProperties(DOMException, {
-      INDEX_SIZE_ERR: { value: 1, enumerable: true },
-      DOMSTRING_SIZE_ERR: { value: 2, enumerable: true },
-      HIERARCHY_REQUEST_ERR: { value: 3, enumerable: true },
-      WRONG_DOCUMENT_ERR: { value: 4, enumerable: true },
-      INVALID_CHARACTER_ERR: { value: 5, enumerable: true },
-      NO_DATA_ALLOWED_ERR: { value: 6, enumerable: true },
-      NO_MODIFICATION_ALLOWED_ERR: { value: 7, enumerable: true },
-      NOT_FOUND_ERR: { value: 8, enumerable: true },
-      NOT_SUPPORTED_ERR: { value: 9, enumerable: true },
-      INUSE_ATTRIBUTE_ERR: { value: 10, enumerable: true },
-      INVALID_STATE_ERR: { value: 11, enumerable: true },
-      SYNTAX_ERR: { value: 12, enumerable: true },
-      INVALID_MODIFICATION_ERR: { value: 13, enumerable: true },
-      NAMESPACE_ERR: { value: 14, enumerable: true },
-      INVALID_ACCESS_ERR: { value: 15, enumerable: true },
-      VALIDATION_ERR: { value: 16, enumerable: true },
-      TYPE_MISMATCH_ERR: { value: 17, enumerable: true },
-      SECURITY_ERR: { value: 18, enumerable: true },
-      NETWORK_ERR: { value: 19, enumerable: true },
-      ABORT_ERR: { value: 20, enumerable: true },
-      URL_MISMATCH_ERR: { value: 21, enumerable: true },
-      QUOTA_EXCEEDED_ERR: { value: 22, enumerable: true },
-      TIMEOUT_ERR: { value: 23, enumerable: true },
-      INVALID_NODE_TYPE_ERR: { value: 24, enumerable: true },
-      DATA_CLONE_ERR: { value: 25, enumerable: true }
-    });
-    if (globalObject[ctorRegistry] === undefined) {
-      globalObject[ctorRegistry] = Object.create(null);
-    }
-    globalObject[ctorRegistry]["DOMException"] = DOMException;
-
-    Object.defineProperty(globalObject, "DOMException", {
-      configurable: true,
-      writable: true,
-      value: DOMException
-    });
+exports.is = value => {
+  return utils.isObject(value) && utils.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+};
+exports.isImpl = value => {
+  return utils.isObject(value) && value instanceof Impl.implementation;
+};
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (exports.is(value)) {
+    return utils.implForWrapper(value);
   }
-}; // iface
-module.exports = iface;
+  throw new globalObject.TypeError(`${context} is not of type 'DOMException'.`);
+};
+
+function makeWrapper(globalObject, newTarget) {
+  let proto;
+  if (newTarget !== undefined) {
+    proto = newTarget.prototype;
+  }
+
+  if (!utils.isObject(proto)) {
+    proto = globalObject[ctorRegistrySymbol]["DOMException"].prototype;
+  }
+
+  return Object.create(proto);
+}
+
+exports.create = (globalObject, constructorArgs, privateData) => {
+  const wrapper = makeWrapper(globalObject);
+  return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+};
+
+exports.createImpl = (globalObject, constructorArgs, privateData) => {
+  const wrapper = exports.create(globalObject, constructorArgs, privateData);
+  return utils.implForWrapper(wrapper);
+};
+
+exports._internalSetup = (wrapper, globalObject) => {};
+
+exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+  privateData.wrapper = wrapper;
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: new Impl.implementation(globalObject, constructorArgs, privateData),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper;
+};
+
+exports.new = (globalObject, newTarget) => {
+  const wrapper = makeWrapper(globalObject, newTarget);
+
+  exports._internalSetup(wrapper, globalObject);
+  Object.defineProperty(wrapper, implSymbol, {
+    value: Object.create(Impl.implementation.prototype),
+    configurable: true
+  });
+
+  wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+  if (Impl.init) {
+    Impl.init(wrapper[implSymbol]);
+  }
+  return wrapper[implSymbol];
+};
+
+const exposed = new Set(["Window", "Worker"]);
+
+exports.install = (globalObject, globalNames) => {
+  if (!globalNames.some(globalName => exposed.has(globalName))) {
+    return;
+  }
+
+  const ctorRegistry = utils.initCtorRegistry(globalObject);
+  class DOMException {
+    constructor() {
+      const args = [];
+      {
+        let curArg = arguments[0];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to construct 'DOMException': parameter 1",
+            globals: globalObject
+          });
+        } else {
+          curArg = "";
+        }
+        args.push(curArg);
+      }
+      {
+        let curArg = arguments[1];
+        if (curArg !== undefined) {
+          curArg = conversions["DOMString"](curArg, {
+            context: "Failed to construct 'DOMException': parameter 2",
+            globals: globalObject
+          });
+        } else {
+          curArg = "Error";
+        }
+        args.push(curArg);
+      }
+      return exports.setup(Object.create(new.target.prototype), globalObject, args);
+    }
+
+    get name() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get name' called on an object that is not a valid instance of DOMException."
+        );
+      }
+
+      return esValue[implSymbol]["name"];
+    }
+
+    get message() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get message' called on an object that is not a valid instance of DOMException."
+        );
+      }
+
+      return esValue[implSymbol]["message"];
+    }
+
+    get code() {
+      const esValue = this !== null && this !== undefined ? this : globalObject;
+
+      if (!exports.is(esValue)) {
+        throw new globalObject.TypeError(
+          "'get code' called on an object that is not a valid instance of DOMException."
+        );
+      }
+
+      return esValue[implSymbol]["code"];
+    }
+  }
+  Object.defineProperties(DOMException.prototype, {
+    name: { enumerable: true },
+    message: { enumerable: true },
+    code: { enumerable: true },
+    [Symbol.toStringTag]: { value: "DOMException", configurable: true },
+    INDEX_SIZE_ERR: { value: 1, enumerable: true },
+    DOMSTRING_SIZE_ERR: { value: 2, enumerable: true },
+    HIERARCHY_REQUEST_ERR: { value: 3, enumerable: true },
+    WRONG_DOCUMENT_ERR: { value: 4, enumerable: true },
+    INVALID_CHARACTER_ERR: { value: 5, enumerable: true },
+    NO_DATA_ALLOWED_ERR: { value: 6, enumerable: true },
+    NO_MODIFICATION_ALLOWED_ERR: { value: 7, enumerable: true },
+    NOT_FOUND_ERR: { value: 8, enumerable: true },
+    NOT_SUPPORTED_ERR: { value: 9, enumerable: true },
+    INUSE_ATTRIBUTE_ERR: { value: 10, enumerable: true },
+    INVALID_STATE_ERR: { value: 11, enumerable: true },
+    SYNTAX_ERR: { value: 12, enumerable: true },
+    INVALID_MODIFICATION_ERR: { value: 13, enumerable: true },
+    NAMESPACE_ERR: { value: 14, enumerable: true },
+    INVALID_ACCESS_ERR: { value: 15, enumerable: true },
+    VALIDATION_ERR: { value: 16, enumerable: true },
+    TYPE_MISMATCH_ERR: { value: 17, enumerable: true },
+    SECURITY_ERR: { value: 18, enumerable: true },
+    NETWORK_ERR: { value: 19, enumerable: true },
+    ABORT_ERR: { value: 20, enumerable: true },
+    URL_MISMATCH_ERR: { value: 21, enumerable: true },
+    QUOTA_EXCEEDED_ERR: { value: 22, enumerable: true },
+    TIMEOUT_ERR: { value: 23, enumerable: true },
+    INVALID_NODE_TYPE_ERR: { value: 24, enumerable: true },
+    DATA_CLONE_ERR: { value: 25, enumerable: true }
+  });
+  Object.defineProperties(DOMException, {
+    INDEX_SIZE_ERR: { value: 1, enumerable: true },
+    DOMSTRING_SIZE_ERR: { value: 2, enumerable: true },
+    HIERARCHY_REQUEST_ERR: { value: 3, enumerable: true },
+    WRONG_DOCUMENT_ERR: { value: 4, enumerable: true },
+    INVALID_CHARACTER_ERR: { value: 5, enumerable: true },
+    NO_DATA_ALLOWED_ERR: { value: 6, enumerable: true },
+    NO_MODIFICATION_ALLOWED_ERR: { value: 7, enumerable: true },
+    NOT_FOUND_ERR: { value: 8, enumerable: true },
+    NOT_SUPPORTED_ERR: { value: 9, enumerable: true },
+    INUSE_ATTRIBUTE_ERR: { value: 10, enumerable: true },
+    INVALID_STATE_ERR: { value: 11, enumerable: true },
+    SYNTAX_ERR: { value: 12, enumerable: true },
+    INVALID_MODIFICATION_ERR: { value: 13, enumerable: true },
+    NAMESPACE_ERR: { value: 14, enumerable: true },
+    INVALID_ACCESS_ERR: { value: 15, enumerable: true },
+    VALIDATION_ERR: { value: 16, enumerable: true },
+    TYPE_MISMATCH_ERR: { value: 17, enumerable: true },
+    SECURITY_ERR: { value: 18, enumerable: true },
+    NETWORK_ERR: { value: 19, enumerable: true },
+    ABORT_ERR: { value: 20, enumerable: true },
+    URL_MISMATCH_ERR: { value: 21, enumerable: true },
+    QUOTA_EXCEEDED_ERR: { value: 22, enumerable: true },
+    TIMEOUT_ERR: { value: 23, enumerable: true },
+    INVALID_NODE_TYPE_ERR: { value: 24, enumerable: true },
+    DATA_CLONE_ERR: { value: 25, enumerable: true }
+  });
+  ctorRegistry[interfaceName] = DOMException;
+
+  Object.defineProperty(globalObject, interfaceName, {
+    configurable: true,
+    writable: true,
+    value: DOMException
+  });
+};
 
 const Impl = require("./DOMException-impl.js");

node_modules/domexception/lib/Function.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (typeof value !== "function") {
+    throw new globalObject.TypeError(context + " is not a function");
+  }
+
+  function invokeTheCallbackFunction(...args) {
+    const thisArg = utils.tryWrapperForImpl(this);
+    let callResult;
+
+    for (let i = 0; i < args.length; i++) {
+      args[i] = utils.tryWrapperForImpl(args[i]);
+    }
+
+    callResult = Reflect.apply(value, thisArg, args);
+
+    callResult = conversions["any"](callResult, { context: context, globals: globalObject });
+
+    return callResult;
+  }
+
+  invokeTheCallbackFunction.construct = (...args) => {
+    for (let i = 0; i < args.length; i++) {
+      args[i] = utils.tryWrapperForImpl(args[i]);
+    }
+
+    let callResult = Reflect.construct(value, args);
+
+    callResult = conversions["any"](callResult, { context: context, globals: globalObject });
+
+    return callResult;
+  };
+
+  invokeTheCallbackFunction[utils.wrapperSymbol] = value;
+  invokeTheCallbackFunction.objectReference = value;
+
+  return invokeTheCallbackFunction;
+};

node_modules/domexception/lib/VoidFunction.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+  if (typeof value !== "function") {
+    throw new globalObject.TypeError(context + " is not a function");
+  }
+
+  function invokeTheCallbackFunction() {
+    const thisArg = utils.tryWrapperForImpl(this);
+    let callResult;
+
+    callResult = Reflect.apply(value, thisArg, []);
+  }
+
+  invokeTheCallbackFunction.construct = () => {
+    let callResult = Reflect.construct(value, []);
+  };
+
+  invokeTheCallbackFunction[utils.wrapperSymbol] = value;
+  invokeTheCallbackFunction.objectReference = value;
+
+  return invokeTheCallbackFunction;
+};

node_modules/domexception/lib/legacy-error-codes.json

@@ -1,10 +1,8 @@
 {
   "IndexSizeError": 1,
-  "DOMStringSizeError": 2,
   "HierarchyRequestError": 3,
   "WrongDocumentError": 4,
   "InvalidCharacterError": 5,
-  "NoDataAllowedError": 6,
   "NoModificationAllowedError": 7,
   "NotFoundError": 8,
   "NotSupportedError": 9,
@@ -14,7 +12,6 @@
   "InvalidModificationError": 13,
   "NamespaceError": 14,
   "InvalidAccessError": 15,
-  "ValidationError": 16,
   "TypeMismatchError": 17,
   "SecurityError": 18,
   "NetworkError": 19,

node_modules/domexception/lib/utils.js

@@ -2,17 +2,65 @@
 
 // Returns "Type(value) is Object" in ES terminology.
 function isObject(value) {
-  return typeof value === "object" && value !== null || typeof value === "function";
+  return (typeof value === "object" && value !== null) || typeof value === "function";
 }
 
-function hasOwn(obj, prop) {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
+const hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
+
+// Like `Object.assign`, but using `[[GetOwnProperty]]` and `[[DefineOwnProperty]]`
+// instead of `[[Get]]` and `[[Set]]` and only allowing objects
+function define(target, source) {
+  for (const key of Reflect.ownKeys(source)) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
+    if (descriptor && !Reflect.defineProperty(target, key, descriptor)) {
+      throw new TypeError(`Cannot redefine property: ${String(key)}`);
+    }
+  }
+}
+
+function newObjectInRealm(globalObject, object) {
+  const ctorRegistry = initCtorRegistry(globalObject);
+  return Object.defineProperties(
+    Object.create(ctorRegistry["%Object.prototype%"]),
+    Object.getOwnPropertyDescriptors(object)
+  );
 }
 
 const wrapperSymbol = Symbol("wrapper");
 const implSymbol = Symbol("impl");
 const sameObjectCaches = Symbol("SameObject caches");
-const ctorRegistrySymbol = Symbol.for("[webidl2js]  constructor registry");
+const ctorRegistrySymbol = Symbol.for("[webidl2js] constructor registry");
+
+const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {}).prototype);
+
+function initCtorRegistry(globalObject) {
+  if (hasOwn(globalObject, ctorRegistrySymbol)) {
+    return globalObject[ctorRegistrySymbol];
+  }
+
+  const ctorRegistry = Object.create(null);
+
+  // In addition to registering all the WebIDL2JS-generated types in the constructor registry,
+  // we also register a few intrinsics that we make use of in generated code, since they are not
+  // easy to grab from the globalObject variable.
+  ctorRegistry["%Object.prototype%"] = globalObject.Object.prototype;
+  ctorRegistry["%IteratorPrototype%"] = Object.getPrototypeOf(
+    Object.getPrototypeOf(new globalObject.Array()[Symbol.iterator]())
+  );
+
+  try {
+    ctorRegistry["%AsyncIteratorPrototype%"] = Object.getPrototypeOf(
+      Object.getPrototypeOf(
+        globalObject.eval("(async function* () {})").prototype
+      )
+    );
+  } catch {
+    ctorRegistry["%AsyncIteratorPrototype%"] = AsyncIteratorPrototype;
+  }
+
+  globalObject[ctorRegistrySymbol] = ctorRegistry;
+  return ctorRegistry;
+}
 
 function getSameObject(wrapper, prop, creator) {
   if (!wrapper[sameObjectCaches]) {
@@ -46,14 +94,13 @@ function tryImplForWrapper(wrapper) {
 }
 
 const iterInternalSymbol = Symbol("internal");
-const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
 
 function isArrayIndexPropName(P) {
   if (typeof P !== "string") {
     return false;
   }
   const i = P >>> 0;
-  if (i === Math.pow(2, 32) - 1) {
+  if (i === 2 ** 32 - 1) {
     return false;
   }
   const s = `${i}`;
@@ -74,6 +121,22 @@ function isArrayBuffer(value) {
   }
 }
 
+function iteratorResult([key, value], kind) {
+  let result;
+  switch (kind) {
+    case "key":
+      result = key;
+      break;
+    case "value":
+      result = value;
+      break;
+    case "key+value":
+      result = [key, value];
+      break;
+  }
+  return { value: result, done: false };
+}
+
 const supportsPropertyIndex = Symbol("supports property index");
 const supportedPropertyIndices = Symbol("supported property indices");
 const supportsPropertyName = Symbol("supports property name");
@@ -86,19 +149,26 @@ const namedSetNew = Symbol("named property set new");
 const namedSetExisting = Symbol("named property set existing");
 const namedDelete = Symbol("named property delete");
 
+const asyncIteratorNext = Symbol("async iterator get the next iteration result");
+const asyncIteratorReturn = Symbol("async iterator return steps");
+const asyncIteratorInit = Symbol("async iterator initialization steps");
+const asyncIteratorEOI = Symbol("async iterator end of iteration");
+
 module.exports = exports = {
   isObject,
   hasOwn,
+  define,
+  newObjectInRealm,
   wrapperSymbol,
   implSymbol,
   getSameObject,
   ctorRegistrySymbol,
+  initCtorRegistry,
   wrapperForImpl,
   implForWrapper,
   tryWrapperForImpl,
   tryImplForWrapper,
   iterInternalSymbol,
-  IteratorPrototype,
   isArrayBuffer,
   isArrayIndexPropName,
   supportsPropertyIndex,
@@ -111,5 +181,10 @@ module.exports = exports = {
   namedGet,
   namedSetNew,
   namedSetExisting,
-  namedDelete
+  namedDelete,
+  asyncIteratorNext,
+  asyncIteratorReturn,
+  asyncIteratorInit,
+  asyncIteratorEOI,
+  iteratorResult
 };