@valbuild/core 0.63.6 → 0.64.0

package/dist/{index-041f75bd.cjs.prod.js → index-41223963.cjs.prod.js}

@@ -470,6 +470,50 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
           value: src
         }]);
       }
+      var _ref4 = this.options || {},
+        accept = _ref4.accept;
+      var _ref5 = src.metadata || {},
+        mimeType = _ref5.mimeType;
+      if (accept && mimeType && !mimeType.includes("/")) {
+        return _defineProperty({}, path, [{
+          message: "Invalid mime type format. Got: ".concat(mimeType),
+          value: src
+        }]);
+      }
+      if (accept && mimeType && mimeType.includes("/")) {
+        var acceptedTypes = accept.split(",").map(function (type) {
+          return type.trim();
+        });
+        var isValidMimeType = acceptedTypes.some(function (acceptedType) {
+          if (acceptedType === "*/*") {
+            return true;
+          }
+          if (acceptedType.endsWith("/*")) {
+            var baseType = acceptedType.slice(0, -2);
+            return mimeType.startsWith(baseType);
+          }
+          return acceptedType === mimeType;
+        });
+        if (!isValidMimeType) {
+          return _defineProperty({}, path, [{
+            message: "Mime type mismatch. Found '".concat(mimeType, "' but schema accepts '").concat(accept, "'"),
+            value: src
+          }]);
+        }
+      }
+      var fileMimeType = Internal.filenameToMimeType(src[FILE_REF_PROP]);
+      if (!fileMimeType) {
+        return _defineProperty({}, path, [{
+          message: "Could not determine mime type from file extension. Got: ".concat(src[FILE_REF_PROP]),
+          value: src
+        }]);
+      }
+      if (fileMimeType !== mimeType) {
+        return _defineProperty({}, path, [{
+          message: "Mime type and file extension not matching. Mime type is '".concat(mimeType, "' but file extension is '").concat(fileMimeType, "'"),
+          value: src
+        }]);
+      }
       if (src.metadata) {
         return _defineProperty({}, path, [{
           message: "Found metadata, but it could not be validated. File metadata must be an object with the required props: width (positive number), height (positive number) and sha256 (string of length 64 of the base16 hash).",
@@ -486,11 +530,53 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got 'null'",
+            typeError: true
+          }])
+        };
+      }
+      if (_typeof(src) !== "object") {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected object, got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
+      }
+      if (!(FILE_REF_PROP in src)) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Value of this schema must use: 'c.file' (error type: missing_ref_prop)",
+            typeError: true
+          }])
+        };
+      }
+      if (!(VAL_EXTENSION in src && src[VAL_EXTENSION] === "file")) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Value of this schema must use: 'c.file' (error type: missing_file_extension)",
+            typeError: true
+          }])
+        };
       }
-      return (src === null || src === void 0 ? void 0 : src[FILE_REF_PROP]) === "file" && (src === null || src === void 0 ? void 0 : src[VAL_EXTENSION]) === "file";
+      return {
+        success: true,
+        data: src
+      };
     }
   }, {
     key: "nullable",
@@ -635,7 +721,7 @@ function newSelectorProxy$1(source, path, moduleSchema) {
                     return newSelectorProxy$1(a, createValPathOfItem(path, i), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item);
                   }).filter(function (a) {
                     if (f && f instanceof Schema) {
-                      return f.assert(unValify$1(a));
+                      return f.assert(path || "", unValify$1(a)).success;
                     } else {
                       return unValify$1(f(a));
                     }
@@ -702,6 +788,20 @@ function createValPathOfItem(arrayPath, prop) {
   return "".concat(arrayPath).concat(Internal.ModuleFilePathSep).concat(JSON.stringify(prop));
 }
 
+// TODO: replace createValPathOfItem everywhere with this newer implementation (that does not return undefined but throws)
+function unsafeCreateSourcePath(path, itemKey) {
+  if (_typeof(itemKey) === "symbol") {
+    throw Error("Cannot create val path of array item with symbol prop: ".concat(itemKey.toString()));
+  }
+  if (!path) {
+    throw Error("Cannot create val path of array item of empty or missing path: ".concat(path, ". Item: ").concat(itemKey));
+  }
+  if (path.includes(Internal.ModuleFilePathSep)) {
+    return "".concat(path, ".").concat(JSON.stringify(itemKey));
+  }
+  return "".concat(path).concat(Internal.ModuleFilePathSep).concat(JSON.stringify(itemKey));
+}
+
 // TODO: could we do .val on the objects instead?
 function unValify$1(valueOrSelector) {
   if (_typeof(valueOrSelector) === "object" && (GetSource in valueOrSelector || Path$1 in valueOrSelector)) {
@@ -732,6 +832,11 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
       if (this.opt && (src === null || src === undefined)) {
         return false;
       }
+      if (src === null) {
+        return _defineProperty({}, path, [{
+          message: "Expected 'object', got 'null'"
+        }]);
+      }
       if (_typeof(src) !== "object") {
         return _defineProperty({}, path, [{
           message: "Expected 'object', got '".concat(_typeof(src), "'")
@@ -741,10 +846,10 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
           message: "Expected 'object', got 'array'"
         }]);
       }
-      Object.entries(this.items).forEach(function (_ref3) {
-        var _ref4 = _slicedToArray(_ref3, 2),
-          key = _ref4[0],
-          schema = _ref4[1];
+      Object.entries(this.items).forEach(function (_ref4) {
+        var _ref5 = _slicedToArray(_ref4, 2),
+          key = _ref5[0],
+          schema = _ref5[1];
         var subPath = createValPathOfItem(path, key);
         if (!subPath) {
           error = _this2.appendValidationError(error, path, "Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at key ").concat(key),
@@ -763,22 +868,66 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
       }
-      if (!src) {
-        return false;
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got 'null'",
+            typeError: true
+          }])
+        };
       }
-      for (var _i = 0, _Object$entries = Object.entries(this.items); _i < _Object$entries.length; _i++) {
-        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-          _key = _Object$entries$_i[0],
-          schema = _Object$entries$_i[1];
-        if (!schema.assert(src[_key])) {
-          return false;
+      if (_typeof(src) !== "object") {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
+      } else if (Array.isArray(src)) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got 'array'",
+            typeError: true
+          }])
+        };
+      }
+      var errorsAtPath = [];
+      for (var _i = 0, _Object$keys = Object.keys(this.items); _i < _Object$keys.length; _i++) {
+        var _key = _Object$keys[_i];
+        var subPath = createValPathOfItem(path, _key);
+        if (!subPath) {
+          errorsAtPath.push({
+            message: "Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at key ").concat(_key),
+            // Should! never happen
+            internalError: true
+          });
+        } else if (!(_key in src)) {
+          errorsAtPath.push({
+            message: "Expected key '".concat(_key, "' not found in object"),
+            typeError: true
+          });
         }
       }
-      return _typeof(src) === "object" && !Array.isArray(src);
+      if (errorsAtPath.length > 0) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, errorsAtPath)
+        };
+      }
+      return {
+        success: true,
+        data: src
+      };
     }
   }, {
     key: "nullable",
@@ -790,10 +939,10 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
     value: function serialize() {
       return {
         type: "object",
-        items: Object.fromEntries(Object.entries(this.items).map(function (_ref5) {
-          var _ref6 = _slicedToArray(_ref5, 2),
-            key = _ref6[0],
-            schema = _ref6[1];
+        items: Object.fromEntries(Object.entries(this.items).map(function (_ref6) {
+          var _ref7 = _slicedToArray(_ref6, 2),
+            key = _ref7[0],
+            schema = _ref7[1];
           return [key, schema.serialize()];
         })),
         opt: this.opt
@@ -1056,7 +1205,7 @@ function parseTokens$1(inputTokens) {
   }
   return res;
 }
-function parse$1(input) {
+function parse(input) {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   var _tokenize = tokenize(input),
     _tokenize2 = _slicedToArray(_tokenize, 2),
@@ -1182,7 +1331,7 @@ function newSelectorProxy(source, path, moduleSchema) {
                     return newSelectorProxy(a, createValPathOfItem(path, i), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item);
                   }).filter(function (a) {
                     if (f && f instanceof Schema) {
-                      return f.assert(unValify(a));
+                      return f.assert(path || "", unValify(a)).success;
                     } else {
                       return unValify(f(a));
                     }
@@ -1425,7 +1574,7 @@ function evaluate(expr, source, stack) {
 
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  parse: parse$1,
+  parse: parse,
   Call: Call,
   Expr: Expr,
   NilSym: NilSym,
@@ -1449,57 +1598,69 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
   _createClass(ArraySchema, [{
     key: "validate",
     value: function validate(path, src) {
-      var _this2 = this;
-      var error = false;
-      if (this.opt && (src === null || src === undefined)) {
-        return false;
+      var assertRes = this.assert(path, src);
+      if (!assertRes.success) {
+        return assertRes.errors;
       }
-      if (_typeof(src) !== "object" || !Array.isArray(src)) {
-        return _defineProperty({}, path, [{
-          message: "Expected 'array', got '".concat(_typeof(src), "'")
-        }]);
+      if (assertRes.data === null) {
+        return false;
       }
-      src.forEach(function (i, idx) {
-        var subPath = createValPathOfItem(path, idx);
-        if (!subPath) {
-          error = _this2.appendValidationError(error, path, "Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at index ").concat(idx),
-          // Should! never happen
-          src);
-        } else {
-          var subError = _this2.item.validate(subPath, i);
-          if (subError && error) {
-            error = _objectSpread2(_objectSpread2({}, subError), error);
-          } else if (subError) {
-            error = subError;
-          }
+      var error = {};
+      for (var _i = 0, _Object$entries = Object.entries(assertRes.data); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          idx = _Object$entries$_i[0],
+          i = _Object$entries$_i[1];
+        var subPath = unsafeCreateSourcePath(path, Number(idx));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var subError = this.item.validate(subPath, i);
+        if (subError) {
+          error = _objectSpread2(_objectSpread2({}, subError), error);
         }
-      });
+      }
+      if (Object.keys(error).length === 0) {
+        return false;
+      }
       return error;
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (src === null && this.opt) {
+        return {
+          success: true,
+          data: src
+        };
       }
-      if (!src) {
-        return false;
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'array', got 'null'",
+            typeError: true
+          }])
+        };
       }
-      var _iterator = result._createForOfIteratorHelper(src),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var _item = _step.value;
-          if (!this.item.assert(_item)) {
-            return false;
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+      if (_typeof(src) !== "object") {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
+      } else if (!Array.isArray(src)) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected object of type 'array'",
+            typeError: true
+          }])
+        };
       }
-      return _typeof(src) === "object" && Array.isArray(src);
+      return {
+        success: true,
+        data: src
+      };
     }
   }, {
     key: "nullable",
@@ -1555,11 +1716,35 @@ var LiteralSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'string', got 'null'",
+            typeError: true
+          }])
+        };
+      }
+      if (typeof src === "string" && src === this.value) {
+        return {
+          success: true,
+          data: src
+        };
       }
-      return typeof src === "string";
+      return {
+        success: false,
+        errors: _defineProperty({}, path, [{
+          message: "Expected literal '".concat(this.value, "', got '").concat(src, "'"),
+          typeError: true
+        }])
+      };
     }
   }, {
     key: "nullable",
@@ -1599,20 +1784,20 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
     value: function validate(path, src) {
       var unknownSrc = src;
       var errors = false;
-      if (this.opt && (unknownSrc === null || unknownSrc === undefined)) {
-        // TODO: src should never be undefined
+      if (this.opt && unknownSrc === null) {
         return false;
       }
       if (!this.key) {
         return _defineProperty({}, path, [{
-          message: "Missing required first argument in union"
+          message: "Missing required first argument in union",
+          schemaError: true
         }]);
       }
       var key = this.key;
       if (!Array.isArray(this.items)) {
         return _defineProperty({}, path, [{
           message: "A union schema must take more than 1 schema arguments",
-          fatal: true
+          schemaError: true
         }]);
       }
       if (typeof key === "string") {
@@ -1622,7 +1807,7 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
         })) {
           return _defineProperty({}, path, [{
             message: "Key is a string, so all schema items must be objects",
-            fatal: true
+            schemaError: true
           }]);
         }
         var objectSchemas = this.items;
@@ -1635,7 +1820,7 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
         if (illegalSchemas.length > 0) {
           return _defineProperty({}, path, [{
             message: "All schema items must be objects with a key: ".concat(key, " that is a literal schema. Found: ").concat(JSON.stringify(illegalSchemas, null, 2)),
-            fatal: true
+            schemaError: true
           }]);
         }
         var serializedObjectSchemas = serializedSchemas;
@@ -1645,18 +1830,20 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
         if (optionalLiterals.length > 1) {
           return _defineProperty({}, path, [{
             message: "Schema cannot have an optional keys: ".concat(key),
-            fatal: true
+            schemaError: true
           }]);
         }
         if (_typeof(unknownSrc) !== "object") {
           return _defineProperty({}, path, [{
-            message: "Expected an object"
+            message: "Expected an object",
+            typeError: true
           }]);
         }
         var objectSrc = unknownSrc;
         if (objectSrc[key] === undefined) {
           return _defineProperty({}, path, [{
-            message: "Missing required key: ".concat(key)
+            message: "Missing required key: ".concat(key),
+            typeError: true
           }]);
         }
         var foundSchemaLiterals = [];
@@ -1672,7 +1859,7 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
               } else {
                 return _defineProperty({}, path, [{
                   message: "Found duplicate key in schema: ".concat(schemaKey.value),
-                  fatal: true
+                  schemaError: true
                 }]);
               }
             }
