@xpadev-net/niconicomments 0.2.73 → 0.2.75

package/dist/bundle.js

@@ -1,5 +1,5 @@
 /*!
-  niconicomments.js v0.2.73
+  niconicomments.js v0.2.75
   (c) 2021 xpadev-net https://xpadev.net
   Released under the MIT License.
 */
@@ -213,9 +213,6 @@
       for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
       return n;
     }
-    function _arrayWithHoles(r) {
-      if (Array.isArray(r)) return r;
-    }
     function _arrayWithoutHoles(r) {
       if (Array.isArray(r)) return _arrayLikeToArray(r);
     }
@@ -238,7 +235,7 @@
     }
     function _createClass(e, r, t) {
       return Object.defineProperty(e, "prototype", {
-        writable: !1
+        writable: false
       }), e;
     }
     function _createForOfIteratorHelper(r, e) {
@@ -252,9 +249,9 @@
             s: F,
             n: function () {
               return n >= r.length ? {
-                done: !0
+                done: true
               } : {
-                done: !1,
+                done: false,
                 value: r[n++]
               };
             },
@@ -267,8 +264,8 @@
         throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
       }
       var o,
-        a = !0,
-        u = !1;
+        a = true,
+        u = false;
       return {
         s: function () {
           t = t.call(r);
@@ -278,7 +275,7 @@
           return a = r.done, r;
         },
         e: function (r) {
-          u = !0, o = r;
+          u = true, o = r;
         },
         f: function () {
           try {
@@ -292,9 +289,9 @@
     function _defineProperty(e, r, t) {
       return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
         value: t,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
+        enumerable: true,
+        configurable: true,
+        writable: true
       }) : e[r] = t, e;
     }
     function _getPrototypeOf(t) {
@@ -307,11 +304,11 @@
       t.prototype = Object.create(e && e.prototype, {
         constructor: {
           value: t,
-          writable: !0,
-          configurable: !0
+          writable: true,
+          configurable: true
         }
       }), Object.defineProperty(t, "prototype", {
-        writable: !1
+        writable: false
       }), e && _setPrototypeOf(t, e);
     }
     function _isNativeFunction(t) {
@@ -332,36 +329,6 @@
     function _iterableToArray(r) {
       if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
     }
-    function _iterableToArrayLimit(r, l) {
-      var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-      if (null != t) {
-        var e,
-          n,
-          i,
-          u,
-          a = [],
-          f = !0,
-          o = !1;
-        try {
-          if (i = (t = t.call(r)).next, 0 === l) {
-            if (Object(t) !== t) return;
-            f = !1;
-          } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-        } catch (r) {
-          o = !0, n = r;
-        } finally {
-          try {
-            if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
-          } finally {
-            if (o) throw n;
-          }
-        }
-        return a;
-      }
-    }
-    function _nonIterableRest() {
-      throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
     function _nonIterableSpread() {
       throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
     }
@@ -378,7 +345,7 @@
     function _objectSpread2(e) {
       for (var r = 1; r < arguments.length; r++) {
         var t = null != arguments[r] ? arguments[r] : {};
-        r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+        r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
           _defineProperty(e, r, t[r]);
         }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
           Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
@@ -396,9 +363,6 @@
         return t.__proto__ = e, t;
       }, _setPrototypeOf(t, e);
     }
-    function _slicedToArray(r, e) {
-      return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
-    }
     function _toConsumableArray(r) {
       return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
     }
@@ -406,7 +370,7 @@
       if ("object" != typeof t || !t) return t;
       var e = t[Symbol.toPrimitive];
       if (void 0 !== e) {
-        var i = e.call(t, r || "default");
+        var i = e.call(t, r);
         if ("object" != typeof i) return i;
         throw new TypeError("@@toPrimitive must return a primitive value.");
       }
@@ -447,254 +411,272 @@
         return Wrapper.prototype = Object.create(t.prototype, {
           constructor: {
             value: Wrapper,
-            enumerable: !1,
-            writable: !0,
-            configurable: !0
+            enumerable: false,
+            writable: true,
+            configurable: true
           }
         }), _setPrototypeOf(Wrapper, t);
       }, _wrapNativeSuper(t);
     }
 
-    // src/error/ValiError/ValiError.ts
-    var ValiError = /*#__PURE__*/function (_Error) {
-      /**
-       * Creates a Valibot error with useful information.
-       *
-       * @param issues The error issues.
-       */
-      function ValiError(issues) {
-        var _this;
-        _classCallCheck(this, ValiError);
-        _this = _callSuper(this, ValiError, [issues[0].message]);
-        _defineProperty(_this, "issues", void 0);
-        _this.name = "ValiError";
-        _this.issues = issues;
-        return _this;
-      }
-      _inherits(ValiError, _Error);
-      return _createClass(ValiError);
-    }(/*#__PURE__*/_wrapNativeSuper(Error));
-
-    // src/utils/actionIssue/actionIssue.ts
-    function actionIssue(context, reference, input, label, received) {
-      return {
-        issues: [{
-          context: context,
-          reference: reference,
-          input: input,
-          label: label,
-          received: received
-        }]
-      };
-    }
-
-    // src/utils/actionOutput/actionOutput.ts
-    function actionOutput(output) {
-      return {
-        output: output
-      };
-    }
-
-    // src/utils/defaultArgs/defaultArgs.ts
-    function defaultArgs(arg1, arg2) {
-      return Array.isArray(arg1) ? [void 0, arg1] : [arg1, arg2];
-    }
-
     // src/storages/globalConfig/globalConfig.ts
     var store;
