@xpadev-net/niconicomments 0.2.64 → 0.2.66

package/dist/bundle.js

@@ -1,5 +1,5 @@
 /*!
-  niconicomments.js v0.2.64
+  niconicomments.js v0.2.66
   (c) 2021 xpadev-net https://xpadev.net
   Released under the MIT License.
 */
@@ -524,28 +524,70 @@
       return _createClass(ValiError);
     }( /*#__PURE__*/_wrapNativeSuper(Error));
 
-    // src/utils/getIssues/getIssues.ts
-    function getIssues(issues) {
+    // src/utils/errorMessage/errorMessage.ts
+    function errorMessage(message) {
+      return typeof message === "function" ? message() : message;
+    }
+
+    // src/utils/actionIssue/actionIssue.ts
+    function actionIssue(validation, message, input, requirement, path) {
       return {
-        issues: issues
+        issues: [{
+          validation: validation,
+          message: errorMessage(message),
+          input: input,
+          requirement: requirement,
+          path: path
+        }]
       };
     }
 
-    // src/utils/getOutput/getOutput.ts
-    function getOutput(output) {
+    // src/utils/actionOutput/actionOutput.ts
+    function actionOutput(output) {
       return {
         output: output
       };
     }
 
-    // src/utils/executePipe/utils/getIssue/getIssue.ts
-    function getIssue(info, issue) {
+    // src/utils/defaultArgs/defaultArgs.ts
+    function defaultArgs(arg1, arg2) {
+      return Array.isArray(arg1) ? [void 0, arg1] : [arg1, arg2];
+    }
+
+    // src/utils/parseResult/parseResult.ts
+    function parseResult(typed, output, issues) {
+      return {
+        typed: typed,
+        output: output,
+        issues: issues
+      };
+    }
+
+    // src/utils/restAndDefaultArgs/restAndDefaultArgs.ts
+    function restAndDefaultArgs(arg1, arg2, arg3) {
+      if (!arg1 || _typeof(arg1) === "object" && !Array.isArray(arg1)) {
+        var _defaultArgs = defaultArgs(arg2, arg3),
+          _defaultArgs2 = _slicedToArray(_defaultArgs, 2),
+          error2 = _defaultArgs2[0],
+          pipe2 = _defaultArgs2[1];
+        return [arg1, error2, pipe2];
+      }
+      var _defaultArgs3 = defaultArgs(arg1, arg2),
+        _defaultArgs4 = _slicedToArray(_defaultArgs3, 2),
+        error = _defaultArgs4[0],
+        pipe = _defaultArgs4[1];
+      return [void 0, error, pipe];
+    }
+
+    // src/utils/pipeResult/utils/pipeIssue/pipeIssue.ts
+    function pipeIssue(info, issue) {
       return {
         reason: info === null || info === void 0 ? void 0 : info.reason,
         validation: issue.validation,
         origin: (info === null || info === void 0 ? void 0 : info.origin) || "value",
         message: issue.message,
         input: issue.input,
+        requirement: issue === null || issue === void 0 ? void 0 : issue.requirement,
         path: issue.path,
         abortEarly: info === null || info === void 0 ? void 0 : info.abortEarly,
         abortPipeEarly: info === null || info === void 0 ? void 0 : info.abortPipeEarly,
@@ -553,8 +595,8 @@
       };
     }
 
-    // src/utils/executePipe/utils/getPipeInfo/getPipeInfo.ts
-    function getPipeInfo(info, reason) {
+    // src/utils/pipeResult/utils/pipeInfo/pipeInfo.ts
+    function pipeInfo(info, reason) {
       return {
         reason: reason,
         origin: info === null || info === void 0 ? void 0 : info.origin,
@@ -564,91 +606,56 @@
       };
     }
 
-    // src/utils/executePipe/executePipe.ts
-    function executePipe(input, pipe, parseInfo, reason) {
-      if (!pipe || !pipe.length || parseInfo !== null && parseInfo !== void 0 && parseInfo.skipPipe) {
-        return getOutput(input);
-      }
-      var pipeInfo;
-      var issues;
+    // src/utils/pipeResult/pipeResult.ts
+    function pipeResult(input, pipe, parseInfo, reason, issues) {
+      var info;
       var output = input;
-      var _iterator = _createForOfIteratorHelper(pipe),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var action = _step.value;
-          var result = action(output);
-          if (result.issues) {
-            pipeInfo = pipeInfo || getPipeInfo(parseInfo, reason);
-            var _iterator2 = _createForOfIteratorHelper(result.issues),
-              _step2;
-            try {
-              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                var issueInfo = _step2.value;
-                var issue = getIssue(pipeInfo, issueInfo);
-                issues ? issues.push(issue) : issues = [issue];
+      if (pipe !== null && pipe !== void 0 && pipe.length && !(parseInfo !== null && parseInfo !== void 0 && parseInfo.skipPipe)) {
+        var _iterator = _createForOfIteratorHelper(pipe),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var action = _step.value;
+            var result = action._parse(output);
+            if (result.issues) {
+              info = info || pipeInfo(parseInfo, reason);
+              var _iterator2 = _createForOfIteratorHelper(result.issues),
+                _step2;
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  var issueInfo = _step2.value;
+                  var issue = pipeIssue(info, issueInfo);
+                  issues ? issues.push(issue) : issues = [issue];
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
               }
-            } catch (err) {
-              _iterator2.e(err);
-            } finally {
-              _iterator2.f();
-            }
-            if (pipeInfo.abortEarly || pipeInfo.abortPipeEarly) {
-              break;
+              if (info.abortEarly || info.abortPipeEarly) {
+                break;
+              }
+            } else {
+              output = result.output;
             }
-          } else {
-            output = result.output;
           }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-      return issues ? getIssues(issues) : getOutput(output);
-    }
-    function getDefaultArgs(arg1, arg2) {
-      return Array.isArray(arg1) ? [void 0, arg1] : [arg1, arg2];
-    }
-
-    // src/utils/getErrorMessage/getErrorMessage.ts
-    function getErrorMessage(error) {
-      return typeof error === "function" ? error() : error;
-    }
-
-    // src/utils/getPipeIssues/getPipeIssues.ts
-    function getPipeIssues(validation, error, input) {
-      return getIssues([{
-        validation: validation,
-        message: getErrorMessage(error),
-        input: input
-      }]);
-    }
-
-    // src/utils/getRestAndDefaultArgs/getRestAndDefaultArgs.ts
-    function getRestAndDefaultArgs(arg1, arg2, arg3) {
-      if (!arg1 || _typeof(arg1) === "object" && !Array.isArray(arg1)) {
-        var _getDefaultArgs = getDefaultArgs(arg2, arg3),
-          _getDefaultArgs2 = _slicedToArray(_getDefaultArgs, 2),
-          error2 = _getDefaultArgs2[0],
-          pipe2 = _getDefaultArgs2[1];
-        return [arg1, error2, pipe2];
       }
-      var _getDefaultArgs3 = getDefaultArgs(arg1, arg2),
-        _getDefaultArgs4 = _slicedToArray(_getDefaultArgs3, 2),
-        error = _getDefaultArgs4[0],
-        pipe = _getDefaultArgs4[1];
-      return [void 0, error, pipe];
+      return parseResult(true, output, issues);
     }
-
-    // src/utils/getSchemaIssues/getSchemaIssues.ts
-    function getSchemaIssues(info, reason, validation, error, input, issues) {
+    function schemaIssue(info, reason, validation, message, input, issues) {
       return {
+        typed: false,
+        output: input,
         issues: [{
           reason: reason,
           validation: validation,
           origin: (info === null || info === void 0 ? void 0 : info.origin) || "value",
-          message: getErrorMessage(error),
+          message: errorMessage(message),
           input: input,
           issues: issues,
           abortEarly: info === null || info === void 0 ? void 0 : info.abortEarly,
@@ -657,48 +664,41 @@
         }]
       };
     }
-    function is(schema, input) {
+
+    // src/methods/getDefault/getDefault.ts
+    function getDefault(schema) {
+      return typeof schema["default"] === "function" ? schema["default"]() : schema["default"];
+    }
+    function is(schema, input, info) {
       return !schema._parse(input, {
-        abortEarly: true
+        abortEarly: true,
+        skipPipe: info === null || info === void 0 ? void 0 : info.skipPipe
       }).issues;
     }
 
     // src/schemas/array/array.ts
     function array(item, arg2, arg3) {
-      var _getDefaultArgs5 = getDefaultArgs(arg2, arg3),
-        _getDefaultArgs6 = _slicedToArray(_getDefaultArgs5, 2),
-        error = _getDefaultArgs6[0],
-        pipe = _getDefaultArgs6[1];
+      var _defaultArgs5 = defaultArgs(arg2, arg3),
+        _defaultArgs6 = _slicedToArray(_defaultArgs5, 2),
+        _defaultArgs6$ = _defaultArgs6[0],
+        message = _defaultArgs6$ === void 0 ? "Invalid type" : _defaultArgs6$,
+        pipe = _defaultArgs6[1];
       return {
-        /**
-         * The schema type.
-         */
         type: "array",
-        /**
-         * The item schema.
-         */
-        item: item,
-        /**
-         * Whether it's async.
-         */
         async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        item: item,
+        message: message,
+        pipe: pipe,
         _parse: function _parse(input, info) {
           if (!Array.isArray(input)) {
-            return getSchemaIssues(info, "type", "array", error || "Invalid type", input);
+            return schemaIssue(info, "type", "array", this.message, input);
           }
+          var typed = true;
           var issues;
           var output = [];
           for (var key = 0; key < input.length; key++) {
             var value2 = input[key];
-            var result = item._parse(value2, info);
+            var result = this.item._parse(value2, info);
             if (result.issues) {
               var pathItem = {
                 type: "array",
@@ -706,12 +706,12 @@
                 key: key,
                 value: value2
               };
-              var _iterator3 = _createForOfIteratorHelper(result.issues),
-                _step3;
+              var _iterator5 = _createForOfIteratorHelper(result.issues),
+                _step5;
               try {
-                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
                   var _issues;
-                  var issue = _step3.value;
+                  var issue = _step5.value;
                   if (issue.path) {
                     issue.path.unshift(pathItem);
                   } else {
@@ -720,53 +720,48 @@
                   (_issues = issues) === null || _issues === void 0 || _issues.push(issue);
                 }
               } catch (err) {
-                _iterator3.e(err);
+                _iterator5.e(err);
               } finally {
-                _iterator3.f();
+                _iterator5.f();
               }
               if (!issues) {
                 issues = result.issues;
               }
               if (info !== null && info !== void 0 && info.abortEarly) {
+                typed = false;
                 break;
               }
-            } else {
-              output.push(result.output);
             }
+            if (!result.typed) {
+              typed = false;
+            }
+            output.push(result.output);
+          }
+          if (typed) {
+            return pipeResult(output, this.pipe, info, "array", issues);
           }
-          return issues ? getIssues(issues) : executePipe(output, pipe, info, "array");
+          return parseResult(false, output, issues);
         }
       };
     }
 
     // src/schemas/boolean/boolean.ts
     function _boolean(arg1, arg2) {
-      var _getDefaultArgs17 = getDefaultArgs(arg1, arg2),
-        _getDefaultArgs18 = _slicedToArray(_getDefaultArgs17, 2),
-        error = _getDefaultArgs18[0],
-        pipe = _getDefaultArgs18[1];
+      var _defaultArgs17 = defaultArgs(arg1, arg2),
+        _defaultArgs18 = _slicedToArray(_defaultArgs17, 2),
+        _defaultArgs18$ = _defaultArgs18[0],
+        message = _defaultArgs18$ === void 0 ? "Invalid type" : _defaultArgs18$,
+        pipe = _defaultArgs18[1];
       return {
-        /**
-         * The schema type.
-         */
         type: "boolean",
-        /**
-         * Whether it's async.
-         */
         async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        message: message,
+        pipe: pipe,
         _parse: function _parse(input, info) {
           if (typeof input !== "boolean") {
-            return getSchemaIssues(info, "type", "boolean", error || "Invalid type", input);
+            return schemaIssue(info, "type", "boolean", this.message, input);
           }
-          return executePipe(input, pipe, info, "boolean");
+          return pipeResult(input, this.pipe, info, "boolean");
         }
       };
     }
@@ -775,7 +770,9 @@
     function mergeOutputs(output1, output2) {
       if (_typeof(output1) === _typeof(output2)) {
         if (output1 === output2 || output1 instanceof Date && output2 instanceof Date && +output1 === +output2) {
-          return getOutput(output1);
+          return {
+            output: output1
+          };
         }
         if (Array.isArray(output1) && Array.isArray(output2)) {
           if (output1.length === output2.length) {
@@ -787,7 +784,9 @@
               }
               array2.push(result.output);
             }
-            return getOutput(array2);
+            return {
+              output: array2
+            };
           }
           return {
             invalid: true
@@ -804,7 +803,9 @@
               object2[key] = _result.output;
             }
           }
-          return getOutput(object2);
+          return {
+            output: object2
+          };
         }
       }
       return {
@@ -813,114 +814,85 @@
     }
 
     // src/schemas/intersect/intersect.ts
-    function intersect(options, error) {
+    function intersect(options) {
+      var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid type";
       return {
-        /**
-         * The schema type.
-         */
         type: "intersect",
-        /**
-         * The intersect options.
-         */
-        options: options,
-        /**
-         * Whether it's async.
-         */
         async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        options: options,
+        message: message,
         _parse: function _parse(input, info) {
+          var typed = true;
           var issues;
-          var outputs;
-          var _iterator5 = _createForOfIteratorHelper(options),
-            _step5;
+          var output;
+          var outputs = [];
+          var _iterator7 = _createForOfIteratorHelper(this.options),
+            _step7;
           try {
-            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-              var schema = _step5.value;
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              var schema = _step7.value;
               var _result2 = schema._parse(input, info);
               if (_result2.issues) {
                 if (issues) {
-                  var _iterator6 = _createForOfIteratorHelper(_result2.issues),
-                    _step6;
+                  var _iterator8 = _createForOfIteratorHelper(_result2.issues),
+                    _step8;
                   try {
-                    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-                      var issue = _step6.value;
+                    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                      var issue = _step8.value;
                       issues.push(issue);
                     }
                   } catch (err) {
-                    _iterator6.e(err);
+                    _iterator8.e(err);
                   } finally {
-                    _iterator6.f();
+                    _iterator8.f();
                   }
                 } else {
                   issues = _result2.issues;
                 }
                 if (info !== null && info !== void 0 && info.abortEarly) {
+                  typed = false;
                   break;
                 }
-              } else {
-                if (outputs) {
-                  outputs.push(_result2.output);
-                } else {
-                  outputs = [_result2.output];
-                }
               }
+              if (!_result2.typed) {
+                typed = false;
+              }
+              outputs.push(_result2.output);
             }
           } catch (err) {
-            _iterator5.e(err);
+            _iterator7.e(err);
           } finally {
-            _iterator5.f();
+            _iterator7.f();
           }
-          if (issues) {
-            return getIssues(issues);
-          }
-          var output = outputs[0];
-          for (var index = 1; index < outputs.length; index++) {
-            var result = mergeOutputs(output, outputs[index]);
-            if (result.invalid) {
-              return getSchemaIssues(info, "type", "intersect", error || "Invalid type", input);
+          if (typed) {
+            output = outputs[0];
+            for (var index = 1; index < outputs.length; index++) {
+              var result = mergeOutputs(output, outputs[index]);
+              if (result.invalid) {
+                return schemaIssue(info, "type", "intersect", this.message, input);
+              }
+              output = result.output;
             }
-            output = result.output;
+            return parseResult(true, output, issues);
           }
-          return getOutput(output);
+          return parseResult(false, output, issues);
         }
       };
     }
 
     // src/schemas/literal/literal.ts
-    function literal(literal2, error) {
+    function literal(literal2) {
+      var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid type";
       return {
-        /**
-         * The schema type.
-         */
         type: "literal",
-        /**
-         * The literal value.
-         */
-        literal: literal2,
-        /**
-         * Whether it's async.
-         */
         async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        literal: literal2,
+        message: message,
         _parse: function _parse(input, info) {
-          if (input !== literal2) {
-            return getSchemaIssues(info, "type", "literal", error || "Invalid type", input);
+          if (input !== this.literal) {
+            return schemaIssue(info, "type", "literal", this.message, input);
           }
-          return getOutput(input);
+          return parseResult(true, input);
         }
       };
     }
@@ -928,124 +900,75 @@
     // src/schemas/nullable/nullable.ts
     function nullable(wrapped, default_) {
       return {
-        /**
-         * The schema type.
-         */
         type: "nullable",
-        /**
-         * The wrapped schema.
-         */
-        wrapped: wrapped,
-        /**
-         * Returns the default value.
-         */
-        getDefault: function getDefault() {
-          return typeof default_ === "function" ? default_() : default_;
-        },
-        /**
-         * Whether it's async.
-         */
         async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        wrapped: wrapped,
+        "default": default_,
         _parse: function _parse(input, info) {
           if (input === null) {
-            var override = this.getDefault();
+            var override = getDefault(this);
             if (override === void 0) {
-              return getOutput(input);
+              return parseResult(true, input);
             }
             input = override;
           }
-          return wrapped._parse(input, info);
+          return this.wrapped._parse(input, info);
         }
       };
     }
 
     // src/schemas/number/number.ts
     function number(arg1, arg2) {
-      var _getDefaultArgs33 = getDefaultArgs(arg1, arg2),
-        _getDefaultArgs34 = _slicedToArray(_getDefaultArgs33, 2),
-        error = _getDefaultArgs34[0],
-        pipe = _getDefaultArgs34[1];
+      var _defaultArgs33 = defaultArgs(arg1, arg2),
+        _defaultArgs34 = _slicedToArray(_defaultArgs33, 2),
+        _defaultArgs34$ = _defaultArgs34[0],
+        message = _defaultArgs34$ === void 0 ? "Invalid type" : _defaultArgs34$,
+        pipe = _defaultArgs34[1];
       return {
-        /**
-         * The schema type.
-         */
         type: "number",
-        /**
-         * Whether it's async.
-         */
         async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        message: message,
+        pipe: pipe,
         _parse: function _parse(input, info) {
           if (typeof input !== "number" || isNaN(input)) {
-            return getSchemaIssues(info, "type", "number", error || "Invalid type", input);
+            return schemaIssue(info, "type", "number", this.message, input);
           }
-          return executePipe(input, pipe, info, "number");
+          return pipeResult(input, this.pipe, info, "number");
         }
       };
     }
 
     // src/schemas/object/object.ts
     function object(entries, arg2, arg3, arg4) {
-      var _getRestAndDefaultArg = getRestAndDefaultArgs(arg2, arg3, arg4),
-        _getRestAndDefaultArg2 = _slicedToArray(_getRestAndDefaultArg, 3),
-        rest = _getRestAndDefaultArg2[0],
-        error = _getRestAndDefaultArg2[1],
-        pipe = _getRestAndDefaultArg2[2];
+      var _restAndDefaultArgs = restAndDefaultArgs(arg2, arg3, arg4),
+        _restAndDefaultArgs2 = _slicedToArray(_restAndDefaultArgs, 3),
+        rest = _restAndDefaultArgs2[0],
+        _restAndDefaultArgs2$ = _restAndDefaultArgs2[1],
+        message = _restAndDefaultArgs2$ === void 0 ? "Invalid type" : _restAndDefaultArgs2$,
+        pipe = _restAndDefaultArgs2[2];
       var cachedEntries;
       return {
-        /**
-         * The schema type.
-         */
         type: "object",
-        /**
-         * The entries schema.
-         */
+        async: false,
         entries: entries,
-        /**
-         * The rest schema.
-         */
         rest: rest,
-        /**
-         * Whether it's async.
-         */
-        async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        message: message,
+        pipe: pipe,
         _parse: function _parse(input, info) {
           if (!input || _typeof(input) !== "object") {
-            return getSchemaIssues(info, "type", "object", error || "Invalid type", input);
+            return schemaIssue(info, "type", "object", this.message, input);
           }
-          cachedEntries = cachedEntries || Object.entries(entries);
+          cachedEntries = cachedEntries || Object.entries(this.entries);
+          var typed = true;
           var issues;
           var output = {};
-          var _iterator11 = _createForOfIteratorHelper(cachedEntries),
-            _step11;
+          var _iterator13 = _createForOfIteratorHelper(cachedEntries),
+            _step13;
           try {
-            for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
-              var _step11$value = _slicedToArray(_step11.value, 2),
-                _key3 = _step11$value[0],
-                schema = _step11$value[1];
+            for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+              var _step13$value = _slicedToArray(_step13.value, 2),
+                _key3 = _step13$value[0],
+                schema = _step13$value[1];
               var _value = input[_key3];
               var _result3 = schema._parse(_value, info);
               if (_result3.issues) {
@@ -1055,12 +978,12 @@
                   key: _key3,
                   value: _value
                 };
-                var _iterator13 = _createForOfIteratorHelper(_result3.issues),
-                  _step13;
+                var _iterator15 = _createForOfIteratorHelper(_result3.issues),
+                  _step15;
                 try {
-                  for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+                  for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
                     var _issues7;
-                    var _issue2 = _step13.value;
+                    var _issue2 = _step15.value;
                     if (_issue2.path) {
                       _issue2.path.unshift(_pathItem);
                     } else {
@@ -1069,30 +992,35 @@
                     (_issues7 = issues) === null || _issues7 === void 0 || _issues7.push(_issue2);
                   }
                 } catch (err) {
-                  _iterator13.e(err);
+                  _iterator15.e(err);
                 } finally {
-                  _iterator13.f();
+                  _iterator15.f();
                 }
                 if (!issues) {
                   issues = _result3.issues;
                 }
                 if (info !== null && info !== void 0 && info.abortEarly) {
+                  typed = false;
                   break;
                 }
-              } else if (_result3.output !== void 0 || _key3 in input) {
+              }
+              if (!_result3.typed) {
+                typed = false;
+              }
+              if (_result3.output !== void 0 || _key3 in input) {
                 output[_key3] = _result3.output;
               }
             }
           } catch (err) {
-            _iterator11.e(err);
+            _iterator13.e(err);
           } finally {
-            _iterator11.f();
+            _iterator13.f();
           }
-          if (rest && !(info !== null && info !== void 0 && info.abortEarly && issues)) {
+          if (this.rest && !(info !== null && info !== void 0 && info.abortEarly && issues)) {
             for (var key in input) {
-              if (!(key in entries)) {
+              if (!(key in this.entries)) {
                 var value2 = input[key];
-                var result = rest._parse(value2, info);
+                var result = this.rest._parse(value2, info);
                 if (result.issues) {
                   var pathItem = {
                     type: "object",
@@ -1100,12 +1028,12 @@
                     key: key,
                     value: value2
                   };
-                  var _iterator12 = _createForOfIteratorHelper(result.issues),
-                    _step12;
+                  var _iterator14 = _createForOfIteratorHelper(result.issues),
+                    _step14;
                   try {
-                    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+                    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
                       var _issues6;
-                      var issue = _step12.value;
+                      var issue = _step14.value;
                       if (issue.path) {
                         issue.path.unshift(pathItem);
                       } else {
@@ -1114,23 +1042,29 @@
                       (_issues6 = issues) === null || _issues6 === void 0 || _issues6.push(issue);
                     }
                   } catch (err) {
-                    _iterator12.e(err);
+                    _iterator14.e(err);
                   } finally {
-                    _iterator12.f();
+                    _iterator14.f();
                   }
                   if (!issues) {
                     issues = result.issues;
                   }
                   if (info !== null && info !== void 0 && info.abortEarly) {
+                    typed = false;
                     break;
                   }
-                } else {
-                  output[key] = result.output;
                 }
+                if (!result.typed) {
+                  typed = false;
+                }
+                output[key] = result.output;
               }
             }
           }
-          return issues ? getIssues(issues) : executePipe(output, pipe, info, "object");
+          if (typed) {
+            return pipeResult(output, this.pipe, info, "object", issues);
+          }
+          return parseResult(false, output, issues);
         }
       };
     }
@@ -1138,91 +1072,58 @@
     // src/schemas/optional/optional.ts
     function optional(wrapped, default_) {
       return {
-        /**
-         * The schema type.
-         */
         type: "optional",
-        /**
-         * The wrapped schema.
-         */
-        wrapped: wrapped,
-        /**
-         * Returns the default value.
-         */
-        getDefault: function getDefault() {
-          return typeof default_ === "function" ? default_() : default_;
-        },
-        /**
-         * Whether it's async.
-         */
         async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        wrapped: wrapped,
+        "default": default_,
         _parse: function _parse(input, info) {
           if (input === void 0) {
-            var override = this.getDefault();
+            var override = getDefault(this);
             if (override === void 0) {
-              return getOutput(input);
+              return parseResult(true, input);
             }
             input = override;
           }
-          return wrapped._parse(input, info);
+          return this.wrapped._parse(input, info);
         }
       };
     }
 
     // src/schemas/string/string.ts
     function string(arg1, arg2) {
-      var _getDefaultArgs37 = getDefaultArgs(arg1, arg2),
-        _getDefaultArgs38 = _slicedToArray(_getDefaultArgs37, 2),
-        error = _getDefaultArgs38[0],
-        pipe = _getDefaultArgs38[1];
+      var _defaultArgs37 = defaultArgs(arg1, arg2),
+        _defaultArgs38 = _slicedToArray(_defaultArgs37, 2),
+        _defaultArgs38$ = _defaultArgs38[0],
+        message = _defaultArgs38$ === void 0 ? "Invalid type" : _defaultArgs38$,
+        pipe = _defaultArgs38[1];
       return {
-        /**
-         * The schema type.
-         */
         type: "string",
-        /**
-         * Whether it's async.
-         */
         async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        message: message,
+        pipe: pipe,
         _parse: function _parse(input, info) {
           if (typeof input !== "string") {
-            return getSchemaIssues(info, "type", "string", error || "Invalid type", input);
+            return schemaIssue(info, "type", "string", this.message, input);
           }
-          return executePipe(input, pipe, info, "string");
+          return pipeResult(input, this.pipe, info, "string");
         }
       };
     }
 
-    // src/schemas/record/utils/getRecordArgs/getRecordArgs.ts
-    function getRecordArgs(arg1, arg2, arg3, arg4) {
+    // src/schemas/record/utils/recordArgs/recordArgs.ts
+    function recordArgs(arg1, arg2, arg3, arg4) {
       if (_typeof(arg2) === "object" && !Array.isArray(arg2)) {
-        var _getDefaultArgs41 = getDefaultArgs(arg3, arg4),
-          _getDefaultArgs42 = _slicedToArray(_getDefaultArgs41, 2),
-          error2 = _getDefaultArgs42[0],
-          pipe2 = _getDefaultArgs42[1];
-        return [arg1, arg2, error2, pipe2];
+        var _defaultArgs41 = defaultArgs(arg3, arg4),
+          _defaultArgs42 = _slicedToArray(_defaultArgs41, 2),
+          message2 = _defaultArgs42[0],
+          pipe2 = _defaultArgs42[1];
+        return [arg1, arg2, message2, pipe2];
       }
-      var _getDefaultArgs43 = getDefaultArgs(arg2, arg3),
-        _getDefaultArgs44 = _slicedToArray(_getDefaultArgs43, 2),
-        error = _getDefaultArgs44[0],
-        pipe = _getDefaultArgs44[1];
-      return [string(), arg1, error, pipe];
+      var _defaultArgs43 = defaultArgs(arg2, arg3),
+        _defaultArgs44 = _slicedToArray(_defaultArgs43, 2),
+        message = _defaultArgs44[0],
+        pipe = _defaultArgs44[1];
+      return [string(), arg1, message, pipe];
     }
 
     // src/schemas/record/values.ts
@@ -1230,41 +1131,25 @@
 
     // src/schemas/record/record.ts
     function record(arg1, arg2, arg3, arg4) {
-      var _getRecordArgs = getRecordArgs(arg1, arg2, arg3, arg4),
-        _getRecordArgs2 = _slicedToArray(_getRecordArgs, 4),
-        key = _getRecordArgs2[0],
-        value2 = _getRecordArgs2[1],
-        error = _getRecordArgs2[2],
-        pipe = _getRecordArgs2[3];
+      var _recordArgs = recordArgs(arg1, arg2, arg3, arg4),
+        _recordArgs2 = _slicedToArray(_recordArgs, 4),
+        key = _recordArgs2[0],
+        value2 = _recordArgs2[1],
+        _recordArgs2$ = _recordArgs2[2],
+        message = _recordArgs2$ === void 0 ? "Invalid type" : _recordArgs2$,
+        pipe = _recordArgs2[3];
       return {
-        /**
-         * The schema type.
-         */
         type: "record",
-        /**
-         * The key schema.
-         */
+        async: false,
         key: key,
-        /**
-         * The value schema.
-         */
         value: value2,
-        /**
-         * Whether it's async.
-         */
-        async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        message: message,
+        pipe: pipe,
         _parse: function _parse(input, info) {
           if (!input || _typeof(input) !== "object") {
-            return getSchemaIssues(info, "type", "record", error || "Invalid type", input);
+            return schemaIssue(info, "type", "record", this.message, input);
           }
+          var typed = true;
           var issues;
           var output = {};
           for (var _i = 0, _Object$entries = Object.entries(input); _i < _Object$entries.length; _i++) {
@@ -1273,7 +1158,7 @@
               inputValue = _Object$entries$_i[1];
             if (!BLOCKED_KEYS.includes(inputKey)) {
               var pathItem = void 0;
-              var keyResult = key._parse(inputKey, {
+              var keyResult = this.key._parse(inputKey, {
                 origin: "key",
                 abortEarly: info === null || info === void 0 ? void 0 : info.abortEarly,
                 abortPipeEarly: info === null || info === void 0 ? void 0 : info.abortPipeEarly,
@@ -1286,28 +1171,29 @@
                   key: inputKey,
                   value: inputValue
                 };
-                var _iterator16 = _createForOfIteratorHelper(keyResult.issues),
-                  _step16;
+                var _iterator18 = _createForOfIteratorHelper(keyResult.issues),
+                  _step18;
                 try {
-                  for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+                  for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
                     var _issues10;
-                    var issue = _step16.value;
+                    var issue = _step18.value;
                     issue.path = [pathItem];
                     (_issues10 = issues) === null || _issues10 === void 0 || _issues10.push(issue);
                   }
                 } catch (err) {
-                  _iterator16.e(err);
+                  _iterator18.e(err);
                 } finally {
-                  _iterator16.f();
+                  _iterator18.f();
                 }
                 if (!issues) {
                   issues = keyResult.issues;
                 }
                 if (info !== null && info !== void 0 && info.abortEarly) {
+                  typed = false;
                   break;
                 }
               }
-              var valueResult = value2._parse(inputValue, info);
+              var valueResult = this.value._parse(inputValue, info);
               if (valueResult.issues) {
                 pathItem = pathItem || {
                   type: "record",
@@ -1315,12 +1201,12 @@
                   key: inputKey,
                   value: inputValue
                 };
-                var _iterator17 = _createForOfIteratorHelper(valueResult.issues),
-                  _step17;
+                var _iterator19 = _createForOfIteratorHelper(valueResult.issues),
+                  _step19;
                 try {
-                  for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
+                  for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
                     var _issues11;
-                    var _issue3 = _step17.value;
+                    var _issue3 = _step19.value;
                     if (_issue3.path) {
                       _issue3.path.unshift(pathItem);
                     } else {
@@ -1329,72 +1215,64 @@
                     (_issues11 = issues) === null || _issues11 === void 0 || _issues11.push(_issue3);
                   }
                 } catch (err) {
-                  _iterator17.e(err);
+                  _iterator19.e(err);
                 } finally {
-                  _iterator17.f();
+                  _iterator19.f();
                 }
                 if (!issues) {
                   issues = valueResult.issues;
                 }
                 if (info !== null && info !== void 0 && info.abortEarly) {
+                  typed = false;
                   break;
                 }
               }
-              if (!keyResult.issues && !valueResult.issues) {
+              if (!keyResult.typed || !valueResult.typed) {
+                typed = false;
+              }
+              if (keyResult.typed) {
                 output[keyResult.output] = valueResult.output;
               }
             }
           }
-          return issues ? getIssues(issues) : executePipe(output, pipe, info, "record");
+          if (typed) {
+            return pipeResult(output, this.pipe, info, "record", issues);
+          }
+          return parseResult(false, output, issues);
         }
       };
     }
 
     // src/schemas/union/union.ts
-    function union(options, error) {
+    function union(options) {
+      var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid type";
       return {
-        /**
-         * The schema type.
-         */
         type: "union",
-        /**
-         * The union options.
-         */
-        options: options,
-        /**
-         * Whether it's async.
-         */
         async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        options: options,
+        message: message,
         _parse: function _parse(input, info) {
           var issues;
           var output;
-          var _iterator26 = _createForOfIteratorHelper(options),
-            _step26;
+          var _iterator28 = _createForOfIteratorHelper(this.options),
+            _step28;
           try {
-            for (_iterator26.s(); !(_step26 = _iterator26.n()).done;) {
-              var schema = _step26.value;
+            for (_iterator28.s(); !(_step28 = _iterator28.n()).done;) {
+              var schema = _step28.value;
               var result = schema._parse(input, info);
               if (result.issues) {
                 if (issues) {
-                  var _iterator27 = _createForOfIteratorHelper(result.issues),
-                    _step27;
+                  var _iterator29 = _createForOfIteratorHelper(result.issues),
+                    _step29;
                   try {
-                    for (_iterator27.s(); !(_step27 = _iterator27.n()).done;) {
-                      var issue = _step27.value;
+                    for (_iterator29.s(); !(_step29 = _iterator29.n()).done;) {
+                      var issue = _step29.value;
                       issues.push(issue);
                     }
                   } catch (err) {
-                    _iterator27.e(err);
+                    _iterator29.e(err);
                   } finally {
-                    _iterator27.f();
+                    _iterator29.f();
                   }
                 } else {
                   issues = result.issues;
@@ -1405,54 +1283,43 @@
               }
             }
           } catch (err) {
-            _iterator26.e(err);
+            _iterator28.e(err);
           } finally {
-            _iterator26.f();
+            _iterator28.f();
           }
-          return output ? getOutput(output[0]) : getSchemaIssues(info, "type", "union", error || "Invalid type", input, issues);
+          if (output) {
+            return parseResult(true, output[0]);
+          }
+          return schemaIssue(info, "type", "union", this.message, input, issues);
         }
       };
     }
 
     // src/schemas/unknown/unknown.ts
-    function unknown() {
-      var pipe = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    function unknown(pipe) {
       return {
-        /**
-         * The schema type.
-         */
         type: "unknown",
-        /**
-         * Whether it's async.
-         */
         async: false,
-        /**
-         * Parses unknown input based on its schema.
-         *
-         * @param input The input to be parsed.
-         * @param info The parse info.
-         *
-         * @returns The parsed output.
-         */
+        pipe: pipe,
         _parse: function _parse(input, info) {
-          return executePipe(input, pipe, info, "unknown");
+          return pipeResult(input, this.pipe, info, "unknown");
         }
       };
     }
 
     // src/methods/omit/omit.ts
     function omit(schema, keys, arg3, arg4, arg5) {
-      var _getRestAndDefaultArg13 = getRestAndDefaultArgs(arg3, arg4, arg5),
-        _getRestAndDefaultArg14 = _slicedToArray(_getRestAndDefaultArg13, 3),
-        rest = _getRestAndDefaultArg14[0],
-        error = _getRestAndDefaultArg14[1],
-        pipe = _getRestAndDefaultArg14[2];
+      var _restAndDefaultArgs13 = restAndDefaultArgs(arg3, arg4, arg5),
+        _restAndDefaultArgs14 = _slicedToArray(_restAndDefaultArgs13, 3),
+        rest = _restAndDefaultArgs14[0],
+        message = _restAndDefaultArgs14[1],
+        pipe = _restAndDefaultArgs14[2];
       return object(Object.entries(schema.entries).reduce(function (entries, _ref24) {
         var _ref25 = _slicedToArray(_ref24, 2),
           key = _ref25[0],
           schema2 = _ref25[1];
         return keys.includes(key) ? entries : _objectSpread2(_objectSpread2({}, entries), {}, _defineProperty({}, key, schema2));
-      }, {}), rest, error, pipe);
+      }, {}), rest, message, pipe);
     }
 
     // src/methods/parse/parse.ts
@@ -1467,35 +1334,55 @@
     // src/methods/safeParse/safeParse.ts
     function safeParse(schema, input, info) {
       var result = schema._parse(input, info);
-      return result.issues ? {
-        success: false,
-        error: new ValiError(result.issues),
-        issues: result.issues
-      } : {
-        success: true,
+      return {
+        typed: result.typed,
+        success: !result.issues,
         data: result.output,
-        output: result.output
+        output: result.output,
+        error: result.issues && new ValiError(result.issues),
+        issues: result.issues
       };
     }
 
     // src/validations/custom/custom.ts
-    function custom(requirement, error) {
-      return function (input) {
-        return !requirement(input) ? getPipeIssues("custom", error || "Invalid input", input) : getOutput(input);
+    function custom(requirement) {
+      var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid input";
+      return {
+        type: "custom",
+        async: false,
+        message: message,
+        requirement: requirement,
+        _parse: function _parse(input) {
+          return !this.requirement(input) ? actionIssue(this.type, this.message, input, this.requirement) : actionOutput(input);
+        }
       };
     }
 
     // src/validations/notValue/notValue.ts
-    function notValue(requirement, error) {
-      return function (input) {
-        return input === requirement ? getPipeIssues("not_value", error || "Invalid value", input) : getOutput(input);
+    function notValue(requirement) {
+      var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid value";
+      return {
+        type: "not_value",
+        async: false,
+        message: message,
+        requirement: requirement,
+        _parse: function _parse(input) {
+          return input === this.requirement ? actionIssue(this.type, this.message, input, this.requirement) : actionOutput(input);
+        }
       };
     }
 
     // src/validations/regex/regex.ts
-    function regex(requirement, error) {
-      return function (input) {
-        return !requirement.test(input) ? getPipeIssues("regex", error || "Invalid regex", input) : getOutput(input);
+    function regex(requirement) {
+      var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Invalid regex";
+      return {
+        type: "regex",
+        async: false,
+        message: message,
+        requirement: requirement,
+        _parse: function _parse(input) {
+          return !this.requirement.test(input) ? actionIssue(this.type, this.message, input, this.requirement) : actionOutput(input);
+        }
       };
     }
 
@@ -3004,11 +2891,11 @@
             const cache = imageCache[this.cacheKey];
             if (cache) {
                 this.image = cache.image;
-                setTimeout(() => {
+                window.setTimeout(() => {
                     delete this.image;
                 }, this.comment.long * 10 + config.cacheAge);
                 clearTimeout(cache.timeout);
-                cache.timeout = setTimeout(() => {
+                cache.timeout = window.setTimeout(() => {
                     imageCache[this.cacheKey]?.image.destroy();
                     delete imageCache[this.cacheKey];
                 }, this.comment.long * 10 + config.cacheAge);
@@ -3026,11 +2913,11 @@
         }
         _cacheImage(image) {
             this.image = image;
-            setTimeout(() => {
+            window.setTimeout(() => {
                 delete this.image;
             }, this.comment.long * 10 + config.cacheAge);
             imageCache[this.cacheKey] = {
-                timeout: setTimeout(() => {
+                timeout: window.setTimeout(() => {
                     delete imageCache[this.cacheKey];
                 }, this.comment.long * 10 + config.cacheAge),
                 image,
@@ -4651,6 +4538,8 @@
             }
             this.renderer = renderer;
             this.renderer.setLineWidth(getConfig(config.contextLineWidth, false));
+            const rendererSize = this.renderer.getSize();
+            this.renderer.setScale(rendererSize.width / config.canvasWidth, rendererSize.height / config.canvasHeight);
             let formatType = options.format;
             if (options.formatted) {
                 console.warn("Deprecated: options.formatted is no longer recommended. Please use options.format. https://xpadev-net.github.io/niconicomments/#p_format");