@@ -1712,7 +1899,7 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
         })) {
           return _defineProperty({}, path, [{
             message: "Key is a literal schema, so all schema items must be literals",
-            fatal: true
+            typeError: true
           }]);
         }
         var literalItems = [key].concat(_toConsumableArray(this.items));
@@ -1737,8 +1924,146 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got 'null'",
+            typeError: true
+          }])
+        };
+      }
+      if (!this.key) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Missing required first argument in union schema",
+            schemaError: true
+          }])
+        };
+      }
+      if (!Array.isArray(this.items)) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "The schema of this value is wrong. Schema is neither a union of literals nor a tagged union (of objects)",
+            schemaError: true
+          }])
+        };
+      }
+      if (this.key instanceof LiteralSchema) {
+        var _ref13;
+        var success = false;
+        var errors = {};
+        var _iterator2 = result._createForOfIteratorHelper((_ref13 = [this.key]).concat.apply(_ref13, _toConsumableArray(this.items))),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var itemSchema = _step2.value;
+            if (!(itemSchema instanceof LiteralSchema)) {
+              return {
+                success: false,
+                errors: _defineProperty({}, path, [{
+                  message: "Schema of value is a union of string, so all schema items must be literals",
+                  schemaError: true
+                }])
+              };
+            }
+            if (typeof src !== "string") {
+              errors[path] = [{
+                message: "Expected 'string', got '".concat(_typeof(src), "'"),
+                typeError: true
+              }];
+              continue;
+            }
+            var res = itemSchema.assert(path, src);
+            if (res.success) {
+              success = true;
+              break;
+            } else {
+              for (var _i = 0, _Object$entries = Object.entries(res.errors); _i < _Object$entries.length; _i++) {
+                var _errors5;
+                var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+                  _key = _Object$entries$_i[0],
+                  value = _Object$entries$_i[1];
+                if (!errors[_key]) {
+                  errors[_key] = [];
+                }
+                (_errors5 = errors[_key]).push.apply(_errors5, _toConsumableArray(value));
+              }
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        if (!success) {
+          return {
+            success: false,
+            errors: errors
+          };
+        }
+        return {
+          success: true,
+          data: src
+        };
+      } else if (typeof this.key === "string") {
+        var _success = false;
+        var _errors6 = {};
+        var _iterator3 = result._createForOfIteratorHelper(this.items),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var _itemSchema = _step3.value;
+            var _res = _itemSchema.assert(path, src);
+            if (_res.success) {
+              _success = true;
+              break;
+            } else {
+              for (var _i2 = 0, _Object$entries2 = Object.entries(_res.errors); _i2 < _Object$entries2.length; _i2++) {
+                var _errors7;
+                var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+                  _key2 = _Object$entries2$_i[0],
+                  _value = _Object$entries2$_i[1];
+                if (!_errors6[_key2]) {
+                  _errors6[_key2] = [];
+                }
+                (_errors7 = _errors6[_key2]).push.apply(_errors7, _toConsumableArray(_value)); // by appending all type errors, we most likely get a lot of duplicate errors. Currently we believe this is correct though, but should probably be handled in when showing the errors to users
+              }
+            }
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+        if (!_success) {
+          return {
+            success: false,
+            errors: _errors6
+          };
+        }
+        return {
+          success: true,
+          data: src
+        };
+      } else {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "The schema of this value is wrong. Schema is neither a union of literals nor a tagged union (of objects)",
+            schemaError: true
+          }])
+        };
+      }
     }
   }, {
     key: "nullable",
@@ -1771,8 +2096,8 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
   return UnionSchema;
 }(Schema);
 var union = function union(key) {
-  for (var _len = arguments.length, objects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    objects[_key - 1] = arguments[_key];
+  for (var _len = arguments.length, objects = new Array(_len > 1 ? _len - 1 : 0), _key3 = 1; _key3 < _len; _key3++) {
+    objects[_key3 - 1] = arguments[_key3];
   }
   return new UnionSchema(key, objects);
 };
@@ -1799,12 +2124,147 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
           fixes: ["fix:deprecated-richtext"]
         }]);
       }
-      return false; //TODO
+      var assertRes = this.assert(path, src);
+      if (!assertRes.success) {
+        return _defineProperty({}, path, assertRes.errors[path]);
+      }
+      // TODO validate options
+      return false;
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      return true; // TODO
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (!Array.isArray(src)) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'array', got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
+      }
+      var errors = {};
+      for (var i = 0; i < src.length; i++) {
+        this.recursiveAssert(unsafeCreateSourcePath(path, i), src[i], errors);
+      }
+      if (Object.keys(errors).length > 0) {
+        return {
+          success: false,
+          errors: errors
+        };
+      }
+      // TODO: validate options
+      return {
+        success: true,
+        data: src
+      };
+    }
+  }, {
+    key: "recursiveAssert",
+    value: function recursiveAssert(path, node, errors) {
+      if (_typeof(node) !== "object") {
+        if (!errors[path]) {
+          errors[path] = [];
+        }
+        errors[path].push({
+          message: "Expected 'object', got '".concat(_typeof(node), "'"),
+          typeError: true
+        });
+        return;
+      }
+      if (Array.isArray(node)) {
+        if (!errors[path]) {
+          errors[path] = [];
+        }
+        errors[path].push({
+          message: "Expected 'object', got 'array'",
+          typeError: true
+        });
+        return;
+      }
+      if (node === null) {
+        if (!errors[path]) {
+          errors[path] = [];
+        }
+        errors[path].push({
+          message: "Expected 'object', got 'null'",
+          typeError: true
+        });
+        return;
+      }
+      if ("tag" in node) {
+        if (typeof node.tag !== "string") {
+          if (!errors[path]) {
+            errors[path] = [];
+          }
+          errors[path].push({
+            message: "Expected 'string', got '".concat(_typeof(node.tag), "'"),
+            typeError: true
+          });
+          return;
+        }
+      }
+      if ("children" in node) {
+        if (!Array.isArray(node.children)) {
+          if (!errors[path]) {
+            errors[path] = [];
+          }
+          errors[path].push({
+            message: "Expected 'array', got '".concat(_typeof(node.children), "'"),
+            typeError: true
+          });
+          return;
+        } else {
+          for (var i = 0; i < node.children.length; i++) {
+            var child = node.children[i];
+            var pathAtError = unsafeCreateSourcePath(unsafeCreateSourcePath(path, "children"), i);
+            if (_typeof(child) === "object") {
+              this.recursiveAssert(pathAtError, child, errors);
+            } else if (typeof child === "string") {
+              continue;
+            } else {
+              if (!errors[pathAtError]) {
+                errors[pathAtError] = [];
+              }
+              errors[pathAtError].push({
+                message: "Expected 'object' or 'string', got '".concat(_typeof(child), "'"),
+                typeError: true
+              });
+            }
+          }
+        }
+      }
+      if ("styles" in node) {
+        if (!Array.isArray(node.styles)) {
+          if (!errors[path]) {
+            errors[path] = [];
+          }
+          errors[path].push({
+            message: "Expected 'array', got '".concat(_typeof(node.styles), "'"),
+            typeError: true
+          });
+        } else {
+          for (var _i = 0; _i < node.styles.length; _i++) {
+            var style = node.styles[_i];
+            if (typeof style !== "string") {
+              var _pathAtError = unsafeCreateSourcePath(path, _i);
+              if (!errors[_pathAtError]) {
+                errors[_pathAtError] = [];
+              }
+              errors[_pathAtError].push({
+                message: "Expected 'string', got '".concat(_typeof(style), "'"),
+                typeError: true
+              });
+            }
+          }
+        }
+      }
     }
   }, {
     key: "nullable",
@@ -1862,6 +2322,50 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
           value: src
         }]);
       }