-    function getGlobalConfig(config) {
-      var _config$lang, _store, _config$abortEarly, _store2, _config$abortPipeEarl, _store3, _config$skipPipe, _store4;
+    // @__NO_SIDE_EFFECTS__
+    function getGlobalConfig(config2) {
+      var _config2$lang, _store, _config2$abortEarly, _store2, _config2$abortPipeEar, _store3;
       return {
-        lang: (_config$lang = config === null || config === void 0 ? void 0 : config.lang) !== null && _config$lang !== void 0 ? _config$lang : (_store = store) === null || _store === void 0 ? void 0 : _store.lang,
-        message: config === null || config === void 0 ? void 0 : config.message,
-        abortEarly: (_config$abortEarly = config === null || config === void 0 ? void 0 : config.abortEarly) !== null && _config$abortEarly !== void 0 ? _config$abortEarly : (_store2 = store) === null || _store2 === void 0 ? void 0 : _store2.abortEarly,
-        abortPipeEarly: (_config$abortPipeEarl = config === null || config === void 0 ? void 0 : config.abortPipeEarly) !== null && _config$abortPipeEarl !== void 0 ? _config$abortPipeEarl : (_store3 = store) === null || _store3 === void 0 ? void 0 : _store3.abortPipeEarly,
-        skipPipe: (_config$skipPipe = config === null || config === void 0 ? void 0 : config.skipPipe) !== null && _config$skipPipe !== void 0 ? _config$skipPipe : (_store4 = store) === null || _store4 === void 0 ? void 0 : _store4.skipPipe
+        lang: (_config2$lang = void 0 ) !== null && _config2$lang !== void 0 ? _config2$lang : (_store = store) === null || _store === void 0 ? void 0 : _store.lang,
+        message: config2 === null || config2 === void 0 ? void 0 : config2.message,
+        abortEarly: (_config2$abortEarly = void 0 ) !== null && _config2$abortEarly !== void 0 ? _config2$abortEarly : (_store2 = store) === null || _store2 === void 0 ? void 0 : _store2.abortEarly,
+        abortPipeEarly: (_config2$abortPipeEar = void 0 ) !== null && _config2$abortPipeEar !== void 0 ? _config2$abortPipeEar : (_store3 = store) === null || _store3 === void 0 ? void 0 : _store3.abortPipeEarly
       };
     }
 
     // src/storages/globalMessage/globalMessage.ts
     var store2;
+    // @__NO_SIDE_EFFECTS__
     function getGlobalMessage(lang) {
-      var _store5;
-      return (_store5 = store2) === null || _store5 === void 0 ? void 0 : _store5.get(lang);
+      var _store4;
+      return (_store4 = store2) === null || _store4 === void 0 ? void 0 : _store4.get(lang);
     }
 
     // src/storages/schemaMessage/schemaMessage.ts
     var store3;
+    // @__NO_SIDE_EFFECTS__
     function getSchemaMessage(lang) {
-      var _store7;
-      return (_store7 = store3) === null || _store7 === void 0 ? void 0 : _store7.get(lang);
+      var _store6;
+      return (_store6 = store3) === null || _store6 === void 0 ? void 0 : _store6.get(lang);
     }
 
     // src/storages/specificMessage/specificMessage.ts
     var store4;
+    // @__NO_SIDE_EFFECTS__
     function getSpecificMessage(reference, lang) {
-      var _store9;
-      return (_store9 = store4) === null || _store9 === void 0 || (_store9 = _store9.get(reference)) === null || _store9 === void 0 ? void 0 : _store9.get(lang);
+      var _store8;
+      return (_store8 = store4) === null || _store8 === void 0 || (_store8 = _store8.get(reference)) === null || _store8 === void 0 ? void 0 : _store8.get(lang);
     }
 
-    // src/utils/i18n/i18n.ts
-    function i18n(schema, context, reference, config, issue) {
-      var _ref3, _ref4, _ref5, _ref6, _context$message;
-      var message = (_ref3 = (_ref4 = (_ref5 = (_ref6 = (_context$message = context.message) !== null && _context$message !== void 0 ? _context$message : getSpecificMessage(reference, issue.lang)) !== null && _ref6 !== void 0 ? _ref6 : schema ? getSchemaMessage(issue.lang) : null) !== null && _ref5 !== void 0 ? _ref5 : config === null || config === void 0 ? void 0 : config.message) !== null && _ref4 !== void 0 ? _ref4 : getGlobalMessage(issue.lang)) !== null && _ref3 !== void 0 ? _ref3 : issue.message;
-      return typeof message === "function" ? message(issue) : message;
+    // src/utils/_stringify/_stringify.ts
+    // @__NO_SIDE_EFFECTS__
+    function _stringify(input) {
+      var type = _typeof(input);
+      if (type === "string") {
+        return "\"".concat(input, "\"");
+      }
+      if (type === "number" || type === "bigint" || type === "boolean") {
+        return "".concat(input);
+      }
+      if (type === "object" || type === "function") {
+        var _ref, _Object$getPrototypeO;
+        return (_ref = input && ((_Object$getPrototypeO = Object.getPrototypeOf(input)) === null || _Object$getPrototypeO === void 0 || (_Object$getPrototypeO = _Object$getPrototypeO.constructor) === null || _Object$getPrototypeO === void 0 ? void 0 : _Object$getPrototypeO.name)) !== null && _ref !== void 0 ? _ref : "null";
+      }
+      return type;
+    }
+
+    // src/utils/_addIssue/_addIssue.ts
+    function _addIssue(context, label, dataset, config2, other) {
+      var _ref2, _other$expected, _other$received, _ref3, _ref4, _ref5, _ref6, _other$message;
+      var input = other && "input" in other ? other.input : dataset.value;
+      var expected = (_ref2 = (_other$expected = other === null || other === void 0 ? void 0 : other.expected) !== null && _other$expected !== void 0 ? _other$expected : context.expects) !== null && _ref2 !== void 0 ? _ref2 : null;
+      var received = (_other$received = other === null || other === void 0 ? void 0 : other.received) !== null && _other$received !== void 0 ? _other$received : _stringify(input);
+      var issue = {
+        kind: context.kind,
+        type: context.type,
+        input: input,
+        expected: expected,
+        received: received,
+        message: "Invalid ".concat(label, ": ").concat(expected ? "Expected ".concat(expected, " but r") : "R", "eceived ").concat(received),
+        requirement: context.requirement,
+        path: other === null || other === void 0 ? void 0 : other.path,
+        issues: other === null || other === void 0 ? void 0 : other.issues,
+        lang: config2.lang,
+        abortEarly: config2.abortEarly,
+        abortPipeEarly: config2.abortPipeEarly
+      };
+      var isSchema = context.kind === "schema";
+      var message2 = (_ref3 = (_ref4 = (_ref5 = (_ref6 = (_other$message = other === null || other === void 0 ? void 0 : other.message) !== null && _other$message !== void 0 ? _other$message : context.message) !== null && _ref6 !== void 0 ? _ref6 : getSpecificMessage(context.reference, issue.lang)) !== null && _ref5 !== void 0 ? _ref5 : isSchema ? getSchemaMessage(issue.lang) : null) !== null && _ref4 !== void 0 ? _ref4 : config2.message) !== null && _ref3 !== void 0 ? _ref3 : getGlobalMessage(issue.lang);
+      if (message2 !== void 0) {
+        issue.message = typeof message2 === "function" ?
+        // @ts-expect-error
+        message2(issue) : message2;
+      }
+      if (isSchema) {
+        dataset.typed = false;
+      }
+      if (dataset.issues) {
+        dataset.issues.push(issue);
+      } else {
+        dataset.issues = [issue];
+      }
     }
 
-    // src/utils/schemaResult/schemaResult.ts
-    function schemaResult(typed, output, issues) {
+    // src/utils/_getStandardProps/_getStandardProps.ts
+    // @__NO_SIDE_EFFECTS__
+    function _getStandardProps(context) {
       return {
-        typed: typed,
-        output: output,
-        issues: issues
+        version: 1,
+        vendor: "valibot",
+        validate: function validate(value2) {
+          return context["~run"]({
+            value: value2
+          }, getGlobalConfig());
+        }
       };
     }
 
-    // src/utils/stringify/stringify.ts
-    function stringify(input) {
-      var type = _typeof(input);
-      if (type === "object") {
-        type = input ? Object.getPrototypeOf(input).constructor.name : "null";
+    // src/utils/_isValidObjectKey/_isValidObjectKey.ts
+    // @__NO_SIDE_EFFECTS__
+    function _isValidObjectKey(object2, key) {
+      return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+    }
+
+    // src/utils/_joinExpects/_joinExpects.ts
+    // @__NO_SIDE_EFFECTS__
+    function _joinExpects(values2, separator) {
+      var _list$;
+      var list = _toConsumableArray(new Set(values2));
+      if (list.length > 1) {
+        return "(".concat(list.join(" ".concat(separator, " ")), ")");
       }
-      return type === "string" ? "\"".concat(input, "\"") : type === "number" || type === "bigint" || type === "boolean" ? "".concat(input) : type;
+      return (_list$ = list[0]) !== null && _list$ !== void 0 ? _list$ : "never";
     }
 
-    // src/utils/pipeResult/utils/pipeIssue/pipeIssue.ts
-    function pipeIssue(context, config, issue) {
-      var _issue$received;
-      var received = (_issue$received = issue.received) !== null && _issue$received !== void 0 ? _issue$received : stringify(issue.input);
-      var schemaIssue2 = {
-        reason: context.type,
-        context: issue.context.type,
-        expected: issue.context.expects,
-        received: received,
-        message: "Invalid ".concat(issue.label, ": ").concat(issue.context.expects ? "Expected ".concat(issue.context.expects, " but r") : "R", "eceived ").concat(received),
-        input: issue.input,
-        requirement: issue.context.requirement,
-        path: issue.path,
-        lang: config === null || config === void 0 ? void 0 : config.lang,
-        abortEarly: config === null || config === void 0 ? void 0 : config.abortEarly,
-        abortPipeEarly: config === null || config === void 0 ? void 0 : config.abortPipeEarly,
-        skipPipe: config === null || config === void 0 ? void 0 : config.skipPipe
+    // src/utils/ValiError/ValiError.ts
+    var ValiError = /*#__PURE__*/function (_Error) {
+      /**
+       * Creates a Valibot error with useful information.
+       *
+       * @param issues The error issues.
+       */
+      function ValiError(issues) {
+        var _this;
+        _classCallCheck(this, ValiError);
+        _this = _callSuper(this, ValiError, [issues[0].message]);
+        _this.name = "ValiError";
+        _this.issues = issues;
+        return _this;
+      }
+      _inherits(ValiError, _Error);
+      return _createClass(ValiError);
+    }(/*#__PURE__*/_wrapNativeSuper(Error));
+
+    // src/actions/check/check.ts
+    // @__NO_SIDE_EFFECTS__
+    function check(requirement, message2) {
+      return {
+        kind: "validation",
+        type: "check",
+        reference: check,
+        async: false,
+        expects: null,
+        requirement: requirement,
+        message: message2,
+        "~run": function run(dataset, config2) {
+          if (dataset.typed && !this.requirement(dataset.value)) {
+            _addIssue(this, "input", dataset, config2);
+          }
+          return dataset;
+        }
       };
-      schemaIssue2.message = i18n(false, issue.context, issue.reference, config, schemaIssue2);
-      return schemaIssue2;
     }
 
-    // src/utils/pipeResult/pipeResult.ts
-    function pipeResult(context, input, config, issues) {
-      if (context.pipe && !(config !== null && config !== void 0 && config.skipPipe)) {
-        var _iterator = _createForOfIteratorHelper(context.pipe),
-          _step;
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var action = _step.value;
-            var result = action._parse(input);
-            if (result.issues) {
-              var _iterator2 = _createForOfIteratorHelper(result.issues),
-                _step2;
-              try {
-                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                  var actionIssue2 = _step2.value;
-                  var schemaIssue2 = pipeIssue(context, config, actionIssue2);
-                  issues ? issues.push(schemaIssue2) : issues = [schemaIssue2];
-                }
-              } catch (err) {
-                _iterator2.e(err);
-              } finally {
-                _iterator2.f();
-              }
-              if (config !== null && config !== void 0 && config.abortEarly || config !== null && config !== void 0 && config.abortPipeEarly) {
-                break;
-              }
-            } else {
-              input = result.output;
-            }
+    // src/actions/notValue/notValue.ts
+    // @__NO_SIDE_EFFECTS__
+    function notValue(requirement, message2) {
+      return {
+        kind: "validation",
+        type: "not_value",
+        reference: notValue,
+        async: false,
+        expects: requirement instanceof Date ? "!".concat(requirement.toJSON()) : "!".concat(_stringify(requirement)),
+        requirement: requirement,
+        message: message2,
+        "~run": function run(dataset, config2) {
+          if (dataset.typed && this.requirement <= dataset.value && this.requirement >= dataset.value) {
+            _addIssue(this, "value", dataset, config2, {
+              received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value)
+            });
           }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
+          return dataset;
         }
-      }
-      return schemaResult(true, input, issues);
-    }
-    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/schemaIssue/schemaIssue.ts
-    function schemaIssue(context, reference, input, config, other) {
-      var _other$expected, _other$reason;
-      var received = stringify(input);
-      var expected = (_other$expected = other === null || other === void 0 ? void 0 : other.expected) !== null && _other$expected !== void 0 ? _other$expected : context.expects;
-      var issue = {
-        reason: (_other$reason = other === null || other === void 0 ? void 0 : other.reason) !== null && _other$reason !== void 0 ? _other$reason : "type",
-        context: context.type,
-        expected: expected,
-        received: received,
-        message: "Invalid type: Expected ".concat(expected, " but received ").concat(received),
-        input: input,
-        path: other === null || other === void 0 ? void 0 : other.path,
-        issues: other === null || other === void 0 ? void 0 : other.issues,
-        lang: config === null || config === void 0 ? void 0 : config.lang,
-        abortEarly: config === null || config === void 0 ? void 0 : config.abortEarly,
-        abortPipeEarly: config === null || config === void 0 ? void 0 : config.abortPipeEarly,
-        skipPipe: config === null || config === void 0 ? void 0 : config.skipPipe
-      };
-      issue.message = i18n(true, context, reference, config, issue);
+    // src/actions/regex/regex.ts
+    // @__NO_SIDE_EFFECTS__
+    function regex(requirement, message2) {
       return {
-        typed: false,
-        output: input,
-        issues: [issue]
+        kind: "validation",
+        type: "regex",
+        reference: regex,
+        async: false,
+        expects: "".concat(requirement),
+        requirement: requirement,
+        message: message2,
+        "~run": function run(dataset, config2) {
+          if (dataset.typed && !this.requirement.test(dataset.value)) {
+            _addIssue(this, "format", dataset, config2);
+          }
+          return dataset;
+        }
       };
     }
 
+    // src/methods/getFallback/getFallback.ts
+    // @__NO_SIDE_EFFECTS__
+    function getFallback(schema, dataset, config2) {
+      return typeof schema.fallback === "function" ?
+      // @ts-expect-error
+      schema.fallback(dataset, config2) :
+      // @ts-expect-error
+      schema.fallback;
+    }
+
     // src/methods/getDefault/getDefault.ts
-    function getDefault(schema) {
-      return typeof schema["default"] === "function" ? schema["default"]() : schema["default"];
+    // @__NO_SIDE_EFFECTS__
+    function getDefault(schema, dataset, config2) {
+      return typeof schema["default"] === "function" ?
+      // @ts-expect-error
+      schema["default"](dataset, config2) :
+      // @ts-expect-error
+      schema["default"];
     }
-    function is(schema, input, config) {
-      var _getGlobalConfig;
-      return !schema._parse(input, {
-        abortEarly: true,
-        skipPipe: (_getGlobalConfig = getGlobalConfig(config)) === null || _getGlobalConfig === void 0 ? void 0 : _getGlobalConfig.skipPipe
+
+    // src/methods/is/is.ts
+    // @__NO_SIDE_EFFECTS__
+    function is(schema, input) {
+      return !schema["~run"]({
+        value: input
+      }, {
+        abortEarly: true
       }).issues;
     }
 
     // src/schemas/array/array.ts
-    function array(item, arg2, arg3) {
-      var _defaultArgs5 = defaultArgs(arg2, arg3),
-        _defaultArgs6 = _slicedToArray(_defaultArgs5, 2),
-        message = _defaultArgs6[0],
-        pipe = _defaultArgs6[1];
+    // @__NO_SIDE_EFFECTS__
+    function array(item, message2) {
       return {
+        kind: "schema",
         type: "array",
+        reference: array,
         expects: "Array",
         async: false,
         item: item,
-        message: message,
-        pipe: pipe,
-        _parse: function _parse(input, config) {
+        message: message2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          var input = dataset.value;
           if (Array.isArray(input)) {
-            var typed = true;
-            var issues;
-            var output = [];
+            dataset.typed = true;
+            dataset.value = [];
             for (var key = 0; key < input.length; key++) {
               var value2 = input[key];
-              var result = this.item._parse(value2, config);
-              if (result.issues) {
+              var itemDataset = this.item["~run"]({
+                value: value2
+              }, config2);
+              if (itemDataset.issues) {
                 var pathItem = {
                   type: "array",
                   origin: "value",
@@ -702,774 +684,749 @@
                   key: key,
                   value: value2
                 };
-                var _iterator7 = _createForOfIteratorHelper(result.issues),
-                  _step7;
+                var _iterator12 = _createForOfIteratorHelper(itemDataset.issues),
+                  _step12;
                 try {
-                  for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-                    var _issues;
-                    var issue = _step7.value;
+                  for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+                    var _dataset$issues;
+                    var issue = _step12.value;
                     if (issue.path) {
                       issue.path.unshift(pathItem);
                     } else {
                       issue.path = [pathItem];
                     }
-                    (_issues = issues) === null || _issues === void 0 || _issues.push(issue);
+                    (_dataset$issues = dataset.issues) === null || _dataset$issues === void 0 || _dataset$issues.push(issue);
                   }
                 } catch (err) {
-                  _iterator7.e(err);
+                  _iterator12.e(err);
                 } finally {
-                  _iterator7.f();
+                  _iterator12.f();
                 }
-                if (!issues) {
-                  issues = result.issues;
+                if (!dataset.issues) {
+                  dataset.issues = itemDataset.issues;
                 }
-                if (config !== null && config !== void 0 && config.abortEarly) {
-                  typed = false;
+                if (config2.abortEarly) {
+                  dataset.typed = false;
                   break;
                 }
               }
-              if (!result.typed) {
-                typed = false;
+              if (!itemDataset.typed) {
+                dataset.typed = false;
               }
-              output.push(result.output);
-            }
-            if (typed) {
-              return pipeResult(this, output, config, issues);
+              dataset.value.push(itemDataset.value);
             }
-            return schemaResult(false, output, issues);
+          } else {
+            _addIssue(this, "type", dataset, config2);
           }
-          return schemaIssue(this, array, input, config);
+          return dataset;
         }
       };
     }
 
     // src/schemas/boolean/boolean.ts
-    function _boolean(arg1, arg2) {
-      var _defaultArgs17 = defaultArgs(arg1, arg2),
-        _defaultArgs18 = _slicedToArray(_defaultArgs17, 2),
-        message = _defaultArgs18[0],
-        pipe = _defaultArgs18[1];
+    // @__NO_SIDE_EFFECTS__
+    function _boolean(message2) {
       return {
+        kind: "schema",
         type: "boolean",
+        reference: _boolean,
         expects: "boolean",
         async: false,
-        message: message,
-        pipe: pipe,
-        _parse: function _parse(input, config) {
-          if (typeof input === "boolean") {
-            return pipeResult(this, input, config);
+        message: message2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          if (typeof dataset.value === "boolean") {
+            dataset.typed = true;
+          } else {
+            _addIssue(this, "type", dataset, config2);
           }
-          return schemaIssue(this, _boolean, input, config);
+          return dataset;
         }
       };
     }
 
     // src/schemas/instance/instance.ts
-    function instance(class_, arg2, arg3) {
-      var _defaultArgs25 = defaultArgs(arg2, arg3),
-        _defaultArgs26 = _slicedToArray(_defaultArgs25, 2),
-        message = _defaultArgs26[0],
-        pipe = _defaultArgs26[1];
+    // @__NO_SIDE_EFFECTS__
+    function instance(class_, message2) {
       return {
+        kind: "schema",
         type: "instance",
+        reference: instance,
         expects: class_.name,
         async: false,
         "class": class_,
-        message: message,
-        pipe: pipe,
-        _parse: function _parse(input, config) {
-          if (input instanceof this["class"]) {
-            return pipeResult(this, input, config);
+        message: message2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          if (dataset.value instanceof this["class"]) {
+            dataset.typed = true;
+          } else {
+            _addIssue(this, "type", dataset, config2);
           }
-          return schemaIssue(this, instance, input, config);
+          return dataset;
         }
       };
     }
 
-    // src/schemas/intersect/utils/mergeOutputs/mergeOutputs.ts
-    function mergeOutputs(output1, output2) {
-      if (_typeof(output1) === _typeof(output2)) {
-        if (output1 === output2 || output1 instanceof Date && output2 instanceof Date && +output1 === +output2) {
+    // src/schemas/intersect/utils/_merge/_merge.ts
+    // @__NO_SIDE_EFFECTS__
+    function _merge(value1, value2) {
+      if (_typeof(value1) === _typeof(value2)) {
+        if (value1 === value2 || value1 instanceof Date && value2 instanceof Date && +value1 === +value2) {
           return {
-            output: output1
+            value: value1
           };
         }
-        if (Array.isArray(output1) && Array.isArray(output2)) {
-          if (output1.length === output2.length) {
-            var array2 = [];
-            for (var index = 0; index < output1.length; index++) {
-              var result = mergeOutputs(output1[index], output2[index]);
-              if (result.invalid) {
-                return result;
+        if (value1 && value2 && value1.constructor === Object && value2.constructor === Object) {
+          for (var key in value2) {
+            if (key in value1) {
+              var dataset = /* @__PURE__ */_merge(value1[key], value2[key]);
+              if (dataset.issue) {
+                return dataset;
               }
-              array2.push(result.output);
+              value1[key] = dataset.value;
+            } else {
+              value1[key] = value2[key];
             }
-            return {
-              output: array2
-            };
           }
           return {
-            invalid: true
+            value: value1
           };
         }
-        if (output1 && output2 && output1.constructor === Object && output2.constructor === Object) {
-          var object2 = _objectSpread2(_objectSpread2({}, output1), output2);
-          for (var key in output1) {
-            if (key in output2) {
-              var _result = mergeOutputs(output1[key], output2[key]);
-              if (_result.invalid) {
-                return _result;
+        if (Array.isArray(value1) && Array.isArray(value2)) {
+          if (value1.length === value2.length) {
+            for (var index = 0; index < value1.length; index++) {
+              var _dataset = /* @__PURE__ */_merge(value1[index], value2[index]);
+              if (_dataset.issue) {
+                return _dataset;
               }
-              object2[key] = _result.output;
+              value1[index] = _dataset.value;
             }
+            return {
+              value: value1
+            };
           }
-          return {
-            output: object2
-          };
         }
       }
       return {
-        invalid: true
+        issue: true
       };
     }
 
     // src/schemas/intersect/intersect.ts
-    function intersect(options, arg2, arg3) {
-      var _defaultArgs29 = defaultArgs(arg2, arg3),
-        _defaultArgs30 = _slicedToArray(_defaultArgs29, 2),
-        message = _defaultArgs30[0],
-        pipe = _defaultArgs30[1];
+    // @__NO_SIDE_EFFECTS__
+    function intersect(options, message2) {
       return {
+        kind: "schema",
         type: "intersect",
-        expects: _toConsumableArray(new Set(options.map(function (option) {
+        reference: intersect,
+        expects: _joinExpects(options.map(function (option) {
           return option.expects;
-        }))).join(" & "),
+        }), "&"),
         async: false,
         options: options,
-        message: message,
-        pipe: pipe,
-        _parse: function _parse(input, config) {
-          var typed = true;
-          var issues;
-          var output;
-          var outputs = [];
-          var _iterator9 = _createForOfIteratorHelper(this.options),
-            _step9;
-          try {
-            for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-              var schema = _step9.value;
-              var _result2 = schema._parse(input, config);
-              if (_result2.issues) {
-                if (issues) {
-                  var _iterator10 = _createForOfIteratorHelper(_result2.issues),
-                    _step10;
-                  try {
-                    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
-                      var issue = _step10.value;
-                      issues.push(issue);
-                    }
-                  } catch (err) {
-                    _iterator10.e(err);
-                  } finally {
-                    _iterator10.f();
+        message: message2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          if (this.options.length) {
+            var input = dataset.value;
+            var outputs;
+            dataset.typed = true;
+            var _iterator14 = _createForOfIteratorHelper(this.options),
+              _step14;
+            try {
+              for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+                var schema = _step14.value;
+                var optionDataset = schema["~run"]({
+                  value: input
+                }, config2);
+                if (optionDataset.issues) {
+                  if (dataset.issues) {
+                    var _dataset$issues3;
+                    (_dataset$issues3 = dataset.issues).push.apply(_dataset$issues3, _toConsumableArray(optionDataset.issues));
+                  } else {
+                    dataset.issues = optionDataset.issues;
+                  }
+                  if (config2.abortEarly) {
+                    dataset.typed = false;
+                    break;
                   }
-                } else {
-                  issues = _result2.issues;
                 }
-                if (config !== null && config !== void 0 && config.abortEarly) {
-                  typed = false;
-                  break;
+                if (!optionDataset.typed) {
+                  dataset.typed = false;
+                }
+                if (dataset.typed) {
+                  if (outputs) {
+                    outputs.push(optionDataset.value);
+                  } else {
+                    outputs = [optionDataset.value];
+                  }
                 }
               }
-              if (!_result2.typed) {
-                typed = false;
-              }
-              outputs.push(_result2.output);
-            }
-          } catch (err) {
-            _iterator9.e(err);
-          } finally {
-            _iterator9.f();
-          }
-          if (typed) {
-            output = outputs[0];
-            for (var index = 1; index < outputs.length; index++) {
-              var result = mergeOutputs(output, outputs[index]);
-              if (result.invalid) {
-                return schemaIssue(this, intersect, input, config);
+            } catch (err) {
+              _iterator14.e(err);
+            } finally {
+              _iterator14.f();
+            }
+            if (dataset.typed) {
+              dataset.value = outputs[0];
+              for (var index = 1; index < outputs.length; index++) {
+                var mergeDataset = _merge(dataset.value, outputs[index]);
+                if (mergeDataset.issue) {
+                  _addIssue(this, "type", dataset, config2, {
+                    received: "unknown"
+                  });
+                  break;
+                }
+                dataset.value = mergeDataset.value;
               }
-              output = result.output;
             }
-            return pipeResult(this, output, config, issues);
+          } else {
+            _addIssue(this, "type", dataset, config2);
           }
-          return schemaResult(false, output, issues);
+          return dataset;
         }
       };
     }
 
     // src/schemas/literal/literal.ts
-    function literal(literal_, message) {
+    // @__NO_SIDE_EFFECTS__
+    function literal(literal_, message2) {
       return {
+        kind: "schema",
         type: "literal",
-        expects: stringify(literal_),
+        reference: literal,
+        expects: _stringify(literal_),
         async: false,
         literal: literal_,
-        message: message,
-        _parse: function _parse(input, config) {
-          if (input === this.literal) {
-            return schemaResult(true, input);
+        message: message2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          if (dataset.value === this.literal) {
+            dataset.typed = true;
+          } else {
+            _addIssue(this, "type", dataset, config2);
           }
-          return schemaIssue(this, literal, input, config);
+          return dataset;
         }
       };
     }
 
     // src/schemas/nullable/nullable.ts
+    // @__NO_SIDE_EFFECTS__
     function nullable(wrapped, default_) {
       return {
+        kind: "schema",
         type: "nullable",
-        expects: "".concat(wrapped.expects, " | null"),
+        reference: nullable,
+        expects: "(".concat(wrapped.expects, " | null)"),
         async: false,
         wrapped: wrapped,
         "default": default_,
-        _parse: function _parse(input, config) {
-          if (input === null) {
-            var override = getDefault(this);
-            if (override === void 0) {
-              return schemaResult(true, input);
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          if (dataset.value === null) {
+            if (this["default"] !== void 0) {
+              dataset.value = getDefault(this, dataset, config2);
+            }
+            if (dataset.value === null) {
+              dataset.typed = true;
+              return dataset;
             }
-            input = override;
           }
-          return this.wrapped._parse(input, config);
+          return this.wrapped["~run"](dataset, config2);
         }
       };
     }
 
     // src/schemas/number/number.ts
-    function number(arg1, arg2) {
-      var _defaultArgs37 = defaultArgs(arg1, arg2),
-        _defaultArgs38 = _slicedToArray(_defaultArgs37, 2),
-        message = _defaultArgs38[0],
-        pipe = _defaultArgs38[1];
+    // @__NO_SIDE_EFFECTS__
+    function number(message2) {
       return {
+        kind: "schema",
         type: "number",
+        reference: number,
         expects: "number",
         async: false,
-        message: message,
-        pipe: pipe,
-        _parse: function _parse(input, config) {
-          if (typeof input === "number" && !isNaN(input)) {
-            return pipeResult(this, input, config);
+        message: message2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
+            dataset.typed = true;
+          } else {
+            _addIssue(this, "type", dataset, config2);
           }
-          return schemaIssue(this, number, input, config);
+          return dataset;
         }
       };
     }
 
     // src/schemas/object/object.ts
-    function object(entries, arg2, arg3, arg4) {
-      var _restAndDefaultArgs = restAndDefaultArgs(arg2, arg3, arg4),
-        _restAndDefaultArgs2 = _slicedToArray(_restAndDefaultArgs, 3),
-        rest = _restAndDefaultArgs2[0],
-        message = _restAndDefaultArgs2[1],
-        pipe = _restAndDefaultArgs2[2];
-      var cachedEntries;
+    // @__NO_SIDE_EFFECTS__
+    function object(entries2, message2) {
       return {
+        kind: "schema",
         type: "object",
+        reference: object,
         expects: "Object",
         async: false,
-        entries: entries,
-        rest: rest,
-        message: message,
-        pipe: pipe,
-        _parse: function _parse(input, config) {
+        entries: entries2,
+        message: message2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          var input = dataset.value;
           if (input && _typeof(input) === "object") {
-            var _cachedEntries;
-            cachedEntries = (_cachedEntries = cachedEntries) !== null && _cachedEntries !== void 0 ? _cachedEntries : Object.entries(this.entries);
-            var typed = true;
-            var issues;
-            var output = {};
-            var _iterator16 = _createForOfIteratorHelper(cachedEntries),
-              _step16;
-            try {
-              for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
-                var _step16$value = _slicedToArray(_step16.value, 2),
-                  _key = _step16$value[0],
-                  schema = _step16$value[1];
-                var _value = input[_key];
-                var _result3 = schema._parse(_value, config);
-                if (_result3.issues) {
-                  var _pathItem3 = {
+            dataset.typed = true;
+            dataset.value = {};
+            for (var key in this.entries) {
+              var valueSchema = this.entries[key];
+              if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") &&
+              // @ts-expect-error
+              valueSchema["default"] !== void 0) {
+                var value2 = key in input ?
+                // @ts-expect-error
+                input[key] : getDefault(valueSchema);
+                var valueDataset = valueSchema["~run"]({
+                  value: value2
+                }, config2);
+                if (valueDataset.issues) {
+                  var pathItem = {
                     type: "object",
                     origin: "value",
                     input: input,
-                    key: _key,
-                    value: _value
+                    key: key,
+                    value: value2
                   };
-                  var _iterator18 = _createForOfIteratorHelper(_result3.issues),
-                    _step18;
+                  var _iterator28 = _createForOfIteratorHelper(valueDataset.issues),
+                    _step28;
                   try {
-                    for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
-                      var _issues7;
-                      var _issue2 = _step18.value;
-                      if (_issue2.path) {
-                        _issue2.path.unshift(_pathItem3);
+                    for (_iterator28.s(); !(_step28 = _iterator28.n()).done;) {
+                      var _dataset$issues11;
+                      var issue = _step28.value;
+                      if (issue.path) {
+                        issue.path.unshift(pathItem);
                       } else {
-                        _issue2.path = [_pathItem3];
+                        issue.path = [pathItem];
                       }
-                      (_issues7 = issues) === null || _issues7 === void 0 || _issues7.push(_issue2);
+                      (_dataset$issues11 = dataset.issues) === null || _dataset$issues11 === void 0 || _dataset$issues11.push(issue);
                     }
                   } catch (err) {
-                    _iterator18.e(err);
+                    _iterator28.e(err);
                   } finally {
-                    _iterator18.f();
+                    _iterator28.f();
                   }
-                  if (!issues) {
-                    issues = _result3.issues;
+                  if (!dataset.issues) {
+                    dataset.issues = valueDataset.issues;
                   }
-                  if (config !== null && config !== void 0 && config.abortEarly) {
-                    typed = false;
+                  if (config2.abortEarly) {
+                    dataset.typed = false;
                     break;
                   }
                 }
-                if (!_result3.typed) {
-                  typed = false;
-                }
-                if (_result3.output !== void 0 || _key in input) {
-                  output[_key] = _result3.output;
+                if (!valueDataset.typed) {
+                  dataset.typed = false;
                 }
-              }
-            } catch (err) {
-              _iterator16.e(err);
-            } finally {
-              _iterator16.f();
-            }
-            if (this.rest && !(config !== null && config !== void 0 && config.abortEarly && issues)) {
-              for (var key in input) {
-                if (!(key in this.entries)) {
-                  var value2 = input[key];
-                  var result = this.rest._parse(value2, config);
-                  if (result.issues) {
-                    var pathItem = {
-                      type: "object",
-                      origin: "value",
-                      input: input,
-                      key: key,
-                      value: value2
-                    };
-                    var _iterator17 = _createForOfIteratorHelper(result.issues),
-                      _step17;
-                    try {
-                      for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
-                        var _issues6;
-                        var issue = _step17.value;
-                        if (issue.path) {
-                          issue.path.unshift(pathItem);
-                        } else {
-                          issue.path = [pathItem];
-                        }
-                        (_issues6 = issues) === null || _issues6 === void 0 || _issues6.push(issue);
-                      }
-                    } catch (err) {
-                      _iterator17.e(err);
-                    } finally {
-                      _iterator17.f();
-                    }
-                    if (!issues) {
-                      issues = result.issues;
-                    }
-                    if (config !== null && config !== void 0 && config.abortEarly) {
-                      typed = false;
-                      break;
-                    }
-                  }
-                  if (!result.typed) {
-                    typed = false;
-                  }
-                  output[key] = result.output;
+                dataset.value[key] = valueDataset.value;
+              } else if (valueSchema.fallback !== void 0) {
+                dataset.value[key] = getFallback(valueSchema);
+              } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+                _addIssue(this, "key", dataset, config2, {
+                  input: void 0,
+                  expected: "\"".concat(key, "\""),
+                  path: [{
+                    type: "object",
+                    origin: "key",
+                    input: input,
+                    key: key,
+                    // @ts-expect-error
+                    value: input[key]
+                  }]
+                });
+                if (config2.abortEarly) {
+                  break;
                 }
               }
             }
-            if (typed) {
-              return pipeResult(this, output, config, issues);
-            }
-            return schemaResult(false, output, issues);
+          } else {
+            _addIssue(this, "type", dataset, config2);
           }
-          return schemaIssue(this, object, input, config);
+          return dataset;
         }
       };
     }
 
     // src/schemas/optional/optional.ts
+    // @__NO_SIDE_EFFECTS__
     function optional(wrapped, default_) {
       return {
+        kind: "schema",
         type: "optional",
-        expects: "".concat(wrapped.expects, " | undefined"),
+        reference: optional,
+        expects: "(".concat(wrapped.expects, " | undefined)"),
         async: false,
         wrapped: wrapped,
         "default": default_,
-        _parse: function _parse(input, config) {
-          if (input === void 0) {
-            var override = getDefault(this);
-            if (override === void 0) {
-              return schemaResult(true, input);
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          if (dataset.value === void 0) {
+            if (this["default"] !== void 0) {
+              dataset.value = getDefault(this, dataset, config2);
+            }
+            if (dataset.value === void 0) {
+              dataset.typed = true;
+              return dataset;
             }
-            input = override;
-          }
-          return this.wrapped._parse(input, config);
-        }
-      };
-    }
-
-    // src/schemas/string/string.ts
-    function string(arg1, arg2) {
-      var _defaultArgs41 = defaultArgs(arg1, arg2),
-        _defaultArgs42 = _slicedToArray(_defaultArgs41, 2),
-        message = _defaultArgs42[0],
-        pipe = _defaultArgs42[1];
-      return {
-        type: "string",
-        expects: "string",
-        async: false,
-        message: message,
-        pipe: pipe,
-        _parse: function _parse(input, config) {
-          if (typeof input === "string") {
-            return pipeResult(this, input, config);
           }
-          return schemaIssue(this, string, input, config);
+          return this.wrapped["~run"](dataset, config2);
         }
       };
     }
 
-    // src/schemas/record/utils/recordArgs/recordArgs.ts
-    function recordArgs(arg1, arg2, arg3, arg4) {
-      if (_typeof(arg2) === "object" && !Array.isArray(arg2)) {
-        var _defaultArgs45 = defaultArgs(arg3, arg4),
-          _defaultArgs46 = _slicedToArray(_defaultArgs45, 2),
-          message2 = _defaultArgs46[0],
-          pipe2 = _defaultArgs46[1];
-        return [arg1, arg2, message2, pipe2];
-      }
-      var _defaultArgs47 = defaultArgs(arg2, arg3),
-        _defaultArgs48 = _slicedToArray(_defaultArgs47, 2),
-        message = _defaultArgs48[0],
-        pipe = _defaultArgs48[1];
-      return [string(), arg1, message, pipe];
-    }
-
-    // src/schemas/record/values.ts
-    var BLOCKED_KEYS = ["__proto__", "prototype", "constructor"];
-
     // src/schemas/record/record.ts
-    function record(arg1, arg2, arg3, arg4) {
-      var _recordArgs = recordArgs(arg1, arg2, arg3, arg4),
-        _recordArgs2 = _slicedToArray(_recordArgs, 4),
-        key = _recordArgs2[0],
-        value2 = _recordArgs2[1],
-        message = _recordArgs2[2],
-        pipe = _recordArgs2[3];
+    // @__NO_SIDE_EFFECTS__
+    function record(key, value2, message2) {
       return {
+        kind: "schema",
         type: "record",
+        reference: record,
         expects: "Object",
         async: false,
         key: key,
         value: value2,
-        message: message,
-        pipe: pipe,
-        _parse: function _parse(input, config) {
+        message: message2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          var input = dataset.value;
           if (input && _typeof(input) === "object") {
-            var typed = true;
-            var issues;
-            var output = {};
-            for (var _i = 0, _Object$entries = Object.entries(input); _i < _Object$entries.length; _i++) {
-              var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-                inputKey = _Object$entries$_i[0],
-                inputValue = _Object$entries$_i[1];
-              if (!BLOCKED_KEYS.includes(inputKey)) {
-                var pathItem = void 0;
-                var keyResult = this.key._parse(inputKey, config);
-                if (keyResult.issues) {
-                  pathItem = {
-                    type: "record",
+            dataset.typed = true;
+            dataset.value = {};
+            for (var entryKey in input) {
+              if (_isValidObjectKey(input, entryKey)) {
+                var entryValue = input[entryKey];
+                var keyDataset = this.key["~run"]({
+                  value: entryKey
+                }, config2);
+                if (keyDataset.issues) {
+                  var pathItem = {
+                    type: "object",
                     origin: "key",
                     input: input,
-                    key: inputKey,
-                    value: inputValue
+                    key: entryKey,
+                    value: entryValue
                   };
-                  var _iterator21 = _createForOfIteratorHelper(keyResult.issues),
-                    _step21;
+                  var _iterator37 = _createForOfIteratorHelper(keyDataset.issues),
+                    _step37;
                   try {
-                    for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
-                      var _issues10;
-                      var issue = _step21.value;
+                    for (_iterator37.s(); !(_step37 = _iterator37.n()).done;) {
+                      var _dataset$issues17;
+                      var issue = _step37.value;
                       issue.path = [pathItem];
-                      (_issues10 = issues) === null || _issues10 === void 0 || _issues10.push(issue);
+                      (_dataset$issues17 = dataset.issues) === null || _dataset$issues17 === void 0 || _dataset$issues17.push(issue);
                     }
                   } catch (err) {
-                    _iterator21.e(err);
+                    _iterator37.e(err);
                   } finally {
-                    _iterator21.f();
+                    _iterator37.f();
                   }
-                  if (!issues) {
-                    issues = keyResult.issues;
+                  if (!dataset.issues) {
+                    dataset.issues = keyDataset.issues;
                   }
-                  if (config !== null && config !== void 0 && config.abortEarly) {
-                    typed = false;
+                  if (config2.abortEarly) {
+                    dataset.typed = false;
                     break;
                   }
                 }
-                var valueResult = this.value._parse(inputValue, config);
-                if (valueResult.issues) {
-                  var _pathItem4;
-                  pathItem = (_pathItem4 = pathItem) !== null && _pathItem4 !== void 0 ? _pathItem4 : {
-                    type: "record",
+                var valueDataset = this.value["~run"]({
+                  value: entryValue
+                }, config2);
+                if (valueDataset.issues) {
+                  var _pathItem5 = {
+                    type: "object",
                     origin: "value",
                     input: input,
-                    key: inputKey,
-                    value: inputValue
+                    key: entryKey,
+                    value: entryValue
                   };
-                  var _iterator22 = _createForOfIteratorHelper(valueResult.issues),
-                    _step22;
+                  var _iterator38 = _createForOfIteratorHelper(valueDataset.issues),
+                    _step38;
                   try {
-                    for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
-                      var _issues11;
-                      var _issue3 = _step22.value;
-                      if (_issue3.path) {
-                        _issue3.path.unshift(pathItem);
+                    for (_iterator38.s(); !(_step38 = _iterator38.n()).done;) {
+                      var _dataset$issues18;
+                      var _issue5 = _step38.value;
+                      if (_issue5.path) {
+                        _issue5.path.unshift(_pathItem5);
                       } else {
-                        _issue3.path = [pathItem];
+                        _issue5.path = [_pathItem5];
                       }
-                      (_issues11 = issues) === null || _issues11 === void 0 || _issues11.push(_issue3);
+                      (_dataset$issues18 = dataset.issues) === null || _dataset$issues18 === void 0 || _dataset$issues18.push(_issue5);
                     }
                   } catch (err) {
-                    _iterator22.e(err);
+                    _iterator38.e(err);
                   } finally {
-                    _iterator22.f();
+                    _iterator38.f();
                   }
-                  if (!issues) {
-                    issues = valueResult.issues;
+                  if (!dataset.issues) {
+                    dataset.issues = valueDataset.issues;
                   }
-                  if (config !== null && config !== void 0 && config.abortEarly) {
-                    typed = false;
+                  if (config2.abortEarly) {
+                    dataset.typed = false;
                     break;
                   }
                 }
-                if (!keyResult.typed || !valueResult.typed) {
-                  typed = false;
+                if (!keyDataset.typed || !valueDataset.typed) {
+                  dataset.typed = false;
                 }
-                if (keyResult.typed) {
-                  output[keyResult.output] = valueResult.output;
+                if (keyDataset.typed) {
+                  dataset.value[keyDataset.value] = valueDataset.value;
                 }
               }
             }
-            if (typed) {
-              return pipeResult(this, output, config, issues);
-            }
-            return schemaResult(false, output, issues);
+          } else {
+            _addIssue(this, "type", dataset, config2);
+          }
+          return dataset;
+        }
+      };
+    }
+
+    // src/schemas/string/string.ts
+    // @__NO_SIDE_EFFECTS__
+    function string(message2) {
+      return {
+        kind: "schema",
+        type: "string",
+        reference: string,
+        expects: "string",
+        async: false,
+        message: message2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          if (typeof dataset.value === "string") {
+            dataset.typed = true;
+          } else {
+            _addIssue(this, "type", dataset, config2);
           }
-          return schemaIssue(this, record, input, config);
+          return dataset;
         }
       };
     }
 
-    // src/schemas/union/utils/subissues/subissues.ts
-    function subissues(results) {
+    // src/schemas/union/utils/_subIssues/_subIssues.ts
+    // @__NO_SIDE_EFFECTS__
+    function _subIssues(datasets) {
       var issues;
-      if (results) {
-        var _iterator31 = _createForOfIteratorHelper(results),
-          _step31;
+      if (datasets) {
+        var _iterator61 = _createForOfIteratorHelper(datasets),
+          _step61;
         try {
-          for (_iterator31.s(); !(_step31 = _iterator31.n()).done;) {
-            var result = _step31.value;
+          for (_iterator61.s(); !(_step61 = _iterator61.n()).done;) {
+            var dataset = _step61.value;
             if (issues) {
-              var _iterator32 = _createForOfIteratorHelper(result.issues),
-                _step32;
-              try {
-                for (_iterator32.s(); !(_step32 = _iterator32.n()).done;) {
-                  var issue = _step32.value;
-                  issues.push(issue);
-                }
-              } catch (err) {
-                _iterator32.e(err);
-              } finally {
-                _iterator32.f();
-              }
+              var _issues;
+              (_issues = issues).push.apply(_issues, _toConsumableArray(dataset.issues));
             } else {
-              issues = result.issues;
+              issues = dataset.issues;
             }
           }
         } catch (err) {
-          _iterator31.e(err);
+          _iterator61.e(err);
         } finally {
-          _iterator31.f();
+          _iterator61.f();
         }
       }
       return issues;
     }
 
     // src/schemas/union/union.ts
-    function union(options, arg2, arg3) {
-      var _defaultArgs57 = defaultArgs(arg2, arg3),
-        _defaultArgs58 = _slicedToArray(_defaultArgs57, 2),
-        message = _defaultArgs58[0],
-        pipe = _defaultArgs58[1];
+    // @__NO_SIDE_EFFECTS__
+    function union(options, message2) {
       return {
+        kind: "schema",
         type: "union",
-        expects: _toConsumableArray(new Set(options.map(function (option) {
+        reference: union,
+        expects: _joinExpects(options.map(function (option) {
           return option.expects;
-        }))).join(" | "),
+        }), "|"),
         async: false,
         options: options,
-        message: message,
-        pipe: pipe,
-        _parse: function _parse(input, config) {
-          var _typedResults, _untypedResults;
-          var validResult;
-          var untypedResults;
-          var typedResults;
-          var _iterator33 = _createForOfIteratorHelper(this.options),
-            _step33;
+        message: message2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          var _untypedDatasets;
+          var validDataset;
+          var typedDatasets;
+          var untypedDatasets;
+          var _iterator62 = _createForOfIteratorHelper(this.options),
+            _step62;
           try {
-            for (_iterator33.s(); !(_step33 = _iterator33.n()).done;) {
-              var schema = _step33.value;
-              var result = schema._parse(input, config);
-              if (result.typed) {
-                if (!result.issues) {
-                  validResult = result;
-                  break;
+            for (_iterator62.s(); !(_step62 = _iterator62.n()).done;) {
+              var schema = _step62.value;
+              var optionDataset = schema["~run"]({
+                value: dataset.value
+              }, config2);
+              if (optionDataset.typed) {
+                if (optionDataset.issues) {
+                  if (typedDatasets) {
+                    typedDatasets.push(optionDataset);
+                  } else {
+                    typedDatasets = [optionDataset];
+                  }
                 } else {
-                  typedResults ? typedResults.push(result) : typedResults = [result];
+                  validDataset = optionDataset;
+                  break;
                 }
               } else {
-                untypedResults ? untypedResults.push(result) : untypedResults = [result];
+                if (untypedDatasets) {
+                  untypedDatasets.push(optionDataset);
+                } else {
+                  untypedDatasets = [optionDataset];
+                }
               }
             }
           } catch (err) {
-            _iterator33.e(err);
+            _iterator62.e(err);
           } finally {
-            _iterator33.f();
+            _iterator62.f();
           }
-          if (validResult) {
-            return pipeResult(this, validResult.output, config);
+          if (validDataset) {
+            return validDataset;
           }
-          if ((_typedResults = typedResults) !== null && _typedResults !== void 0 && _typedResults.length) {
-            var firstResult = typedResults[0];
-            return pipeResult(this, firstResult.output, config,
-            // Hint: If there is more than one typed result, we use a general
-            // union issue with subissues because the issues could contradict
-            // each other.
-            typedResults.length === 1 ? firstResult.issues : schemaIssue(this, union, input, config, {
-              reason: "union",
-              issues: subissues(typedResults)
-            }).issues);
-          }
-          if (((_untypedResults = untypedResults) === null || _untypedResults === void 0 ? void 0 : _untypedResults.length) === 1) {
-            return untypedResults[0];
+          if (typedDatasets) {
+            if (typedDatasets.length === 1) {
+              return typedDatasets[0];
+            }
+            _addIssue(this, "type", dataset, config2, {
+              issues: _subIssues(typedDatasets)
+            });
+            dataset.typed = true;
+          } else if (((_untypedDatasets = untypedDatasets) === null || _untypedDatasets === void 0 ? void 0 : _untypedDatasets.length) === 1) {
+            return untypedDatasets[0];
+          } else {
+            _addIssue(this, "type", dataset, config2, {
+              issues: _subIssues(untypedDatasets)
+            });
           }
-          return schemaIssue(this, union, input, config, {
-            issues: subissues(untypedResults)
-          });
+          return dataset;
         }
       };
     }
 
     // src/schemas/unknown/unknown.ts
-    function unknown(pipe) {
+    // @__NO_SIDE_EFFECTS__
+    function unknown() {
       return {
+        kind: "schema",
         type: "unknown",
+        reference: unknown,
         expects: "unknown",
         async: false,
-        pipe: pipe,
-        _parse: function _parse(input, config) {
-          return pipeResult(this, input, config);
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset) {
+          dataset.typed = true;
+          return dataset;
         }
       };
     }
 
     // src/methods/omit/omit.ts
-    function omit(schema, keys, arg3, arg4, arg5) {
-      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, _ref33) {
-        var _ref34 = _slicedToArray(_ref33, 2),
-          key = _ref34[0],
-          schema2 = _ref34[1];
-        return keys.includes(key) ? entries : _objectSpread2(_objectSpread2({}, entries), {}, _defineProperty({}, key, schema2));
-      }, {}), rest, message, pipe);
+    // @__NO_SIDE_EFFECTS__
+    function omit(schema, keys) {
+      var entries2 = _objectSpread2({}, schema.entries);
+      var _iterator68 = _createForOfIteratorHelper(keys),
+        _step68;
+      try {
+        for (_iterator68.s(); !(_step68 = _iterator68.n()).done;) {
+          var key = _step68.value;
+          delete entries2[key];
+        }
+      } catch (err) {
+        _iterator68.e(err);
+      } finally {
+        _iterator68.f();
+      }
+      return _objectSpread2(_objectSpread2({}, schema), {}, {
+        entries: entries2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        }
+      });
     }
 
     // src/methods/parse/parse.ts
-    function parse(schema, input, config) {
-      var result = schema._parse(input, getGlobalConfig(config));
-      if (result.issues) {
-        throw new ValiError(result.issues);
+    function parse(schema, input, config2) {
+      var dataset = schema["~run"]({
+        value: input
+      }, getGlobalConfig(config2));
+      if (dataset.issues) {
+        throw new ValiError(dataset.issues);
       }
-      return result.output;
+      return dataset.value;
     }
 
-    // src/methods/safeParse/safeParse.ts
-    function safeParse(schema, input, config) {
-      var result = schema._parse(input, getGlobalConfig(config));
-      return {
-        typed: result.typed,
-        success: !result.issues,
-        output: result.output,
-        issues: result.issues
-      };
-    }
-
-    // src/validations/custom/custom.ts
-    function custom(requirement, message) {
-      return {
-        type: "custom",
-        expects: null,
-        async: false,
-        message: message,
-        requirement: requirement,
-        _parse: function _parse(input) {
-          if (this.requirement(input)) {
-            return actionOutput(input);
-          }
-          return actionIssue(this, custom, input, "input");
-        }
-      };
-    }
-
-    // src/validations/notValue/notValue.ts
-    function notValue(requirement, message) {
-      return {
-        type: "not_value",
-        expects: "!".concat(requirement instanceof Date ? requirement.toJSON() : stringify(requirement)),
-        async: false,
-        message: message,
-        requirement: requirement,
-        _parse: function _parse(input) {
-          if (input < this.requirement || input > this.requirement) {
-            return actionOutput(input);
+    // src/methods/pipe/pipe.ts
+    // @__NO_SIDE_EFFECTS__
+    function pipe() {
+      for (var _len3 = arguments.length, pipe2 = new Array(_len3), _key11 = 0; _key11 < _len3; _key11++) {
+        pipe2[_key11] = arguments[_key11];
+      }
+      return _objectSpread2(_objectSpread2({}, pipe2[0]), {}, {
+        pipe: pipe2,
+        get "~standard"() {
+          return _getStandardProps(this);
+        },
+        "~run": function run(dataset, config2) {
+          for (var _i2 = 0, _pipe = pipe2; _i2 < _pipe.length; _i2++) {
+            var item = _pipe[_i2];
+            if (item.kind !== "metadata") {
+              if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+                dataset.typed = false;
+                break;
+              }
+              if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
+                dataset = item["~run"](dataset, config2);
+              }
+            }
           }
-          return actionIssue(this, notValue, input, "value", input instanceof Date ? input.toJSON() : stringify(input));
+          return dataset;
         }
-      };
+      });
     }
 
-    // src/validations/regex/regex.ts
-    function regex(requirement, message) {
+    // src/methods/safeParse/safeParse.ts
+    // @__NO_SIDE_EFFECTS__
+    function safeParse(schema, input, config2) {
+      var dataset = schema["~run"]({
+        value: input
+      }, getGlobalConfig(config2));
       return {
-        type: "regex",
-        expects: "".concat(requirement),
-        async: false,
-        message: message,
-        requirement: requirement,
-        _parse: function _parse(input) {
-          if (this.requirement.test(input)) {
-            return actionOutput(input);
-          }
-          return actionIssue(this, regex, input, "format");
-        }
+        typed: dataset.typed,
+        success: !dataset.issues,
+        output: dataset.value,
+        issues: dataset.issues
       };
     }
 
@@ -1514,7 +1471,7 @@
     });
     const ZRawApiResponse = union([
         object({ chat: ZApiChat }),
-        record(string([notValue("chat")]), unknown()),
+        record(pipe(string(), notValue("chat")), unknown()),
     ]);
     const ZApiPing = object({
         content: string(),
@@ -1603,11 +1560,6 @@
         literal("gulim"),
         literal("simsun"),
     ]);
-    union([
-        literal("defont"),
-        literal("mincho"),
-        literal("gothic"),
-    ]);
     const ZCommentFlashFont = union([
         literal("defont"),
         literal("gulim"),
@@ -1754,17 +1706,15 @@
             chatItem: (i) => is(ZXml2jsChatItem, i),
         },
         legacyOwner: {
-            comments: (i) => is(string([
-                custom((i) => {
-                    const lists = i.split(/\r\n|\r|\n/);
-                    for (const list of lists) {
-                        if (list.split(":").length < 3) {
-                            return false;
-                        }
+            comments: (i) => is(pipe(string(), check((i) => {
+                const lists = i.split(/\r\n|\r|\n/);
+                for (const list of lists) {
+                    if (list.split(":").length < 3) {
+                        return false;
                     }
-                    return true;
-                }),
-            ]), i),
+                }
+                return true;
+            })), i),
         },
         owner: {
             comment: (i) => is(ZOwnerComment, i),
@@ -1798,11 +1748,9 @@
                     literal("invisible"),
                 ]), i),
             },
-            color: (i) => is(string([custom((i) => Object.keys(colors).includes(i))]), i),
-            colorCode: (i) => is(string([regex(/^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6})$/)]), i),
-            colorCodeAllowAlpha: (i) => is(string([
-                regex(/^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/),
-            ]), i),
+            color: (i) => is(pipe(string(), check((i) => Object.keys(colors).includes(i))), i),
+            colorCode: (i) => is(pipe(string(), regex(/^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6})$/)), i),
+            colorCodeAllowAlpha: (i) => is(pipe(string(), regex(/^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/)), i),
         },
         config: {
             initOptions: (item) => {
@@ -1957,6 +1905,7 @@
             strokeColor: commands.strokeColor,
             wakuColor: commands.wakuColor,
             fillColor: commands.fillColor,
+            opacity: commands.opacity,
             button: commands.button,
         };
     };
@@ -2080,15 +2029,16 @@
     };
     const processReverseScript = (comment, commands) => {
         const reverse = RegExp(/^[@\uff20]\u9006(?:\s+)?(\u5168|\u30b3\u30e1|\u6295\u30b3\u30e1)?/).exec(comment.content);
-        if (!reverse?.[1] || !typeGuard.nicoScript.range.target(reverse[1]))
-            return;
+        const target = typeGuard.nicoScript.range.target(reverse?.[1])
+            ? reverse?.[1]
+            : "全";
         if (commands.long === undefined) {
             commands.long = 30;
         }
         nicoScripts.reverse.unshift({
             start: comment.vpos,
             end: comment.vpos + commands.long * 100,
-            target: reverse[1],
+            target,
         });
     };
     const processBanScript = (comment, commands) => {
@@ -2113,9 +2063,12 @@
         const options = RegExp(/\s*((?:sm|so|nm|\uff53\uff4d|\uff53\uff4f|\uff4e\uff4d)?[1-9\uff11-\uff19][0-9\uff11-\uff19]*|#[0-9]+:[0-9]+(?:\.[0-9]+)?)\s+(.*)/).exec(input);
         if (!options?.[1])
             return;
+        const end = commands.long === undefined
+            ? undefined
+            : commands.long * 100 + comment.vpos;
         nicoScripts.jump.unshift({
             start: comment.vpos,
-            end: commands.long === undefined ? undefined : commands.long * 100,
+            end,
             to: options[1],
             message: options[2],
         });
@@ -2188,6 +2141,11 @@
             result.fillColor ??= fillColor;
             return;
         }
+        const opacity = getOpacity(RegExp(/^nico:opacity:(.+)$/).exec(command));
+        if (typeof opacity === "number") {
+            result.opacity ??= opacity;
+            return;
+        }
         if (is(ZCommentLoc, command)) {
             result.loc ??= command;
             return;
@@ -2226,6 +2184,15 @@
         }
         return;
     };
+    const getOpacity = (match) => {
+        if (!match)
+            return;
+        const value = Number(match[1]);
+        if (!Number.isNaN(value) && value >= 0) {
+            return value;
+        }
+        return;
+    };
     const isFlashComment = (comment) => options.mode === "flash" ||
         (options.mode === "default" &&
             !(comment.mail.includes("gothic") ||
@@ -2428,11 +2395,13 @@
                 comment.mail.includes("patissier") ||
                 comment.mail.includes("ender") ||
                 comment.mail.includes("full")) {
-                userScoreList[comment.user_id] += 5;
+                userScoreList[comment.user_id] =
+                    (userScoreList[comment.user_id] ?? 0) + 5;
             }
             const lineCount = (comment.content.match(/\r\n|\n|\r/g) ?? []).length;
             if (lineCount > 2) {
-                userScoreList[comment.user_id] += lineCount / 2;
+                userScoreList[comment.user_id] =
+                    (userScoreList[comment.user_id] ?? 0) + lineCount / 2;
             }
         }
         return userScoreList;
@@ -3039,7 +3008,10 @@
             }
             if (this.image) {
                 this.renderer.save();
-                if (this.comment._live) {
+                if (typeof this.comment.opacity === "number") {
+                    this.renderer.setGlobalAlpha(this.comment.opacity);
+                }
+                else if (this.comment._live) {
                     this.renderer.setGlobalAlpha(config.contextFillLiveOpacity);
                 }
                 else {
@@ -4660,6 +4632,7 @@
             this.context = context;
             this.context.textAlign = "start";
             this.context.textBaseline = "alphabetic";
+            this.context.lineJoin = "round";
             this.video = video;
         }
         drawVideo(enableLegacyPip) {