@valbuild/core 0.63.5 → 0.64.0

package/dist/{index-3c8b4776.esm.js → index-4240c6a6.esm.js}

@@ -1,4 +1,4 @@
-import { _ as _arrayLikeToArray, a as _unsupportedIterableToArray, i as isErr, e as err, o as ok, b as isOk, c as _createForOfIteratorHelper, r as result } from './result-a8316efa.esm.js';
+import { _ as _arrayLikeToArray, a as _unsupportedIterableToArray, i as isErr, e as err, o as ok, b as isOk, c as _createForOfIteratorHelper } from './result-a8316efa.esm.js';
 import * as marked from 'marked';
 import { VAL_EXTENSION as VAL_EXTENSION$1, FILE_REF_SUBTYPE_TAG as FILE_REF_SUBTYPE_TAG$1 } from '@valbuild/core';
 
@@ -448,6 +448,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).",
@@ -464,11 +508,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",
@@ -613,7 +699,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));
                     }
@@ -680,6 +766,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)) {
@@ -710,6 +810,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), "'")
@@ -719,10 +824,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),
@@ -741,22 +846,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",
@@ -768,10 +917,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
@@ -1034,7 +1183,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),
@@ -1160,7 +1309,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));
                     }
@@ -1403,7 +1552,7 @@ function evaluate(expr, source, stack) {
 
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  parse: parse$1,
+  parse: parse,
   Call: Call,
   Expr: Expr,
   NilSym: NilSym,
@@ -1427,57 +1576,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 = _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",
@@ -1533,11 +1694,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",
@@ -1577,20 +1762,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") {
@@ -1600,7 +1785,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;
@@ -1613,7 +1798,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;
@@ -1623,18 +1808,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 = [];
@@ -1650,7 +1837,7 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
               } else {
                 return _defineProperty({}, path, [{
                   message: "Found duplicate key in schema: ".concat(schemaKey.value),
-                  fatal: true
+                  schemaError: true
                 }]);
               }
             }
@@ -1690,7 +1877,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));
@@ -1715,8 +1902,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 = _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 = _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",
@@ -1749,8 +2074,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);
 };
@@ -1777,12 +2102,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",
@@ -1840,6 +2300,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).",
@@ -1856,23 +2360,65 @@ 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
+        };
       }
-      return (src === null || src === void 0 ? void 0 : src[FILE_REF_PROP]) === "image" && (src === null || src === void 0 ? void 0 : src[VAL_EXTENSION]) === "file";
-    }
-  }, {
-    key: "nullable",
-    value: function nullable() {
-      return new ImageSchema(this.options, true);
-    }
-  }, {
-    key: "serialize",
-    value: function serialize() {
-      return {
-        type: "image",
-        options: this.options,
+      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
+          }])
+        };
+      }
+      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",
+    value: function nullable() {
+      return new ImageSchema(this.options, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "image",
+        options: this.options,
         opt: this.opt
       };
     }
@@ -1902,6 +2448,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), "'")
@@ -1912,10 +2463,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),
@@ -1934,21 +2485,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",
@@ -2016,7 +2581,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";
 }
 
@@ -2038,6 +2605,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;
@@ -2132,6 +2700,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) {
@@ -2243,11 +2812,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
+        };
       }
-      return typeof src === "number";
+      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 {
+        success: false,
+        errors: _defineProperty({}, path, [{
+          message: "Expected 'number', got '".concat(_typeof(src), "'"),
+          typeError: true
+        }])
+      };
     }
   }, {
     key: "nullable",
@@ -2343,11 +2936,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
+        };
       }
-      return typeof src === "string";
+      if (typeof src === "string") {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      return {
+        success: false,
+        errors: _defineProperty({}, path, [{
+          message: "Expected 'string', got '".concat(_typeof(src), "'"),
+          typeError: true
+        }])
+      };
     }
   }, {
     key: "nullable",
@@ -2410,11 +3018,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
+        };
+      }
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'boolean', got 'null'",
+            typeError: true
+          }])
+        };
       }
-      return typeof src === "boolean";
+      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",
@@ -2490,34 +3122,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",
@@ -2565,6 +3242,135 @@ var keyOf = function keyOf(valModule) {
   return new KeyOfSchema(valModule === null || valModule === void 0 || (_valModule$GetSchema = valModule[GetSchema$1]) === null || _valModule$GetSchema === void 0 ? void 0 : _valModule$GetSchema.serialize(), getValPath(valModule));
 };
 