+      var _ref4 = this.options || {},
+        accept = _ref4.accept;
+      var _ref5 = src.metadata || {},
+        mimeType = _ref5.mimeType;
+      if (accept && mimeType && !mimeType.includes("/")) {
+        return _defineProperty({}, path, [{
+          message: "Invalid mime type format. Got: '".concat(mimeType, "'"),
+          value: src
+        }]);
+      }
+      if (accept && mimeType && mimeType.includes("/")) {
+        var acceptedTypes = accept.split(",").map(function (type) {
+          return type.trim();
+        });
+        var isValidMimeType = acceptedTypes.some(function (acceptedType) {
+          if (acceptedType === "*/*") {
+            return true;
+          }
+          if (acceptedType.endsWith("/*")) {
+            var baseType = acceptedType.slice(0, -2);
+            return mimeType.startsWith(baseType);
+          }
+          return acceptedType === mimeType;
+        });
+        if (!isValidMimeType) {
+          return _defineProperty({}, path, [{
+            message: "Mime type mismatch. Found '".concat(mimeType, "' but schema accepts '").concat(accept, "'"),
+            value: src
+          }]);
+        }
+      }
+      var fileMimeType = Internal.filenameToMimeType(src[FILE_REF_PROP]);
+      if (!fileMimeType) {
+        return _defineProperty({}, path, [{
+          message: "Could not determine mime type from file extension. Got: ".concat(src[FILE_REF_PROP]),
+          value: src
+        }]);
+      }
+      if (fileMimeType && mimeType && fileMimeType !== mimeType) {
+        return _defineProperty({}, path, [{
+          message: "Mime type and file extension not matching. Mime type is '".concat(mimeType, "' but file extension is '").concat(fileMimeType, "'"),
+          value: src
+        }]);
+      }
       if (src.metadata) {
         return _defineProperty({}, path, [{
           message: "Found metadata, but it could not be validated. Image metadata must be an object with the required props: width (positive number), height (positive number) and sha256 (string of length 64 of the base16 hash).",
@@ -1878,11 +2382,53 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got 'null'",
+            typeError: true
+          }])
+        };
+      }
+      if (_typeof(src) !== "object") {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
+      }
+      if (!(FILE_REF_PROP in src)) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Value of this schema must use: 'c.image' (error type: missing_ref_prop)",
+            typeError: true
+          }])
+        };
       }
-      return (src === null || src === void 0 ? void 0 : src[FILE_REF_PROP]) === "image" && (src === null || src === void 0 ? void 0 : src[VAL_EXTENSION]) === "file";
+      if (!(VAL_EXTENSION in src && src[VAL_EXTENSION] === "file")) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Value of this schema must use: 'c.image' (error type: missing_file_extension)",
+            typeError: true
+          }])
+        };
+      }
+      return {
+        success: true,
+        data: src
+      };
     }
   }, {
     key: "nullable",
@@ -1924,6 +2470,11 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
       if (this.opt && (src === null || src === undefined)) {
         return false;
       }
+      if (src === null) {
+        return _defineProperty({}, path, [{
+          message: "Expected 'object', got 'null'"
+        }]);
+      }
       if (_typeof(src) !== "object") {
         return _defineProperty({}, path, [{
           message: "Expected 'object', got '".concat(_typeof(src), "'")
@@ -1934,10 +2485,10 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
           message: "Expected 'object', got 'array'"
         }]);
       }
-      Object.entries(src).forEach(function (_ref3) {
-        var _ref4 = _slicedToArray(_ref3, 2),
-          key = _ref4[0],
-          elem = _ref4[1];
+      Object.entries(src).forEach(function (_ref4) {
+        var _ref5 = _slicedToArray(_ref4, 2),
+          key = _ref5[0],
+          elem = _ref5[1];
         var subPath = createValPathOfItem(path, key);
         if (!subPath) {
           error = _this2.appendValidationError(error, path, "Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at key ").concat(elem),
@@ -1956,21 +2507,35 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
       }
-      if (!src) {
-        return false;
+      if (_typeof(src) !== "object") {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
       }
-      for (var _i = 0, _Object$entries = Object.entries(src); _i < _Object$entries.length; _i++) {
-        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-          _item = _Object$entries$_i[1];
-        if (!this.item.assert(_item)) {
-          return false;
-        }
+      if (Array.isArray(src)) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'object', got 'array'",
+            typeError: true
+          }])
+        };
       }
-      return _typeof(src) === "object" && !Array.isArray(src);
+      return {
+        success: true,
+        data: src
+      };
     }
   }, {
     key: "nullable",
@@ -2038,7 +2603,9 @@ function isArraySchema(schema) {
 //   );
 // }
 
-function isUnionSchema(schema) {
+function isUnionSchema(schema
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
   return schema instanceof UnionSchema || _typeof(schema) === "object" && "type" in schema && schema.type === "union";
 }
 
@@ -2060,6 +2627,7 @@ function isImageSchema(schema) {
 // }
 
 function resolvePath(path, valModule, schema) {
+  // TODO: use schema assert while resolving (and emit errors if any)
   var parts = parsePath(path);
   var origParts = _toConsumableArray(parts);
   var resolvedSchema = schema;
@@ -2154,6 +2722,7 @@ function resolvePath(path, valModule, schema) {
         if (!keyValue) {
           throw Error("Invalid path: union source ".concat(resolvedSchema, " did not have required key ").concat(_key, " in path: ").concat(path));
         }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         var schemaOfUnionKey = resolvedSchema.items.find(
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         function (child) {
@@ -2265,11 +2834,35 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'number', got 'null'",
+            typeError: true
+          }])
+        };
+      }
+      if (typeof src === "number") {
+        return {
+          success: true,
+          data: src
+        };
       }
-      return typeof src === "number";
+      return {
+        success: false,
+        errors: _defineProperty({}, path, [{
+          message: "Expected 'number', got '".concat(_typeof(src), "'"),
+          typeError: true
+        }])
+      };
     }
   }, {
     key: "nullable",
@@ -2365,11 +2958,26 @@ var StringSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (typeof src === "string") {
+        return {
+          success: true,
+          data: src
+        };
       }
-      return typeof src === "string";
+      return {
+        success: false,
+        errors: _defineProperty({}, path, [{
+          message: "Expected 'string', got '".concat(_typeof(src), "'"),
+          typeError: true
+        }])
+      };
     }
   }, {
     key: "nullable",
@@ -2432,11 +3040,35 @@ var BooleanSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
       }
-      return typeof src === "boolean";
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'boolean', got 'null'",
+            typeError: true
+          }])
+        };
+      }
+      if (typeof src !== "boolean") {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'boolean', got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
+      }
+      return {
+        success: true,
+        data: src
+      };
     }
   }, {
     key: "nullable",
@@ -2512,34 +3144,79 @@ var KeyOfSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'string', got 'null'",
+            typeError: true
+          }])
+        };
       }
       var schema = this.schema;
       if (!schema) {
-        return false;
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Neither key nor schema was found. keyOf is missing an argument.",
+            typeError: true
+          }])
+        };
       }
       var serializedSchema = schema;
       if (!(serializedSchema.type === "array" || serializedSchema.type === "object" || serializedSchema.type === "record")) {
-        return false;
-      }
-      if (serializedSchema.opt && (src === null || src === undefined)) {
-        return true;
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Schema of first argument must be either: 'array', 'object' or 'record'. Found '".concat(serializedSchema.type, "'"),
+            typeError: true
+          }])
+        };
       }
       if (serializedSchema.type === "array" && typeof src !== "number") {
-        return false;
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Value of keyOf (array) must be 'number', got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
       }
       if (serializedSchema.type === "record" && typeof src !== "string") {
-        return false;
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Value of keyOf (record) must be 'string', got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
       }
+      // We check actual value here, since TypeScript also does this. Literals are used in other types (unions),
+      // and there it also makes sense to check the actual string values (i.e. that it is not just a string) since
+      // missing one would lead to a runtime error. At least this is what we are thinking currently.
       if (serializedSchema.type === "object") {
         var keys = Object.keys(serializedSchema.items);
         if (!keys.includes(src)) {
-          return false;
+          return {
+            success: false,
+            errors: _defineProperty({}, path, [{
+              message: "Value of keyOf (object) must be: ".concat(keys.join(", "), ". Found: ").concat(src),
+              typeError: true
+            }])
+          };
         }
       }
