Add node modules and new code for release (#39)

Co-authored-by: tbarnes94 <tbarnes94@users.noreply.github.com>

node_modules/domexception/lib/DOMException-impl.js

@@ -0,0 +1,22 @@
+"use strict";
+const legacyErrorCodes = require("./legacy-error-codes.json");
+const idlUtils = require("./utils.js");
+
+exports.implementation = class DOMExceptionImpl {
+  constructor(globalObject, [message, name]) {
+    this.name = name;
+    this.message = message;
+  }
+
+  get code() {
+    return legacyErrorCodes[this.name] || 0;
+  }
+};
+
+// A proprietary V8 extension that causes the stack property to appear.
+exports.init = impl => {
+  if (Error.captureStackTrace) {
+    const wrapper = idlUtils.wrapperForImpl(impl);
+    Error.captureStackTrace(wrapper, wrapper.constructor);
+  }
+};

node_modules/domexception/lib/DOMException.js

@@ -0,0 +1,205 @@
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+
+const impl = utils.implSymbol;
+const ctorRegistry = 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 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
+    });
+  }
+}; // iface
+module.exports = iface;
+
+const Impl = require("./DOMException-impl.js");

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

@@ -0,0 +1,27 @@
+{
+  "IndexSizeError": 1,
+  "DOMStringSizeError": 2,
+  "HierarchyRequestError": 3,
+  "WrongDocumentError": 4,
+  "InvalidCharacterError": 5,
+  "NoDataAllowedError": 6,
+  "NoModificationAllowedError": 7,
+  "NotFoundError": 8,
+  "NotSupportedError": 9,
+  "InUseAttributeError": 10,
+  "InvalidStateError": 11,
+  "SyntaxError": 12,
+  "InvalidModificationError": 13,
+  "NamespaceError": 14,
+  "InvalidAccessError": 15,
+  "ValidationError": 16,
+  "TypeMismatchError": 17,
+  "SecurityError": 18,
+  "NetworkError": 19,
+  "AbortError": 20,
+  "URLMismatchError": 21,
+  "QuotaExceededError": 22,
+  "TimeoutError": 23,
+  "InvalidNodeTypeError": 24,
+  "DataCloneError": 25
+}

node_modules/domexception/lib/utils.js

@@ -0,0 +1,115 @@
+"use strict";
+
+// Returns "Type(value) is Object" in ES terminology.
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+const wrapperSymbol = Symbol("wrapper");
+const implSymbol = Symbol("impl");
+const sameObjectCaches = Symbol("SameObject caches");
+const ctorRegistrySymbol = Symbol.for("[webidl2js]  constructor registry");
+
+function getSameObject(wrapper, prop, creator) {
+  if (!wrapper[sameObjectCaches]) {
+    wrapper[sameObjectCaches] = Object.create(null);
+  }
+
+  if (prop in wrapper[sameObjectCaches]) {
+    return wrapper[sameObjectCaches][prop];
+  }
+
+  wrapper[sameObjectCaches][prop] = creator();
+  return wrapper[sameObjectCaches][prop];
+}
+
+function wrapperForImpl(impl) {
+  return impl ? impl[wrapperSymbol] : null;
+}
+
+function implForWrapper(wrapper) {
+  return wrapper ? wrapper[implSymbol] : null;
+}
+
+function tryWrapperForImpl(impl) {
+  const wrapper = wrapperForImpl(impl);
+  return wrapper ? wrapper : impl;
+}
+
+function tryImplForWrapper(wrapper) {
+  const impl = implForWrapper(wrapper);
+  return impl ? impl : 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) {
+    return false;
+  }
+  const s = `${i}`;
+  if (P !== s) {
+    return false;
+  }
+  return true;
+}
+
+const byteLengthGetter =
+    Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+function isArrayBuffer(value) {
+  try {
+    byteLengthGetter.call(value);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+const supportsPropertyIndex = Symbol("supports property index");
+const supportedPropertyIndices = Symbol("supported property indices");
+const supportsPropertyName = Symbol("supports property name");
+const supportedPropertyNames = Symbol("supported property names");
+const indexedGet = Symbol("indexed property get");
+const indexedSetNew = Symbol("indexed property set new");
+const indexedSetExisting = Symbol("indexed property set existing");
+const namedGet = Symbol("named property get");
+const namedSetNew = Symbol("named property set new");
+const namedSetExisting = Symbol("named property set existing");
+const namedDelete = Symbol("named property delete");
+
+module.exports = exports = {
+  isObject,
+  hasOwn,
+  wrapperSymbol,
+  implSymbol,
+  getSameObject,
+  ctorRegistrySymbol,
+  wrapperForImpl,
+  implForWrapper,
+  tryWrapperForImpl,
+  tryImplForWrapper,
+  iterInternalSymbol,
+  IteratorPrototype,
+  isArrayBuffer,
+  isArrayIndexPropName,
+  supportsPropertyIndex,
+  supportedPropertyIndices,
+  supportsPropertyName,
+  supportedPropertyNames,
+  indexedGet,
+  indexedSetNew,
+  indexedSetExisting,
+  namedGet,
+  namedSetNew,
+  namedSetExisting,
+  namedDelete
+};