+var DateSchema = /*#__PURE__*/function (_Schema) {
+  _inherits(DateSchema, _Schema);
+  function DateSchema(options) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    _classCallCheck(this, DateSchema);
+    _this = _callSuper(this, DateSchema);
+    _this.options = options;
+    _this.opt = opt;
+    return _this;
+  }
+  _createClass(DateSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      var _this$options, _this$options2, _this$options3, _this$options4;
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (typeof src !== "string") {
+        return _defineProperty({}, path, [{
+          message: "Expected 'string', got '".concat(_typeof(src), "'"),
+          value: src
+        }]);
+      }
+      if ((_this$options = this.options) !== null && _this$options !== void 0 && _this$options.from && (_this$options2 = this.options) !== null && _this$options2 !== void 0 && _this$options2.to) {
+        if (this.options.from > this.options.to) {
+          return _defineProperty({}, path, [{
+            message: "From date ".concat(this.options.from, " is after to date ").concat(this.options.to),
+            value: src,
+            typeError: true
+          }]);
+        }
+        if (src < this.options.from || src > this.options.to) {
+          return _defineProperty({}, path, [{
+            message: "Date is not between ".concat(this.options.from, " and ").concat(this.options.to),
+            value: src
+          }]);
+        }
+      } else if ((_this$options3 = this.options) !== null && _this$options3 !== void 0 && _this$options3.from) {
+        if (src < this.options.from) {
+          return _defineProperty({}, path, [{
+            message: "Date is before the minimum date ".concat(this.options.from),
+            value: src
+          }]);
+        }
+      } else if ((_this$options4 = this.options) !== null && _this$options4 !== void 0 && _this$options4.to) {
+        if (src > this.options.to) {
+          return _defineProperty({}, path, [{
+            message: "Date is after the maximum date ".concat(this.options.to),
+            value: src
+          }]);
+        }
+      }
+      // const errors = [];
+
+      // if (errors.length > 0) {
+      //   return {
+      //     [path]: errors,
+      //   } as ValidationErrors;
+      // }
+      return false;
+    }
+  }, {
+    key: "assert",
+    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 {
+        success: true,
+        data: src
+      };
+    }
+  }, {
+    key: "from",
+    value: function from(_from) {
+      return new DateSchema(_objectSpread2(_objectSpread2({}, this.options), {}, {
+        from: _from
+      }), this.opt);
+    }
+  }, {
+    key: "to",
+    value: function to(_to) {
+      return new DateSchema(_objectSpread2(_objectSpread2({}, this.options), {}, {
+        to: _to
+      }), this.opt);
+    }
+  }, {
+    key: "nullable",
+    value: function nullable() {
+      return new DateSchema(this.options, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return {
+        type: "date",
+        opt: this.opt,
+        options: this.options
+      };
+    }
+  }]);
+  return DateSchema;
+}(Schema);
+var date = function date(options) {
+  return new DateSchema(options);
+};
+
 // import type { F } from "ts-toolbelt";
 // import { i18n, I18n } from "./schema/future/i18n";
 // import { oneOf } from "./schema/future/oneOf";
@@ -2587,7 +3393,8 @@ function initSchema() {
     literal: literal,
     keyOf: keyOf,
     record: record,
-    file: file
+    file: file,
+    date: date
     // i18n: i18n(locales),
   };
 }
@@ -3507,6 +4314,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) {
@@ -3530,9 +5059,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":
@@ -3541,6 +5077,8 @@ function deserializeSchema(serialized) {
       return new FileSchema(serialized.options, serialized.opt);
     case "image":
       return new ImageSchema(serialized.options, serialized.opt);
+    case "date":
+      return new DateSchema(serialized.options);
     default:
       {
         var exhaustiveCheck = serialized;
@@ -3554,671 +5092,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 = _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 = _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 = _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$1) {
-  return err({
-    statusCode: 500,
-    message: err$1 instanceof Error ? err$1.message : _typeof(err$1) === "object" && err$1 && "message" in err$1 && typeof err$1.message === "string" ? err$1.message : "Unknown error",
-    details: _typeof(err$1) === "object" && err$1 && "details" in err$1 ? err$1.details : undefined
-  });
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function formatError(status, json, statusText) {
-  return 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;
-          _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", 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", 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: {
@@ -4242,6 +5115,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";
@@ -4278,4 +5156,4 @@ function tryJsonParse(str) {
   }
 }
 
-export { ArraySchema as A, BooleanSchema as B, Call as C, Expr as E, FATAL_ERROR_TYPES as F, GenericSelector as G, Internal as I, LiteralSchema as L, NilSym as N, ObjectSchema as O, PatchError as P, RT_IMAGE_TAG as R, StringLiteral as S, UnionSchema as U, VAL_EXTENSION as V, _typeof as _, _slicedToArray as a, _createClass as b, _classCallCheck as c, _toConsumableArray as d, StringTemplate as e, Sym as f, evaluate as g, initVal as h, index as i, Schema as j, FILE_REF_PROP as k, FILE_REF_SUBTYPE_TAG as l, modules as m, derefPatch as n, RecordSchema as o, parse$1 as p, StringSchema as q, NumberSchema as r, splitModuleFilePathAndModulePath as s, ImageSchema as t, FileSchema as u, RichTextSchema as v, deserializeSchema as w, ValApi as x };
+export { ArraySchema as A, BooleanSchema as B, Call as C, DateSchema as D, Expr as E, FATAL_ERROR_TYPES as F, GenericSelector as G, Internal as I, KeyOfSchema as K, LiteralSchema as L, NilSym as N, ObjectSchema as O, PatchError as P, RT_IMAGE_TAG as R, StringLiteral as S, UnionSchema as U, VAL_EXTENSION as V, _typeof as _, _slicedToArray as a, _createClass as b, _classCallCheck as c, _toConsumableArray as d, StringTemplate as e, Sym as f, evaluate as g, initVal as h, index as i, Schema as j, FILE_REF_PROP as k, FILE_REF_SUBTYPE_TAG as l, modules as m, derefPatch as n, RecordSchema as o, parse as p, StringSchema as q, NumberSchema as r, splitModuleFilePathAndModulePath as s, ImageSchema as t, FileSchema as u, RichTextSchema as v, deserializeSchema as w };