-      return true;
+      return {
+        success: true,
+        data: src
+      };
     }
   }, {
     key: "nullable",
@@ -2592,12 +3269,10 @@ var DateSchema = /*#__PURE__*/function (_Schema) {
   function DateSchema(options) {
     var _this;
     var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    var isRaw = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     _classCallCheck(this, DateSchema);
     _this = _callSuper(this, DateSchema);
     _this.options = options;
     _this.opt = opt;
-    _this.isRaw = isRaw;
     return _this;
   }
   _createClass(DateSchema, [{
@@ -2618,7 +3293,7 @@ var DateSchema = /*#__PURE__*/function (_Schema) {
           return _defineProperty({}, path, [{
             message: "From date ".concat(this.options.from, " is after to date ").concat(this.options.to),
             value: src,
-            fatal: true
+            typeError: true
           }]);
         }
         if (src < this.options.from || src > this.options.to) {
@@ -2653,30 +3328,54 @@ var DateSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "assert",
-    value: function assert(src) {
-      if (this.opt && (src === null || src === undefined)) {
-        return true;
+    value: function assert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'string', got 'null'",
+            typeError: true
+          }])
+        };
+      }
+      if (typeof src !== "string") {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'string', got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
       }
-      return typeof src === "string";
+      return {
+        success: true,
+        data: src
+      };
     }
   }, {
     key: "from",
     value: function from(_from) {
       return new DateSchema(_objectSpread2(_objectSpread2({}, this.options), {}, {
         from: _from
-      }), this.opt, this.isRaw);
+      }), this.opt);
     }
   }, {
     key: "to",
     value: function to(_to) {
       return new DateSchema(_objectSpread2(_objectSpread2({}, this.options), {}, {
         to: _to
-      }), this.opt, this.isRaw);
+      }), this.opt);
     }
   }, {
     key: "nullable",
     value: function nullable() {
-      return new DateSchema(this.options, true, this.isRaw);
+      return new DateSchema(this.options, true);
     }
   }, {
     key: "serialize",
@@ -3637,6 +4336,728 @@ var getSHA256Hash = function getSHA256Hash(bits) {
   return createHash().update(bits).digest("hex");
 };
 
+var EXT_TO_MIME_TYPES = {
+  x3d: "application/vnd.hzn-3d-crossword",
+  "3gp": "video/3gpp",
+  "3g2": "video/3gpp2",
+  mseq: "application/vnd.mseq",
+  pwn: "application/vnd.3m.post-it-notes",
+  plb: "application/vnd.3gpp.pic-bw-large",
+  psb: "application/vnd.3gpp.pic-bw-small",
+  pvb: "application/vnd.3gpp.pic-bw-var",
+  tcap: "application/vnd.3gpp2.tcap",
+  "7z": "application/x-7z-compressed",
+  abw: "application/x-abiword",
+  ace: "application/x-ace-compressed",
+  acc: "application/vnd.americandynamics.acc",
+  acu: "application/vnd.acucobol",
+  atc: "application/vnd.acucorp",
+  adp: "audio/adpcm",
+  aab: "application/x-authorware-bin",
+  aam: "application/x-authorware-map",
+  aas: "application/x-authorware-seg",
+  air: "application/vnd.adobe.air-application-installer-package+zip",
+  swf: "application/x-shockwave-flash",
+  fxp: "application/vnd.adobe.fxp",
+  pdf: "application/pdf",
+  ppd: "application/vnd.cups-ppd",
+  dir: "application/x-director",
+  xdp: "application/vnd.adobe.xdp+xml",
+  xfdf: "application/vnd.adobe.xfdf",
+  aac: "audio/x-aac",
+  ahead: "application/vnd.ahead.space",
+  azf: "application/vnd.airzip.filesecure.azf",
+  azs: "application/vnd.airzip.filesecure.azs",
+  azw: "application/vnd.amazon.ebook",
+  ami: "application/vnd.amiga.ami",
+  "N/A": "application/andrew-inset",
+  apk: "application/vnd.android.package-archive",
+  cii: "application/vnd.anser-web-certificate-issue-initiation",
+  fti: "application/vnd.anser-web-funds-transfer-initiation",
+  atx: "application/vnd.antix.game-component",
+  dmg: "application/x-apple-diskimage",
+  mpkg: "application/vnd.apple.installer+xml",
+  aw: "application/applixware",
+  mp3: "audio/mpeg",
+  les: "application/vnd.hhe.lesson-player",
+  swi: "application/vnd.aristanetworks.swi",
+  s: "text/x-asm",
+  atomcat: "application/atomcat+xml",
+  atomsvc: "application/atomsvc+xml",
+  atom: "application/atom+xml",
+  ac: "application/pkix-attr-cert",
+  aif: "audio/x-aiff",
+  avi: "video/x-msvideo",
+  aep: "application/vnd.audiograph",
+  dxf: "image/vnd.dxf",
+  dwf: "model/vnd.dwf",
+  par: "text/plain-bas",
+  bcpio: "application/x-bcpio",
+  bin: "application/octet-stream",
+  bmp: "image/bmp",
+  torrent: "application/x-bittorrent",
+  cod: "application/vnd.rim.cod",
+  mpm: "application/vnd.blueice.multipass",
+  bmi: "application/vnd.bmi",
+  sh: "application/x-sh",
+  btif: "image/prs.btif",
+  rep: "application/vnd.businessobjects",
+  bz: "application/x-bzip",
+  bz2: "application/x-bzip2",
+  csh: "application/x-csh",
+  c: "text/x-c",
+  cdxml: "application/vnd.chemdraw+xml",
+  css: "text/css",
+  cdx: "chemical/x-cdx",
+  cml: "chemical/x-cml",
+  csml: "chemical/x-csml",
+  cdbcmsg: "application/vnd.contact.cmsg",
+  cla: "application/vnd.claymore",
+  c4g: "application/vnd.clonk.c4group",
+  sub: "image/vnd.dvb.subtitle",
+  cdmia: "application/cdmi-capability",
+  cdmic: "application/cdmi-container",
+  cdmid: "application/cdmi-domain",
+  cdmio: "application/cdmi-object",
+  cdmiq: "application/cdmi-queue",
+  c11amc: "application/vnd.cluetrust.cartomobile-config",
+  c11amz: "application/vnd.cluetrust.cartomobile-config-pkg",
+  ras: "image/x-cmu-raster",
+  dae: "model/vnd.collada+xml",
+  csv: "text/csv",
+  cpt: "application/mac-compactpro",
+  wmlc: "application/vnd.wap.wmlc",
+  cgm: "image/cgm",
+  ice: "x-conference/x-cooltalk",
+  cmx: "image/x-cmx",
+  xar: "application/vnd.xara",
+  cmc: "application/vnd.cosmocaller",
+  cpio: "application/x-cpio",
+  clkx: "application/vnd.crick.clicker",
+  clkk: "application/vnd.crick.clicker.keyboard",
+  clkp: "application/vnd.crick.clicker.palette",
+  clkt: "application/vnd.crick.clicker.template",
+  clkw: "application/vnd.crick.clicker.wordbank",
+  wbs: "application/vnd.criticaltools.wbs+xml",
+  cryptonote: "application/vnd.rig.cryptonote",
+  cif: "chemical/x-cif",
+  cmdf: "chemical/x-cmdf",
+  cu: "application/cu-seeme",
+  cww: "application/prs.cww",
+  curl: "text/vnd.curl",
+  dcurl: "text/vnd.curl.dcurl",
+  mcurl: "text/vnd.curl.mcurl",
+  scurl: "text/vnd.curl.scurl",
+  car: "application/vnd.curl.car",
+  pcurl: "application/vnd.curl.pcurl",
+  cmp: "application/vnd.yellowriver-custom-menu",
+  dssc: "application/dssc+der",
+  xdssc: "application/dssc+xml",
+  deb: "application/x-debian-package",
+  uva: "audio/vnd.dece.audio",
+  uvi: "image/vnd.dece.graphic",
+  uvh: "video/vnd.dece.hd",
+  uvm: "video/vnd.dece.mobile",
+  uvu: "video/vnd.uvvu.mp4",
+  uvp: "video/vnd.dece.pd",
+  uvs: "video/vnd.dece.sd",
+  uvv: "video/vnd.dece.video",
+  dvi: "application/x-dvi",
+  seed: "application/vnd.fdsn.seed",
+  dtb: "application/x-dtbook+xml",
+  res: "application/x-dtbresource+xml",
+  ait: "application/vnd.dvb.ait",
+  svc: "application/vnd.dvb.service",
+  eol: "audio/vnd.digital-winds",
+  djvu: "image/vnd.djvu",
+  dtd: "application/xml-dtd",
+  mlp: "application/vnd.dolby.mlp",
+  wad: "application/x-doom",
+  dpg: "application/vnd.dpgraph",
+  dra: "audio/vnd.dra",
+  dfac: "application/vnd.dreamfactory",
+  dts: "audio/vnd.dts",
+  dtshd: "audio/vnd.dts.hd",
+  dwg: "image/vnd.dwg",
+  geo: "application/vnd.dynageo",
+  es: "application/ecmascript",
+  mag: "application/vnd.ecowin.chart",
+  mmr: "image/vnd.fujixerox.edmics-mmr",
+  rlc: "image/vnd.fujixerox.edmics-rlc",
+  exi: "application/exi",
+  mgz: "application/vnd.proteus.magazine",
+  epub: "application/epub+zip",
+  eml: "message/rfc822",
+  nml: "application/vnd.enliven",
+  xpr: "application/vnd.is-xpr",
+  xif: "image/vnd.xiff",
+  xfdl: "application/vnd.xfdl",
+  emma: "application/emma+xml",
+  ez2: "application/vnd.ezpix-album",
+  ez3: "application/vnd.ezpix-package",
+  fst: "image/vnd.fst",
+  fvt: "video/vnd.fvt",
+  fbs: "image/vnd.fastbidsheet",
+  fe_launch: "application/vnd.denovo.fcselayout-link",
+  f4v: "video/x-f4v",
+  flv: "video/x-flv",
+  fpx: "image/vnd.fpx",
+  npx: "image/vnd.net-fpx",
+  flx: "text/vnd.fmi.flexstor",
+  fli: "video/x-fli",
+  ftc: "application/vnd.fluxtime.clip",
+  fdf: "application/vnd.fdf",
+  f: "text/x-fortran",
+  mif: "application/vnd.mif",
+  fm: "application/vnd.framemaker",
+  fh: "image/x-freehand",
+  fsc: "application/vnd.fsc.weblaunch",
+  fnc: "application/vnd.frogans.fnc",
+  ltf: "application/vnd.frogans.ltf",
+  ddd: "application/vnd.fujixerox.ddd",
+  xdw: "application/vnd.fujixerox.docuworks",
+  xbd: "application/vnd.fujixerox.docuworks.binder",
+  oas: "application/vnd.fujitsu.oasys",
+  oa2: "application/vnd.fujitsu.oasys2",
+  oa3: "application/vnd.fujitsu.oasys3",
+  fg5: "application/vnd.fujitsu.oasysgp",
+  bh2: "application/vnd.fujitsu.oasysprs",
+  spl: "application/x-futuresplash",
+  fzs: "application/vnd.fuzzysheet",
+  g3: "image/g3fax",
+  gmx: "application/vnd.gmx",
+  gtw: "model/vnd.gtw",
+  txd: "application/vnd.genomatix.tuxedo",
+  ggb: "application/vnd.geogebra.file",
+  ggt: "application/vnd.geogebra.tool",
+  gdl: "model/vnd.gdl",
+  gex: "application/vnd.geometry-explorer",
+  gxt: "application/vnd.geonext",
+  g2w: "application/vnd.geoplan",
+  g3w: "application/vnd.geospace",
+  gsf: "application/x-font-ghostscript",
+  bdf: "application/x-font-bdf",
+  gtar: "application/x-gtar",
+  texinfo: "application/x-texinfo",
+  gnumeric: "application/x-gnumeric",
+  kml: "application/vnd.google-earth.kml+xml",
+  kmz: "application/vnd.google-earth.kmz",
+  gqf: "application/vnd.grafeq",
+  gif: "image/gif",
+  gv: "text/vnd.graphviz",
+  gac: "application/vnd.groove-account",
+  ghf: "application/vnd.groove-help",
+  gim: "application/vnd.groove-identity-message",
+  grv: "application/vnd.groove-injector",
+  gtm: "application/vnd.groove-tool-message",
+  tpl: "application/vnd.groove-tool-template",
+  vcg: "application/vnd.groove-vcard",
+  h261: "video/h261",
+  h263: "video/h263",
+  h264: "video/h264",
+  hpid: "application/vnd.hp-hpid",
+  hps: "application/vnd.hp-hps",
+  hdf: "application/x-hdf",
+  rip: "audio/vnd.rip",
+  hbci: "application/vnd.hbci",
+  jlt: "application/vnd.hp-jlyt",
+  pcl: "application/vnd.hp-pcl",
+  hpgl: "application/vnd.hp-hpgl",
+  hvs: "application/vnd.yamaha.hv-script",
+  hvd: "application/vnd.yamaha.hv-dic",
+  hvp: "application/vnd.yamaha.hv-voice",
+  "sfd-hdstx": "application/vnd.hydrostatix.sof-data",
+  stk: "application/hyperstudio",
+  hal: "application/vnd.hal+xml",
+  html: "text/html",
+  irm: "application/vnd.ibm.rights-management",
+  sc: "application/vnd.ibm.secure-container",
+  ics: "text/calendar",
+  icc: "application/vnd.iccprofile",
+  ico: "image/x-icon",
+  igl: "application/vnd.igloader",
+  ief: "image/ief",
+  ivp: "application/vnd.immervision-ivp",
+  ivu: "application/vnd.immervision-ivu",
+  rif: "application/reginfo+xml",
+  "3dml": "text/vnd.in3d.3dml",
+  spot: "text/vnd.in3d.spot",
+  igs: "model/iges",
+  i2g: "application/vnd.intergeo",
+  cdy: "application/vnd.cinderella",
+  xpw: "application/vnd.intercon.formnet",
+  fcs: "application/vnd.isac.fcs",
+  ipfix: "application/ipfix",
+  cer: "application/pkix-cert",
+  pki: "application/pkixcmp",
+  crl: "application/pkix-crl",
+  pkipath: "application/pkix-pkipath",
+  igm: "application/vnd.insors.igm",
+  rcprofile: "application/vnd.ipunplugged.rcprofile",
+  irp: "application/vnd.irepository.package+xml",
+  jad: "text/vnd.sun.j2me.app-descriptor",
+  jar: "application/java-archive",
+  "class": "application/java-vm",
+  jnlp: "application/x-java-jnlp-file",
+  ser: "application/java-serialized-object",
+  java: "text/x-java-source,java",
+  js: "application/javascript",
+  json: "application/json",
+  joda: "application/vnd.joost.joda-archive",
+  jpm: "video/jpm",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  pjpeg: "image/pjpeg",
+  jpgv: "video/jpeg",
+  ktz: "application/vnd.kahootz",
+  mmd: "application/vnd.chipnuts.karaoke-mmd",
+  karbon: "application/vnd.kde.karbon",
+  chrt: "application/vnd.kde.kchart",
+  kfo: "application/vnd.kde.kformula",
+  flw: "application/vnd.kde.kivio",
+  kon: "application/vnd.kde.kontour",
+  kpr: "application/vnd.kde.kpresenter",
+  ksp: "application/vnd.kde.kspread",
+  kwd: "application/vnd.kde.kword",
+  htke: "application/vnd.kenameaapp",
+  kia: "application/vnd.kidspiration",
+  kne: "application/vnd.kinar",
+  sse: "application/vnd.kodak-descriptor",
+  lasxml: "application/vnd.las.las+xml",
+  latex: "application/x-latex",
+  lbd: "application/vnd.llamagraphics.life-balance.desktop",
+  lbe: "application/vnd.llamagraphics.life-balance.exchange+xml",
+  jam: "application/vnd.jam",
+  "123": "application/vnd.lotus-1-2-3",
+  apr: "application/vnd.lotus-approach",
+  pre: "application/vnd.lotus-freelance",
+  nsf: "application/vnd.lotus-notes",
+  org: "application/vnd.lotus-organizer",
+  scm: "application/vnd.lotus-screencam",
+  lwp: "application/vnd.lotus-wordpro",
+  lvp: "audio/vnd.lucent.voice",
+  m3u: "audio/x-mpegurl",
+  m4v: "video/x-m4v",
+  hqx: "application/mac-binhex40",
+  portpkg: "application/vnd.macports.portpkg",
+  mgp: "application/vnd.osgeo.mapguide.package",
+  mrc: "application/marc",
+  mrcx: "application/marcxml+xml",
+  mxf: "application/mxf",
+  nbp: "application/vnd.wolfram.player",
+  ma: "application/mathematica",
+  mathml: "application/mathml+xml",
+  mbox: "application/mbox",
+  mc1: "application/vnd.medcalcdata",
+  mscml: "application/mediaservercontrol+xml",
+  cdkey: "application/vnd.mediastation.cdkey",
+  mwf: "application/vnd.mfer",
+  mfm: "application/vnd.mfmp",
+  msh: "model/mesh",
+  mads: "application/mads+xml",
+  mets: "application/mets+xml",
+  mods: "application/mods+xml",
+  meta4: "application/metalink4+xml",
+  mcd: "application/vnd.mcd",
+  flo: "application/vnd.micrografx.flo",
+  igx: "application/vnd.micrografx.igx",
+  es3: "application/vnd.eszigno3+xml",
+  mdb: "application/x-msaccess",
+  asf: "video/x-ms-asf",
+  exe: "application/x-msdownload",
+  cil: "application/vnd.ms-artgalry",
+  cab: "application/vnd.ms-cab-compressed",
+  ims: "application/vnd.ms-ims",
+  application: "application/x-ms-application",
+  clp: "application/x-msclip",
+  mdi: "image/vnd.ms-modi",
+  eot: "application/vnd.ms-fontobject",
+  xls: "application/vnd.ms-excel",
+  xlam: "application/vnd.ms-excel.addin.macroenabled.12",
+  xlsb: "application/vnd.ms-excel.sheet.binary.macroenabled.12",
+  xltm: "application/vnd.ms-excel.template.macroenabled.12",
+  xlsm: "application/vnd.ms-excel.sheet.macroenabled.12",
+  chm: "application/vnd.ms-htmlhelp",
+  crd: "application/x-mscardfile",
+  lrm: "application/vnd.ms-lrm",
+  mvb: "application/x-msmediaview",
+  mny: "application/x-msmoney",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  sldx: "application/vnd.openxmlformats-officedocument.presentationml.slide",
+  ppsx: "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+  potx: "application/vnd.openxmlformats-officedocument.presentationml.template",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  xltx: "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  dotx: "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
+  obd: "application/x-msbinder",
+  thmx: "application/vnd.ms-officetheme",
+  onetoc: "application/onenote",
+  pya: "audio/vnd.ms-playready.media.pya",
+  pyv: "video/vnd.ms-playready.media.pyv",
+  ppt: "application/vnd.ms-powerpoint",
+  ppam: "application/vnd.ms-powerpoint.addin.macroenabled.12",
+  sldm: "application/vnd.ms-powerpoint.slide.macroenabled.12",
+  pptm: "application/vnd.ms-powerpoint.presentation.macroenabled.12",
+  ppsm: "application/vnd.ms-powerpoint.slideshow.macroenabled.12",
+  potm: "application/vnd.ms-powerpoint.template.macroenabled.12",
+  mpp: "application/vnd.ms-project",
+  pub: "application/x-mspublisher",
+  scd: "application/x-msschedule",
+  xap: "application/x-silverlight-app",
+  stl: "application/vnd.ms-pki.stl",
+  cat: "application/vnd.ms-pki.seccat",
+  vsd: "application/vnd.visio",
+  vsdx: "application/vnd.visio2013",
+  wm: "video/x-ms-wm",
+  wma: "audio/x-ms-wma",
+  wax: "audio/x-ms-wax",
+  wmx: "video/x-ms-wmx",
+  wmd: "application/x-ms-wmd",
+  wpl: "application/vnd.ms-wpl",
+  wmz: "application/x-ms-wmz",
+  wmv: "video/x-ms-wmv",
+  wvx: "video/x-ms-wvx",
+  wmf: "application/x-msmetafile",
+  trm: "application/x-msterminal",
+  doc: "application/msword",
+  docm: "application/vnd.ms-word.document.macroenabled.12",
+  dotm: "application/vnd.ms-word.template.macroenabled.12",
+  wri: "application/x-mswrite",
+  wps: "application/vnd.ms-works",
+  xbap: "application/x-ms-xbap",
+  xps: "application/vnd.ms-xpsdocument",
+  mid: "audio/midi",
+  mpy: "application/vnd.ibm.minipay",
+  afp: "application/vnd.ibm.modcap",
+  rms: "application/vnd.jcp.javame.midlet-rms",
+  tmo: "application/vnd.tmobile-livetv",
+  prc: "application/x-mobipocket-ebook",
+  mbk: "application/vnd.mobius.mbk",
+  dis: "application/vnd.mobius.dis",
+  plc: "application/vnd.mobius.plc",
+  mqy: "application/vnd.mobius.mqy",
+  msl: "application/vnd.mobius.msl",
+  txf: "application/vnd.mobius.txf",
+  daf: "application/vnd.mobius.daf",
+  fly: "text/vnd.fly",
+  mpc: "application/vnd.mophun.certificate",
+  mpn: "application/vnd.mophun.application",
+  mj2: "video/mj2",
+  mpga: "audio/mpeg",
+  mxu: "video/vnd.mpegurl",
+  mpeg: "video/mpeg",
+  m21: "application/mp21",
+  mp4a: "audio/mp4",
+  mp4: "video/mp4",
+  m3u8: "application/vnd.apple.mpegurl",
+  mus: "application/vnd.musician",
+  msty: "application/vnd.muvee.style",
+  mxml: "application/xv+xml",
+  ngdat: "application/vnd.nokia.n-gage.data",
+  "n-gage": "application/vnd.nokia.n-gage.symbian.install",
+  ncx: "application/x-dtbncx+xml",
+  nc: "application/x-netcdf",
+  nlu: "application/vnd.neurolanguage.nlu",
+  dna: "application/vnd.dna",
+  nnd: "application/vnd.noblenet-directory",
+  nns: "application/vnd.noblenet-sealer",
+  nnw: "application/vnd.noblenet-web",
+  rpst: "application/vnd.nokia.radio-preset",
+  rpss: "application/vnd.nokia.radio-presets",
+  n3: "text/n3",
+  edm: "application/vnd.novadigm.edm",
+  edx: "application/vnd.novadigm.edx",
+  ext: "application/vnd.novadigm.ext",
+  gph: "application/vnd.flographit",
+  ecelp4800: "audio/vnd.nuera.ecelp4800",
+  ecelp7470: "audio/vnd.nuera.ecelp7470",
+  ecelp9600: "audio/vnd.nuera.ecelp9600",
+  oda: "application/oda",
+  ogx: "application/ogg",
+  oga: "audio/ogg",
+  ogv: "video/ogg",
+  dd2: "application/vnd.oma.dd2+xml",
+  oth: "application/vnd.oasis.opendocument.text-web",
+  opf: "application/oebps-package+xml",
+  qbo: "application/vnd.intu.qbo",
+  oxt: "application/vnd.openofficeorg.extension",
+  osf: "application/vnd.yamaha.openscoreformat",
+  weba: "audio/webm",
+  webm: "video/webm",
+  odc: "application/vnd.oasis.opendocument.chart",
+  otc: "application/vnd.oasis.opendocument.chart-template",
+  odb: "application/vnd.oasis.opendocument.database",
+  odf: "application/vnd.oasis.opendocument.formula",
+  odft: "application/vnd.oasis.opendocument.formula-template",
+  odg: "application/vnd.oasis.opendocument.graphics",
+  otg: "application/vnd.oasis.opendocument.graphics-template",
+  odi: "application/vnd.oasis.opendocument.image",
+  oti: "application/vnd.oasis.opendocument.image-template",
+  odp: "application/vnd.oasis.opendocument.presentation",
+  otp: "application/vnd.oasis.opendocument.presentation-template",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  ots: "application/vnd.oasis.opendocument.spreadsheet-template",
+  odt: "application/vnd.oasis.opendocument.text",
+  odm: "application/vnd.oasis.opendocument.text-master",
+  ott: "application/vnd.oasis.opendocument.text-template",
+  ktx: "image/ktx",
+  sxc: "application/vnd.sun.xml.calc",
+  stc: "application/vnd.sun.xml.calc.template",
+  sxd: "application/vnd.sun.xml.draw",
+  std: "application/vnd.sun.xml.draw.template",
+  sxi: "application/vnd.sun.xml.impress",
+  sti: "application/vnd.sun.xml.impress.template",
+  sxm: "application/vnd.sun.xml.math",
+  sxw: "application/vnd.sun.xml.writer",
+  sxg: "application/vnd.sun.xml.writer.global",
+  stw: "application/vnd.sun.xml.writer.template",
+  otf: "application/x-font-otf",
+  osfpvg: "application/vnd.yamaha.openscoreformat.osfpvg+xml",
+  dp: "application/vnd.osgi.dp",
+  pdb: "application/vnd.palm",
+  p: "text/x-pascal",
+  paw: "application/vnd.pawaafile",
+  pclxl: "application/vnd.hp-pclxl",
+  efif: "application/vnd.picsel",
+  pcx: "image/x-pcx",
+  psd: "image/vnd.adobe.photoshop",
+  prf: "application/pics-rules",
+  pic: "image/x-pict",
+  chat: "application/x-chat",
+  p10: "application/pkcs10",
+  p12: "application/x-pkcs12",
+  p7m: "application/pkcs7-mime",
+  p7s: "application/pkcs7-signature",
+  p7r: "application/x-pkcs7-certreqresp",
+  p7b: "application/x-pkcs7-certificates",
+  p8: "application/pkcs8",
+  plf: "application/vnd.pocketlearn",
+  pnm: "image/x-portable-anymap",
+  pbm: "image/x-portable-bitmap",
+  pcf: "application/x-font-pcf",
+  pfr: "application/font-tdpfr",
+  pgn: "application/x-chess-pgn",
+  pgm: "image/x-portable-graymap",
+  png: "image/png",
+  ppm: "image/x-portable-pixmap",
+  pskcxml: "application/pskc+xml",
+  pml: "application/vnd.ctc-posml",
+  ai: "application/postscript",
+  pfa: "application/x-font-type1",
+  pbd: "application/vnd.powerbuilder6",
+  pgp: "application/pgp-signature",
+  box: "application/vnd.previewsystems.box",
+  ptid: "application/vnd.pvi.ptid1",
+  pls: "application/pls+xml",
+  str: "application/vnd.pg.format",
+  ei6: "application/vnd.pg.osasli",
+  dsc: "text/prs.lines.tag",
+  psf: "application/x-font-linux-psf",
+  qps: "application/vnd.publishare-delta-tree",
+  wg: "application/vnd.pmi.widget",
+  qxd: "application/vnd.quark.quarkxpress",
+  esf: "application/vnd.epson.esf",
+  msf: "application/vnd.epson.msf",
+  ssf: "application/vnd.epson.ssf",
+  qam: "application/vnd.epson.quickanime",
+  qfx: "application/vnd.intu.qfx",
+  qt: "video/quicktime",
+  rar: "application/x-rar-compressed",
+  ram: "audio/x-pn-realaudio",
+  rmp: "audio/x-pn-realaudio-plugin",
+  rsd: "application/rsd+xml",
+  rm: "application/vnd.rn-realmedia",
+  bed: "application/vnd.realvnc.bed",
+  mxl: "application/vnd.recordare.musicxml",
+  musicxml: "application/vnd.recordare.musicxml+xml",
+  rnc: "application/relax-ng-compact-syntax",
+  rdz: "application/vnd.data-vision.rdz",
+  rdf: "application/rdf+xml",
+  rp9: "application/vnd.cloanto.rp9",
+  jisp: "application/vnd.jisp",
+  rtf: "application/rtf",
+  rtx: "text/richtext",
+  link66: "application/vnd.route66.link66+xml",
+  rss: "application/rss+xml",
+  shf: "application/shf+xml",
+  st: "application/vnd.sailingtracker.track",
+  svg: "image/svg+xml",
+  sus: "application/vnd.sus-calendar",
+  sru: "application/sru+xml",
+  setpay: "application/set-payment-initiation",
+  setreg: "application/set-registration-initiation",
+  sema: "application/vnd.sema",
+  semd: "application/vnd.semd",
+  semf: "application/vnd.semf",
+  see: "application/vnd.seemail",
+  snf: "application/x-font-snf",
+  spq: "application/scvp-vp-request",
+  spp: "application/scvp-vp-response",
+  scq: "application/scvp-cv-request",
+  scs: "application/scvp-cv-response",
+  sdp: "application/sdp",
+  etx: "text/x-setext",
+  movie: "video/x-sgi-movie",
+  ifm: "application/vnd.shana.informed.formdata",
+  itp: "application/vnd.shana.informed.formtemplate",
+  iif: "application/vnd.shana.informed.interchange",
+  ipk: "application/vnd.shana.informed.package",
+  tfi: "application/thraud+xml",
+  shar: "application/x-shar",
+  rgb: "image/x-rgb",
+  slt: "application/vnd.epson.salt",
+  aso: "application/vnd.accpac.simply.aso",
+  imp: "application/vnd.accpac.simply.imp",
+  twd: "application/vnd.simtech-mindmapper",
+  csp: "application/vnd.commonspace",
+  saf: "application/vnd.yamaha.smaf-audio",
+  mmf: "application/vnd.smaf",
+  spf: "application/vnd.yamaha.smaf-phrase",
+  teacher: "application/vnd.smart.teacher",
+  svd: "application/vnd.svd",
+  rq: "application/sparql-query",
+  srx: "application/sparql-results+xml",
+  gram: "application/srgs",
+  grxml: "application/srgs+xml",
+  ssml: "application/ssml+xml",
+  skp: "application/vnd.koan",
+  sgml: "text/sgml",
+  sdc: "application/vnd.stardivision.calc",
+  sda: "application/vnd.stardivision.draw",
+  sdd: "application/vnd.stardivision.impress",
+  smf: "application/vnd.stardivision.math",
+  sdw: "application/vnd.stardivision.writer",
+  sgl: "application/vnd.stardivision.writer-global",
+  sm: "application/vnd.stepmania.stepchart",
+  sit: "application/x-stuffit",
+  sitx: "application/x-stuffitx",
+  sdkm: "application/vnd.solent.sdkm+xml",
+  xo: "application/vnd.olpc-sugar",
+  au: "audio/basic",
+  wqd: "application/vnd.wqd",
+  sis: "application/vnd.symbian.install",
+  smi: "application/smil+xml",
+  xsm: "application/vnd.syncml+xml",
+  bdm: "application/vnd.syncml.dm+wbxml",
+  xdm: "application/vnd.syncml.dm+xml",
+  sv4cpio: "application/x-sv4cpio",
+  sv4crc: "application/x-sv4crc",
+  sbml: "application/sbml+xml",
+  tsv: "text/tab-separated-values",
+  tiff: "image/tiff",
+  tao: "application/vnd.tao.intent-module-archive",
+  tar: "application/x-tar",
+  tcl: "application/x-tcl",
+  tex: "application/x-tex",
+  tfm: "application/x-tex-tfm",
+  tei: "application/tei+xml",
+  txt: "text/plain",
+  dxp: "application/vnd.spotfire.dxp",
+  sfs: "application/vnd.spotfire.sfs",
+  tsd: "application/timestamped-data",
+  tpt: "application/vnd.trid.tpt",
+  mxs: "application/vnd.triscape.mxs",
+  t: "text/troff",
+  tra: "application/vnd.trueapp",
+  ttf: "application/x-font-ttf",
+  ttl: "text/turtle",
+  umj: "application/vnd.umajin",
+  uoml: "application/vnd.uoml+xml",
+  unityweb: "application/vnd.unity",
+  ufd: "application/vnd.ufdl",
+  uri: "text/uri-list",
+  utz: "application/vnd.uiq.theme",
+  ustar: "application/x-ustar",
+  uu: "text/x-uuencode",
+  vcs: "text/x-vcalendar",
+  vcf: "text/x-vcard",
+  vcd: "application/x-cdlink",
+  vsf: "application/vnd.vsf",
+  wrl: "model/vrml",
+  vcx: "application/vnd.vcx",
+  mts: "model/vnd.mts",
+  vtu: "model/vnd.vtu",
+  vis: "application/vnd.visionary",
+  viv: "video/vnd.vivo",
+  ccxml: "application/ccxml+xml,",
+  vxml: "application/voicexml+xml",
+  src: "application/x-wais-source",
+  wbxml: "application/vnd.wap.wbxml",
+  wbmp: "image/vnd.wap.wbmp",
+  wav: "audio/x-wav",
+  davmount: "application/davmount+xml",
+  woff: "application/x-font-woff",
+  wspolicy: "application/wspolicy+xml",
+  webp: "image/webp",
+  wtb: "application/vnd.webturbo",
+  wgt: "application/widget",
+  hlp: "application/winhlp",
+  wml: "text/vnd.wap.wml",
+  wmls: "text/vnd.wap.wmlscript",
+  wmlsc: "application/vnd.wap.wmlscriptc",
+  wpd: "application/vnd.wordperfect",
+  stf: "application/vnd.wt.stf",
+  wsdl: "application/wsdl+xml",
+  xbm: "image/x-xbitmap",
+  xpm: "image/x-xpixmap",
+  xwd: "image/x-xwindowdump",
+  der: "application/x-x509-ca-cert",
+  fig: "application/x-xfig",
+  xhtml: "application/xhtml+xml",
+  xml: "application/xml",
+  xdf: "application/xcap-diff+xml",
+  xenc: "application/xenc+xml",
+  xer: "application/patch-ops-error+xml",
+  rl: "application/resource-lists+xml",
+  rs: "application/rls-services+xml",
+  rld: "application/resource-lists-diff+xml",
+  xslt: "application/xslt+xml",
+  xop: "application/xop+xml",
+  xpi: "application/x-xpinstall",
+  xspf: "application/xspf+xml",
+  xul: "application/vnd.mozilla.xul+xml",
+  xyz: "chemical/x-xyz",
+  yaml: "text/yaml",
+  yang: "application/yang",
+  yin: "application/yin+xml",
+  zir: "application/vnd.zul",
+  zip: "application/zip",
+  zmm: "application/vnd.handheld-entertainment+xml",
+  zaz: "application/vnd.zzazz.deck+xml"
+};
+
+// TODO: write this out to avoid compute
+var MIME_TYPES_TO_EXT = Object.fromEntries(Object.entries(EXT_TO_MIME_TYPES).map(function (_ref) {
+  var _ref2 = _slicedToArray(_ref, 2),
+    k = _ref2[0],
+    v = _ref2[1];
+  return [v, k];
+}));
+
+var MIME_TYPE_REGEX = /^data:(.*?);base64,/;
+function getMimeType(base64Url) {
+  var match = MIME_TYPE_REGEX.exec(base64Url);
+  if (match && match[1]) {
+    return match[1];
+  }
+  return;
+}
+function mimeTypeToFileExt(mimeType) {
+  var recognizedMimeType = MIME_TYPES_TO_EXT[mimeType];
+  if (recognizedMimeType) {
+    return recognizedMimeType;
+  }
+  return mimeType.split("/")[1];
+}
+function filenameToMimeType(filename) {
+  var ext = filename.split(".").pop();
+  var recognizedExt = ext && EXT_TO_MIME_TYPES[ext];
+  if (recognizedExt) {
+    return recognizedExt;
+  }
+}
+
 function deserializeSchema(serialized) {
   var _serialized$options;
   switch (serialized.type) {
@@ -3660,9 +5081,16 @@ function deserializeSchema(serialized) {
     case "array":
       return new ArraySchema(deserializeSchema(serialized.item), serialized.opt);
     case "union":
-      return new UnionSchema(typeof serialized.key === "string" ? serialized.key : deserializeSchema(serialized.key), serialized.items.map(deserializeSchema), serialized.opt);
+      return new UnionSchema(typeof serialized.key === "string" ? serialized.key :
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      deserializeSchema(serialized.key),
+      // TODO: we do not really need any here - right?
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      serialized.items.map(deserializeSchema),
+      // TODO: we do not really need any here - right?
+      serialized.opt);
     case "richtext":
-      return new RichTextSchema(serialized.options, serialized.opt);
+      return new RichTextSchema(serialized.options || {}, serialized.opt);
     case "record":
       return new RecordSchema(deserializeSchema(serialized.item), serialized.opt);
     case "keyOf":
@@ -3686,671 +5114,6 @@ function deserializeSchema(serialized) {
   }
 }
 
-function _regeneratorRuntime() {
-  _regeneratorRuntime = function () {
-    return e;
-  };
-  var t,
-    e = {},
-    r = Object.prototype,
-    n = r.hasOwnProperty,
-    o = Object.defineProperty || function (t, e, r) {
-      t[e] = r.value;
-    },
-    i = "function" == typeof Symbol ? Symbol : {},
-    a = i.iterator || "@@iterator",
-    c = i.asyncIterator || "@@asyncIterator",
-    u = i.toStringTag || "@@toStringTag";
-  function define(t, e, r) {
-    return Object.defineProperty(t, e, {
-      value: r,
-      enumerable: !0,
-      configurable: !0,
-      writable: !0
-    }), t[e];
-  }
-  try {
-    define({}, "");
-  } catch (t) {
-    define = function (t, e, r) {
-      return t[e] = r;
-    };
-  }
-  function wrap(t, e, r, n) {
-    var i = e && e.prototype instanceof Generator ? e : Generator,
-      a = Object.create(i.prototype),
-      c = new Context(n || []);
-    return o(a, "_invoke", {
-      value: makeInvokeMethod(t, r, c)
-    }), a;
-  }
-  function tryCatch(t, e, r) {
-    try {
-      return {
-        type: "normal",
-        arg: t.call(e, r)
-      };
-    } catch (t) {
-      return {
-        type: "throw",
-        arg: t
-      };
-    }
-  }
-  e.wrap = wrap;
-  var h = "suspendedStart",
-    l = "suspendedYield",
-    f = "executing",
-    s = "completed",
-    y = {};
-  function Generator() {}
-  function GeneratorFunction() {}
-  function GeneratorFunctionPrototype() {}
-  var p = {};
-  define(p, a, function () {
-    return this;
-  });
-  var d = Object.getPrototypeOf,
-    v = d && d(d(values([])));
-  v && v !== r && n.call(v, a) && (p = v);
-  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
-  function defineIteratorMethods(t) {
-    ["next", "throw", "return"].forEach(function (e) {
-      define(t, e, function (t) {
-        return this._invoke(e, t);
-      });
-    });
-  }
-  function AsyncIterator(t, e) {
-    function invoke(r, o, i, a) {
-      var c = tryCatch(t[r], t, o);
-      if ("throw" !== c.type) {
-        var u = c.arg,
-          h = u.value;
-        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
-          invoke("next", t, i, a);
-        }, function (t) {
-          invoke("throw", t, i, a);
-        }) : e.resolve(h).then(function (t) {
-          u.value = t, i(u);
-        }, function (t) {
-          return invoke("throw", t, i, a);
-        });
-      }
-      a(c.arg);
-    }
-    var r;
-    o(this, "_invoke", {
-      value: function (t, n) {
-        function callInvokeWithMethodAndArg() {
-          return new e(function (e, r) {
-            invoke(t, n, e, r);
-          });
-        }
-        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-      }
-    });
-  }
-  function makeInvokeMethod(e, r, n) {
-    var o = h;
-    return function (i, a) {
-      if (o === f) throw new Error("Generator is already running");
-      if (o === s) {
-        if ("throw" === i) throw a;
-        return {
-          value: t,
-          done: !0
-        };
-      }
-      for (n.method = i, n.arg = a;;) {
-        var c = n.delegate;
-        if (c) {
-          var u = maybeInvokeDelegate(c, n);
-          if (u) {
-            if (u === y) continue;
-            return u;
-          }
-        }
-        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
-          if (o === h) throw o = s, n.arg;
-          n.dispatchException(n.arg);
-        } else "return" === n.method && n.abrupt("return", n.arg);
-        o = f;
-        var p = tryCatch(e, r, n);
-        if ("normal" === p.type) {
-          if (o = n.done ? s : l, p.arg === y) continue;
-          return {
-            value: p.arg,
-            done: n.done
-          };
-        }
-        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
-      }
-    };
-  }
-  function maybeInvokeDelegate(e, r) {
-    var n = r.method,
-      o = e.iterator[n];
-    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
-    var i = tryCatch(o, e.iterator, r.arg);
-    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
-    var a = i.arg;
-    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
-  }
-  function pushTryEntry(t) {
-    var e = {
-      tryLoc: t[0]
-    };
-    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
-  }
-  function resetTryEntry(t) {
-    var e = t.completion || {};
-    e.type = "normal", delete e.arg, t.completion = e;
-  }
-  function Context(t) {
-    this.tryEntries = [{
-      tryLoc: "root"
-    }], t.forEach(pushTryEntry, this), this.reset(!0);
-  }
-  function values(e) {
-    if (e || "" === e) {
-      var r = e[a];
-      if (r) return r.call(e);
-      if ("function" == typeof e.next) return e;
-      if (!isNaN(e.length)) {
-        var o = -1,
-          i = function next() {
-            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
-            return next.value = t, next.done = !0, next;
-          };
-        return i.next = i;
-      }
-    }
-    throw new TypeError(typeof e + " is not iterable");
-  }
-  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
-    value: GeneratorFunctionPrototype,
-    configurable: !0
-  }), o(GeneratorFunctionPrototype, "constructor", {
-    value: GeneratorFunction,
-    configurable: !0
-  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
-    var e = "function" == typeof t && t.constructor;
-    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
-  }, e.mark = function (t) {
-    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
-  }, e.awrap = function (t) {
-    return {
-      __await: t
-    };
-  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
-    return this;
-  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
-    void 0 === i && (i = Promise);
-    var a = new AsyncIterator(wrap(t, r, n, o), i);
-    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
-      return t.done ? t.value : a.next();
-    });
-  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
-    return this;
-  }), define(g, "toString", function () {
-    return "[object Generator]";
-  }), e.keys = function (t) {
-    var e = Object(t),
-      r = [];
-    for (var n in e) r.push(n);
-    return r.reverse(), function next() {
-      for (; r.length;) {
-        var t = r.pop();
-        if (t in e) return next.value = t, next.done = !1, next;
-      }
-      return next.done = !0, next;
-    };
-  }, e.values = values, Context.prototype = {
-    constructor: Context,
-    reset: function (e) {
-      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
-    },
-    stop: function () {
-      this.done = !0;
-      var t = this.tryEntries[0].completion;
-      if ("throw" === t.type) throw t.arg;
-      return this.rval;
-    },
-    dispatchException: function (e) {
-      if (this.done) throw e;
-      var r = this;
-      function handle(n, o) {
-        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
-      }
-      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
-        var i = this.tryEntries[o],
-          a = i.completion;
-        if ("root" === i.tryLoc) return handle("end");
-        if (i.tryLoc <= this.prev) {
-          var c = n.call(i, "catchLoc"),
-            u = n.call(i, "finallyLoc");
-          if (c && u) {
-            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-          } else if (c) {
-            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-          } else {
-            if (!u) throw new Error("try statement without catch or finally");
-            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-          }
-        }
-      }
-    },
-    abrupt: function (t, e) {
-      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
-        var o = this.tryEntries[r];
-        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
-          var i = o;
-          break;
-        }
-      }
-      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
-      var a = i ? i.completion : {};
-      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
-    },
-    complete: function (t, e) {
-      if ("throw" === t.type) throw t.arg;
-      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
-    },
-    finish: function (t) {
-      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-        var r = this.tryEntries[e];
-        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
-      }
-    },
-    catch: function (t) {
-      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-        var r = this.tryEntries[e];
-        if (r.tryLoc === t) {
-          var n = r.completion;
-          if ("throw" === n.type) {
-            var o = n.arg;
-            resetTryEntry(r);
-          }
-          return o;
-        }
-      }
-      throw new Error("illegal catch attempt");
-    },
-    delegateYield: function (e, r, n) {
-      return this.delegate = {
-        iterator: values(e),
-        resultName: r,
-        nextLoc: n
-      }, "next" === this.method && (this.arg = t), y;
-    }
-  }, e;
-}
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
-}
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-      args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-      _next(undefined);
-    });
-  };
-}
-
-// TODO: move this to internal, only reason this is here is that react, ui and server all depend on it
-var ValApi = /*#__PURE__*/function () {
-  function ValApi(host) {
-    _classCallCheck(this, ValApi);
-    this.host = host;
-  }
-  _createClass(ValApi, [{
-    key: "getDisableUrl",
-    value: function getDisableUrl(redirectTo) {
-      return "".concat(this.host, "/disable?redirect_to=").concat(encodeURIComponent(redirectTo));
-    }
-  }, {
-    key: "getLoginUrl",
-    value: function getLoginUrl(redirectTo) {
-      return "".concat(this.host, "/authorize?redirect_to=").concat(encodeURIComponent(redirectTo));
-    }
-  }, {
-    key: "getEnableUrl",
-    value: function getEnableUrl(redirectTo) {
-      return "".concat(this.host, "/enable?redirect_to=").concat(encodeURIComponent(redirectTo));
-    }
-  }, {
-    key: "getPatches",
-    value: function () {
-      var _getPatches = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(filters) {
-        var params, _iterator, _step, patchId, _iterator2, _step2, author, _iterator3, _step3, moduleFilePath, searchParams;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              params = [];
-              if (filters) {
-                if (filters.patchIds) {
-                  _iterator = result._createForOfIteratorHelper(filters.patchIds);
-                  try {
-                    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                      patchId = _step.value;
-                      params.push(["patch_id", patchId]);
-                    }
-                  } catch (err) {
-                    _iterator.e(err);
-                  } finally {
-                    _iterator.f();
-                  }
-                }
-                if (filters.authors) {
-                  _iterator2 = result._createForOfIteratorHelper(filters.authors);
-                  try {
-                    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                      author = _step2.value;
-                      params.push(["author", author]);
-                    }
-                  } catch (err) {
-                    _iterator2.e(err);
-                  } finally {
-                    _iterator2.f();
-                  }
-                }
-                if (filters.moduleFilePaths) {
-                  _iterator3 = result._createForOfIteratorHelper(filters.moduleFilePaths);
-                  try {
-                    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-                      moduleFilePath = _step3.value;
-                      params.push(["module_file_path", moduleFilePath]);
-                    }
-                  } catch (err) {
-                    _iterator3.e(err);
-                  } finally {
-                    _iterator3.f();
-                  }
-                }
-                if (filters.omitPatches) {
-                  params.push(["omit_patches", "true"]);
-                }
-              }
-              searchParams = new URLSearchParams(params);
-              return _context.abrupt("return", fetch("".concat(this.host, "/patches/~").concat(searchParams.size > 0 ? "?".concat(searchParams.toString()) : ""), {
-                headers: {
-                  "Content-Type": "application/json"
-                }
-              }).then(function (res) {
-                return parse(res);
-              })["catch"](createError));
-            case 4:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function getPatches(_x) {
-        return _getPatches.apply(this, arguments);
-      }
-      return getPatches;
-    }()
-  }, {
-    key: "deletePatches",
-    value: function () {
-      var _deletePatches = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(ids, headers) {
-        var params;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              params = new URLSearchParams();
-              ids.forEach(function (id) {
-                return params.append("id", id);
-              });
-              return _context2.abrupt("return", fetch("".concat(this.host, "/patches/~?").concat(params), {
-                method: "DELETE",
-                headers: headers || {
-                  "Content-Type": "application/json"
-                }
-              }).then(function (res) {
-                return parse(res);
-              })["catch"](createError));
-            case 3:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function deletePatches(_x2, _x3) {
-        return _deletePatches.apply(this, arguments);
-      }
-      return deletePatches;
-    }()
-  }, {
-    key: "getEditUrl",
-    value: function getEditUrl() {
-      // TODO: make route configurable
-      return "/val/~";
-    }
-  }, {
-    key: "getSession",
-    value: function getSession() {
-      return fetch("".concat(this.host, "/session")).then(function (res) {
-        return parse(res)["catch"](createError);
-      });
-    }
-  }, {
-    key: "getSchema",
-    value: function getSchema(_ref) {
-      var headers = _ref.headers;
-      return fetch("".concat(this.host, "/schema"), {
-        method: "GET",
-        headers: headers
-      }).then(function (res) {
-        return parse(res);
-      })["catch"](createError);
-    }
-  }, {
-    key: "putTree",
-    value: function putTree(_ref2) {
-      var _ref2$treePath = _ref2.treePath,
-        treePath = _ref2$treePath === void 0 ? "/" : _ref2$treePath,
-        patchIds = _ref2.patchIds,
-        addPatch = _ref2.addPatch,
-        validateAll = _ref2.validateAll,
-        validateSource = _ref2.validateSource,
-        validateBinaryFiles = _ref2.validateBinaryFiles,
-        headers = _ref2.headers;
-      var params = new URLSearchParams();
-      var textEncoder = new TextEncoder();
-      var patchesSha = getSHA256Hash(textEncoder.encode((patchIds || []).concat(JSON.stringify(addPatch || {})).join(";")));
-      params.set("patches_sha", patchesSha);
-      params.set("validate_all", (validateAll || false).toString());
-      params.set("validate_source", (validateSource || false).toString());
-      params.set("validate_binary_files", (validateBinaryFiles || false).toString());
-      return fetch("".concat(this.host, "/tree/~").concat(treePath, "?").concat(params.toString()), {
-        method: "PUT",
-        body: JSON.stringify({
-          patchIds: patchIds,
-          addPatch: addPatch
-        }),
-        headers: headers
-      }).then(function (res) {
-        return parse(res);
-      })["catch"](createError);
-    }
-  }, {
-    key: "postSave",
-    value: function postSave(_ref3) {
-      var patchIds = _ref3.patchIds;
-      return fetch("".concat(this.host, "/save"), {
-        method: "POST",
-        body: JSON.stringify({
-          patchIds: patchIds
-        }),
-        headers: {
-          "Content-Type": "application/json"
-        }
-      }).then( /*#__PURE__*/function () {
-        var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(res) {
-          var jsonRes;
-          return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-            while (1) switch (_context3.prev = _context3.next) {
-              case 0:
-                if (!res.ok) {
-                  _context3.next = 4;
-                  break;
-                }
-                return _context3.abrupt("return", parse(res));
-              case 4:
-                if (!(res.status === 400 && res.headers.get("content-type") === "application/json")) {
-                  _context3.next = 9;
-                  break;
-                }
-                _context3.next = 7;
-                return res.json();
-              case 7:
-                jsonRes = _context3.sent;
-                alert(JSON.stringify(jsonRes));
-              case 9:
-                return _context3.abrupt("return", parse(res));
-              case 10:
-              case "end":
-                return _context3.stop();
-            }
-          }, _callee3);
-        }));
-        return function (_x4) {
-          return _ref4.apply(this, arguments);
-        };
-      }())["catch"](createError);
-    }
-  }, {
-    key: "postValidate",
-    value: function postValidate(_ref5) {
-      var patches = _ref5.patches,
-        headers = _ref5.headers;
-      return fetch("".concat(this.host, "/validate"), {
-        method: "POST",
-        body: JSON.stringify({
-          patches: patches
-        }),
-        headers: headers || {
-          "Content-Type": "application/json"
-        }
-      }).then( /*#__PURE__*/function () {
-        var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(res) {
-          return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-            while (1) switch (_context4.prev = _context4.next) {
-              case 0:
-                return _context4.abrupt("return", parse(res));
-              case 1:
-              case "end":
-                return _context4.stop();
-            }
-          }, _callee4);
-        }));
-        return function (_x5) {
-          return _ref6.apply(this, arguments);
-        };
-      }())["catch"](createError);
-    }
-  }]);
-  return ValApi;
-}();
-function createError(err) {
-  return result.err({
-    statusCode: 500,
-    message: err instanceof Error ? err.message : _typeof(err) === "object" && err && "message" in err && typeof err.message === "string" ? err.message : "Unknown error",
-    details: _typeof(err) === "object" && err && "details" in err ? err.details : undefined
-  });
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function formatError(status, json, statusText) {
-  return result.err({
-    statusCode: status,
-    message: json.message || statusText,
-    details: json.details || Object.fromEntries(Object.entries(json).filter(function (_ref7) {
-      var _ref8 = _slicedToArray(_ref7, 1),
-        key = _ref8[0];
-      return key !== "message";
-    }))
-  });
-}
-
-// TODO: validate
-function parse(_x6) {
-  return _parse.apply(this, arguments);
-}
-function _parse() {
-  _parse = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(res) {
-    var json;
-    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-      while (1) switch (_context5.prev = _context5.next) {
-        case 0:
-          _context5.prev = 0;
-          if (!res.ok) {
-            _context5.next = 9;
-            break;
-          }
-          _context5.t0 = result.result;
-          _context5.next = 5;
-          return res.json();
-        case 5:
-          _context5.t1 = _context5.sent;
-          return _context5.abrupt("return", _context5.t0.ok.call(_context5.t0, _context5.t1));
-        case 9:
-          _context5.prev = 9;
-          _context5.next = 12;
-          return res.json();
-        case 12:
-          json = _context5.sent;
-          return _context5.abrupt("return", formatError(res.status, json, res.statusText));
-        case 16:
-          _context5.prev = 16;
-          _context5.t2 = _context5["catch"](9);
-          return _context5.abrupt("return", result.err({
-            statusCode: res.status,
-            message: res.statusText
-          }));
-        case 19:
-          _context5.next = 24;
-          break;
-        case 21:
-          _context5.prev = 21;
-          _context5.t3 = _context5["catch"](0);
-          return _context5.abrupt("return", result.err({
-            message: _context5.t3 instanceof Error ? _context5.t3.message : "Unknown error"
-          }));
-        case 24:
-        case "end":
-          return _context5.stop();
-      }
-    }, _callee5, null, [[0, 21], [9, 16]]);
-  }));
-  return _parse.apply(this, arguments);
-}
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-
 var FATAL_ERROR_TYPES = ["no-schema", "no-source", "invalid-id", "no-module", "invalid-patch"];
 var Internal = {
   VERSION: {
@@ -4374,6 +5137,11 @@ var Internal = {
   createValPathOfItem: createValPathOfItem,
   getSHA256Hash: getSHA256Hash,
   initSchema: initSchema,
+  getMimeType: getMimeType,
+  mimeTypeToFileExt: mimeTypeToFileExt,
+  filenameToMimeType: filenameToMimeType,
+  EXT_TO_MIME_TYPES: EXT_TO_MIME_TYPES,
+  MIME_TYPES_TO_EXT: MIME_TYPES_TO_EXT,
   ModuleFilePathSep: ModuleFilePathSep,
   notFileOp: function notFileOp(op) {
     return op.op !== "file";
@@ -4422,6 +5190,7 @@ exports.FileSchema = FileSchema;
 exports.GenericSelector = GenericSelector;
 exports.ImageSchema = ImageSchema;
 exports.Internal = Internal;
+exports.KeyOfSchema = KeyOfSchema;
 exports.LiteralSchema = LiteralSchema;
 exports.NilSym = NilSym;
 exports.NumberSchema = NumberSchema;
@@ -4437,7 +5206,6 @@ exports.StringTemplate = StringTemplate;
 exports.Sym = Sym;
 exports.UnionSchema = UnionSchema;
 exports.VAL_EXTENSION = VAL_EXTENSION;
-exports.ValApi = ValApi;
 exports._classCallCheck = _classCallCheck;
 exports._createClass = _createClass;
 exports._slicedToArray = _slicedToArray;
@@ -4449,5 +5217,5 @@ exports.evaluate = evaluate;
 exports.index = index;
 exports.initVal = initVal;
 exports.modules = modules;
-exports.parse = parse$1;
+exports.parse = parse;
 exports.splitModuleFilePathAndModulePath = splitModuleFilePathAndModulePath;