1 files changed, 215 insertions, 0 deletions
diff --git a/devtools/shared/storage/vendor/stringvalidator/util/assert.js b/devtools/shared/storage/vendor/stringvalidator/util/assert.js
new file mode 100644
index 0000000000..3bd796aebd
--- /dev/null
+++ b/devtools/shared/storage/vendor/stringvalidator/util/assert.js
@@ -0,0 +1,215 @@
+// // based on node assert, original notice:
+// // NB: The URL to the CommonJS spec is kept just for tradition.
+// //     node-assert has evolved a lot since then, both in API and behavior.
+//
+// // http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+// //
+// // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+// //
+// // Originally from narwhal.js (http://narwhaljs.org)
+// // Copyright (c) 2009 Thomas Robinson <280north.com>
+// //
+// // Permission is hereby granted, free of charge, to any person obtaining a copy
+// // of this software and associated documentation files (the 'Software'), to
+// // deal in the Software without restriction, including without limitation the
+// // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// // sell copies of the Software, and to permit persons to whom the Software is
+// // furnished to do so, subject to the following conditions:
+// //
+// // The above copyright notice and this permission notice shall be included in
+// // all copies or substantial portions of the Software.
+// //
+// // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// // AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"use strict";
+
+var regex = /\s*function\s+([^\(\s]*)\s*/;
+
+var functionsHaveNames = (function () {
+  return function foo() {}.name === "foo";
+}());
+
+function assert(value, message) {
+  if (!value) {
+    fail(value, true, message, "==", assert.ok);
+  }
+}
+
+assert.equal = function equal(actual, expected, message) {
+  if (actual != expected) {
+    fail(actual, expected, message, "==", assert.equal);
+  }
+};
+
+assert.throws = function (block, error, message) {
+  _throws(true, block, error, message);
+};
+
+function _throws(shouldThrow, block, expected, message) {
+  var actual;
+
+  if (typeof block !== "function") {
+    throw new TypeError(`"block" argument must be a function`);
+  }
+
+  if (typeof expected === "string") {
+    message = expected;
+    expected = null;
+  }
+
+  actual = _tryBlock(block);
+
+  message = (expected?.name ? " (" + expected.name + ")." : ".") +
+            (message ? " " + message : ".");
+
+  if (shouldThrow && !actual) {
+    fail(actual, expected, "Missing expected exception" + message);
+  }
+
+  var userProvidedMessage = typeof message === "string";
+  var isUnwantedException = !shouldThrow && isError(actual);
+  var isUnexpectedException = !shouldThrow && actual && !expected;
+
+  if ((isUnwantedException &&
+      userProvidedMessage &&
+      expectedException(actual, expected)) ||
+      isUnexpectedException) {
+    fail(actual, expected, "Got unwanted exception" + message);
+  }
+
+  if ((shouldThrow && actual && expected &&
+      !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+    throw actual;
+  }
+}
+
+function fail(actual, expected, message, operator, stackStartFunction) {
+  throw new assert.AssertionError({
+    message: message,
+    actual: actual,
+    expected: expected,
+    operator: operator,
+    stackStartFunction: stackStartFunction
+  });
+}
+
+assert.fail = fail;
+
+assert.AssertionError = function AssertionError(options) {
+  this.name = "AssertionError";
+  this.actual = options.actual;
+  this.expected = options.expected;
+  this.operator = options.operator;
+  if (options.message) {
+    this.message = options.message;
+    this.generatedMessage = false;
+  } else {
+    this.message = getMessage(this);
+    this.generatedMessage = true;
+  }
+  var stackStartFunction = options.stackStartFunction || fail;
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, stackStartFunction);
+  } else {
+    // non v8 browsers so we can have a stacktrace
+    var err = new Error();
+    if (err.stack) {
+      var out = err.stack;
+
+      // try to strip useless frames
+      var fn_name = getName(stackStartFunction);
+      var idx = out.indexOf("\n" + fn_name);
+      if (idx >= 0) {
+        // once we have located the function frame
+        // we need to strip out everything before it (and its line)
+        var next_line = out.indexOf("\n", idx + 1);
+        out = out.substring(next_line + 1);
+      }
+
+      this.stack = out;
+    }
+  }
+};
+
+function expectedException(actual, expected) {
+  if (!actual || !expected) {
+    return false;
+  }
+
+  if (Object.prototype.toString.call(expected) == "[object RegExp]") {
+    return expected.test(actual);
+  }
+
+  try {
+    if (actual instanceof expected) {
+      return true;
+    }
+  } catch (e) {
+    // Ignore.  The instanceof check doesn"t work for arrow functions.
+  }
+
+  if (Error.isPrototypeOf(expected)) {
+    return false;
+  }
+
+  return expected.call({}, actual) === true;
+}
+
+function _tryBlock(block) {
+  var error;
+  try {
+    block();
+  } catch (e) {
+    error = e;
+  }
+  return error;
+}
+
+function isError(obj) {
+  return obj instanceof Error;
+}
+
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+function getMessage(self) {
+  return truncate(inspect(self.actual), 128) + " " +
+         self.operator + " " +
+         truncate(inspect(self.expected), 128);
+}
+
+function getName(func) {
+  if (!isFunction(func)) {
+    return null;
+  }
+  if (functionsHaveNames) {
+    return func.name;
+  }
+  var str = func.toString();
+  var match = str.match(regex);
+  return match?.[1];
+}
+
+function truncate(s, n) {
+  if (typeof s === "string") {
+    return s.length < n ? s : s.slice(0, n);
+  }
+  return s;
+}
+
+function inspect(something) {
+  if (functionsHaveNames || !isFunction(something)) {
+    throw new Error(something);
+  }
+  var rawname = getName(something);
+  var name = rawname ? ": " + rawname : "";
+  return "[Function" + name + "]";
+}
+
+exports.assert = assert;