@prisma/cli-init 0.5.1 → 0.6.1

package/dist/{chunk-7C5I22R2.js → chunk-YTWW6A72.js}

@@ -1,46 +1,43 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 
-// ../../node_modules/.pnpm/valibot@1.1.0_typescript@5.8.3/node_modules/valibot/dist/index.js
-var store;
+// ../../node_modules/.pnpm/valibot@1.2.0_typescript@5.8.3/node_modules/valibot/dist/index.mjs
+var store$4;
 // @__NO_SIDE_EFFECTS__
-function getGlobalConfig(config2) {
+function getGlobalConfig(config$1) {
   return {
-    lang: config2?.lang ?? store?.lang,
-    message: config2?.message,
-    abortEarly: config2?.abortEarly ?? store?.abortEarly,
-    abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
   };
 }
-var store2;
+var store$3;
 // @__NO_SIDE_EFFECTS__
 function getGlobalMessage(lang) {
-  return store2?.get(lang);
+  return store$3?.get(lang);
 }
-var store3;
+var store$2;
 // @__NO_SIDE_EFFECTS__
 function getSchemaMessage(lang) {
-  return store3?.get(lang);
+  return store$2?.get(lang);
 }
-var store4;
+var store$1;
 // @__NO_SIDE_EFFECTS__
 function getSpecificMessage(reference, lang) {
-  return store4?.get(reference)?.get(lang);
+  return store$1?.get(reference)?.get(lang);
 }
 // @__NO_SIDE_EFFECTS__
 function _stringify(input) {
   const type = typeof input;
-  if (type === "string") {
+  if (type === "string")
     return `"${input}"`;
-  }
-  if (type === "number" || type === "bigint" || type === "boolean") {
+  if (type === "number" || type === "bigint" || type === "boolean")
     return `${input}`;
-  }
-  if (type === "object" || type === "function") {
+  if (type === "object" || type === "function")
     return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-  }
   return type;
 }
-function _addIssue(context, label, dataset, config2, other) {
+function _addIssue(context, label, dataset, config$1, other) {
   const input = other && "input" in other ? other.input : dataset.value;
   const expected = other?.expected ?? context.expects ?? null;
   const received = other?.received ?? /* @__PURE__ */ _stringify(input);
@@ -54,51 +51,44 @@ function _addIssue(context, label, dataset, config2, other) {
     requirement: context.requirement,
     path: other?.path,
     issues: other?.issues,
-    lang: config2.lang,
-    abortEarly: config2.abortEarly,
-    abortPipeEarly: config2.abortPipeEarly
+    lang: config$1.lang,
+    abortEarly: config$1.abortEarly,
+    abortPipeEarly: config$1.abortPipeEarly
   };
   const isSchema = context.kind === "schema";
-  const message2 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
-  if (message2 !== void 0) {
-    issue.message = typeof message2 === "function" ? (
-      // @ts-expect-error
-      message2(issue)
-    ) : message2;
-  }
-  if (isSchema) {
+  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message$1 !== void 0)
+    issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+  if (isSchema)
     dataset.typed = false;
-  }
-  if (dataset.issues) {
+  if (dataset.issues)
     dataset.issues.push(issue);
-  } else {
+  else
     dataset.issues = [issue];
-  }
 }
 // @__NO_SIDE_EFFECTS__
 function _getStandardProps(context) {
   return {
     version: 1,
     vendor: "valibot",
-    validate(value2) {
-      return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig());
+    validate(value$1) {
+      return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function _isValidObjectKey(object2, key) {
-  return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+function _isValidObjectKey(object$1, key) {
+  return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
 }
 // @__NO_SIDE_EFFECTS__
-function _joinExpects(values2, separator) {
-  const list = [...new Set(values2)];
-  if (list.length > 1) {
+function _joinExpects(values$1, separator) {
+  const list = [...new Set(values$1)];
+  if (list.length > 1)
     return `(${list.join(` ${separator} `)})`;
-  }
   return list[0] ?? "never";
 }
 // @__NO_SIDE_EFFECTS__
-function integer(message2) {
+function integer(message$1) {
   return {
     kind: "validation",
     type: "integer",
@@ -106,17 +96,16 @@ function integer(message2) {
     async: false,
     expects: null,
     requirement: Number.isInteger,
-    message: message2,
-    "~run"(dataset, config2) {
-      if (dataset.typed && !this.requirement(dataset.value)) {
-        _addIssue(this, "integer", dataset, config2);
-      }
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement(dataset.value))
+        _addIssue(this, "integer", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function minLength(requirement, message2) {
+function minLength(requirement, message$1) {
   return {
     kind: "validation",
     type: "min_length",
@@ -124,19 +113,16 @@ function minLength(requirement, message2) {
     async: false,
     expects: `>=${requirement}`,
     requirement,
-    message: message2,
-    "~run"(dataset, config2) {
-      if (dataset.typed && dataset.value.length < this.requirement) {
-        _addIssue(this, "length", dataset, config2, {
-          received: `${dataset.value.length}`
-        });
-      }
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && dataset.value.length < this.requirement)
+        _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function minValue(requirement, message2) {
+function minValue(requirement, message$1) {
   return {
     kind: "validation",
     type: "min_value",
@@ -144,45 +130,39 @@ function minValue(requirement, message2) {
     async: false,
     expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
     requirement,
-    message: message2,
-    "~run"(dataset, config2) {
-      if (dataset.typed && !(dataset.value >= this.requirement)) {
-        _addIssue(this, "value", dataset, config2, {
-          received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value)
-        });
-      }
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !(dataset.value >= this.requirement))
+        _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function parseJson(config2, message2) {
+function parseJson(config$1, message$1) {
   return {
     kind: "transformation",
     type: "parse_json",
     reference: parseJson,
-    config: config2,
-    message: message2,
+    config: config$1,
+    message: message$1,
     async: false,
-    "~run"(dataset, config3) {
+    "~run"(dataset, config$2) {
       try {
         dataset.value = JSON.parse(dataset.value, this.config?.reviver);
       } catch (error) {
         if (error instanceof Error) {
-          _addIssue(this, "JSON", dataset, config3, {
-            received: `"${error.message}"`
-          });
+          _addIssue(this, "JSON", dataset, config$2, { received: `"${error.message}"` });
           dataset.typed = false;
-        } else {
+        } else
           throw error;
-        }
       }
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function regex(requirement, message2) {
+function regex(requirement, message$1) {
   return {
     kind: "validation",
     type: "regex",
@@ -190,17 +170,16 @@ function regex(requirement, message2) {
     async: false,
     expects: `${requirement}`,
     requirement,
-    message: message2,
-    "~run"(dataset, config2) {
-      if (dataset.typed && !this.requirement.test(dataset.value)) {
-        _addIssue(this, "format", dataset, config2);
-      }
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement.test(dataset.value))
+        _addIssue(this, "format", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function url(message2) {
+function url(message$1) {
   return {
     kind: "validation",
     type: "url",
@@ -215,37 +194,24 @@ function url(message2) {
         return false;
       }
     },
-    message: message2,
-    "~run"(dataset, config2) {
-      if (dataset.typed && !this.requirement(dataset.value)) {
-        _addIssue(this, "URL", dataset, config2);
-      }
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement(dataset.value))
+        _addIssue(this, "URL", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__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
-  );
+function getFallback(schema, dataset, config$1) {
+  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
 }
 // @__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 getDefault(schema, dataset, config$1) {
+  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
 }
 // @__NO_SIDE_EFFECTS__
-function array(item, message2) {
+function array(item, message$1) {
   return {
     kind: "schema",
     type: "array",
@@ -253,56 +219,52 @@ function array(item, message2) {
     expects: "Array",
     async: false,
     item,
-    message: message2,
+    message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
-    "~run"(dataset, config2) {
+    "~run"(dataset, config$1) {
       const input = dataset.value;
       if (Array.isArray(input)) {
         dataset.typed = true;
         dataset.value = [];
         for (let key = 0; key < input.length; key++) {
-          const value2 = input[key];
-          const itemDataset = this.item["~run"]({ value: value2 }, config2);
+          const value$1 = input[key];
+          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
           if (itemDataset.issues) {
             const pathItem = {
               type: "array",
               origin: "value",
               input,
               key,
-              value: value2
+              value: value$1
             };
             for (const issue of itemDataset.issues) {
-              if (issue.path) {
+              if (issue.path)
                 issue.path.unshift(pathItem);
-              } else {
+              else
                 issue.path = [pathItem];
-              }
               dataset.issues?.push(issue);
             }
-            if (!dataset.issues) {
+            if (!dataset.issues)
               dataset.issues = itemDataset.issues;
-            }
-            if (config2.abortEarly) {
+            if (config$1.abortEarly) {
               dataset.typed = false;
               break;
             }
           }
-          if (!itemDataset.typed) {
+          if (!itemDataset.typed)
             dataset.typed = false;
-          }
           dataset.value.push(itemDataset.value);
         }
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
+      } else
+        _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function literal(literal_, message2) {
+function literal(literal_, message$1) {
   return {
     kind: "schema",
     type: "literal",
@@ -310,213 +272,185 @@ function literal(literal_, message2) {
     expects: /* @__PURE__ */ _stringify(literal_),
     async: false,
     literal: literal_,
-    message: message2,
+    message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
-    "~run"(dataset, config2) {
-      if (dataset.value === this.literal) {
+    "~run"(dataset, config$1) {
+      if (dataset.value === this.literal)
         dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
+      else
+        _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function looseObject(entries2, message2) {
+function looseObject(entries$1, message$1) {
   return {
     kind: "schema",
     type: "loose_object",
     reference: looseObject,
     expects: "Object",
     async: false,
-    entries: entries2,
-    message: message2,
+    entries: entries$1,
+    message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
-    "~run"(dataset, config2) {
+    "~run"(dataset, config$1) {
       const input = dataset.value;
       if (input && typeof input === "object") {
         dataset.typed = true;
         dataset.value = {};
         for (const key in this.entries) {
           const 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) {
-            const value2 = key in input ? (
-              // @ts-expect-error
-              input[key]
-            ) : /* @__PURE__ */ getDefault(valueSchema);
-            const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
             if (valueDataset.issues) {
               const pathItem = {
                 type: "object",
                 origin: "value",
                 input,
                 key,
-                value: value2
+                value: value$1
               };
               for (const issue of valueDataset.issues) {
-                if (issue.path) {
+                if (issue.path)
                   issue.path.unshift(pathItem);
-                } else {
+                else
                   issue.path = [pathItem];
-                }
                 dataset.issues?.push(issue);
               }
-              if (!dataset.issues) {
+              if (!dataset.issues)
                 dataset.issues = valueDataset.issues;
-              }
-              if (config2.abortEarly) {
+              if (config$1.abortEarly) {
                 dataset.typed = false;
                 break;
               }
             }
-            if (!valueDataset.typed) {
+            if (!valueDataset.typed)
               dataset.typed = false;
-            }
             dataset.value[key] = valueDataset.value;
-          } else if (valueSchema.fallback !== void 0) {
+          } else if (valueSchema.fallback !== void 0)
             dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-          } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-            _addIssue(this, "key", dataset, config2, {
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
               input: void 0,
               expected: `"${key}"`,
-              path: [
-                {
-                  type: "object",
-                  origin: "key",
-                  input,
-                  key,
-                  // @ts-expect-error
-                  value: input[key]
-                }
-              ]
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
             });
-            if (config2.abortEarly) {
+            if (config$1.abortEarly)
               break;
-            }
           }
         }
-        if (!dataset.issues || !config2.abortEarly) {
-          for (const key in input) {
-            if (/* @__PURE__ */ _isValidObjectKey(input, key) && !(key in this.entries)) {
+        if (!dataset.issues || !config$1.abortEarly) {
+          for (const key in input)
+            if (/* @__PURE__ */ _isValidObjectKey(input, key) && !(key in this.entries))
               dataset.value[key] = input[key];
-            }
-          }
         }
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
+      } else
+        _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function number(message2) {
+function number(message$1) {
   return {
     kind: "schema",
     type: "number",
     reference: number,
     expects: "number",
     async: false,
-    message: message2,
+    message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
-    "~run"(dataset, config2) {
-      if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value))
         dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
+      else
+        _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function object(entries2, message2) {
+function object(entries$1, message$1) {
   return {
     kind: "schema",
     type: "object",
     reference: object,
     expects: "Object",
     async: false,
-    entries: entries2,
-    message: message2,
+    entries: entries$1,
+    message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
-    "~run"(dataset, config2) {
+    "~run"(dataset, config$1) {
       const input = dataset.value;
       if (input && typeof input === "object") {
         dataset.typed = true;
         dataset.value = {};
         for (const key in this.entries) {
           const 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) {
-            const value2 = key in input ? (
-              // @ts-expect-error
-              input[key]
-            ) : /* @__PURE__ */ getDefault(valueSchema);
-            const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
             if (valueDataset.issues) {
               const pathItem = {
                 type: "object",
                 origin: "value",
                 input,
                 key,
-                value: value2
+                value: value$1
               };
               for (const issue of valueDataset.issues) {
-                if (issue.path) {
+                if (issue.path)
                   issue.path.unshift(pathItem);
-                } else {
+                else
                   issue.path = [pathItem];
-                }
                 dataset.issues?.push(issue);
               }
-              if (!dataset.issues) {
+              if (!dataset.issues)
                 dataset.issues = valueDataset.issues;
-              }
-              if (config2.abortEarly) {
+              if (config$1.abortEarly) {
                 dataset.typed = false;
                 break;
               }
             }
-            if (!valueDataset.typed) {
+            if (!valueDataset.typed)
               dataset.typed = false;
-            }
             dataset.value[key] = valueDataset.value;
-          } else if (valueSchema.fallback !== void 0) {
+          } else if (valueSchema.fallback !== void 0)
             dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-          } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-            _addIssue(this, "key", dataset, config2, {
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
               input: void 0,
               expected: `"${key}"`,
-              path: [
-                {
-                  type: "object",
-                  origin: "key",
-                  input,
-                  key,
-                  // @ts-expect-error
-                  value: input[key]
-                }
-              ]
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
             });
-            if (config2.abortEarly) {
+            if (config$1.abortEarly)
               break;
-            }
           }
         }
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
+      } else
+        _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
   };
@@ -534,38 +468,36 @@ function optional(wrapped, default_) {
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
-    "~run"(dataset, config2) {
+    "~run"(dataset, config$1) {
       if (dataset.value === void 0) {
-        if (this.default !== void 0) {
-          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
-        }
+        if (this.default !== void 0)
+          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
         if (dataset.value === void 0) {
           dataset.typed = true;
           return dataset;
         }
       }
-      return this.wrapped["~run"](dataset, config2);
+      return this.wrapped["~run"](dataset, config$1);
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function string(message2) {
+function string(message$1) {
   return {
     kind: "schema",
     type: "string",
     reference: string,
     expects: "string",
     async: false,
-    message: message2,
+    message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
-    "~run"(dataset, config2) {
-      if (typeof dataset.value === "string") {
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string")
         dataset.typed = true;
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
+      else
+        _addIssue(this, "type", dataset, config$1);
       return dataset;
     }
   };
@@ -573,107 +505,88 @@ function string(message2) {
 // @__NO_SIDE_EFFECTS__
 function _subIssues(datasets) {
   let issues;
-  if (datasets) {
-    for (const dataset of datasets) {
-      if (issues) {
+  if (datasets)
+    for (const dataset of datasets)
+      if (issues)
         issues.push(...dataset.issues);
-      } else {
+      else
         issues = dataset.issues;
-      }
-    }
-  }
   return issues;
 }
 // @__NO_SIDE_EFFECTS__
-function union(options, message2) {
+function union(options, message$1) {
   return {
     kind: "schema",
     type: "union",
     reference: union,
-    expects: /* @__PURE__ */ _joinExpects(
-      options.map((option) => option.expects),
-      "|"
-    ),
+    expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
     async: false,
     options,
-    message: message2,
+    message: message$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
-    "~run"(dataset, config2) {
+    "~run"(dataset, config$1) {
       let validDataset;
       let typedDatasets;
       let untypedDatasets;
       for (const schema of this.options) {
-        const optionDataset = schema["~run"]({ value: dataset.value }, config2);
-        if (optionDataset.typed) {
-          if (optionDataset.issues) {
-            if (typedDatasets) {
+        const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
+        if (optionDataset.typed)
+          if (optionDataset.issues)
+            if (typedDatasets)
               typedDatasets.push(optionDataset);
-            } else {
+            else
               typedDatasets = [optionDataset];
-            }
-          } else {
+          else {
             validDataset = optionDataset;
             break;
           }
-        } else {
-          if (untypedDatasets) {
-            untypedDatasets.push(optionDataset);
-          } else {
-            untypedDatasets = [optionDataset];
-          }
-        }
+        else if (untypedDatasets)
+          untypedDatasets.push(optionDataset);
+        else
+          untypedDatasets = [optionDataset];
       }
-      if (validDataset) {
+      if (validDataset)
         return validDataset;
-      }
       if (typedDatasets) {
-        if (typedDatasets.length === 1) {
+        if (typedDatasets.length === 1)
           return typedDatasets[0];
-        }
-        _addIssue(this, "type", dataset, config2, {
-          issues: /* @__PURE__ */ _subIssues(typedDatasets)
-        });
+        _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
         dataset.typed = true;
-      } else if (untypedDatasets?.length === 1) {
+      } else if (untypedDatasets?.length === 1)
         return untypedDatasets[0];
-      } else {
-        _addIssue(this, "type", dataset, config2, {
-          issues: /* @__PURE__ */ _subIssues(untypedDatasets)
-        });
-      }
+      else
+        _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function pipe(...pipe2) {
+function pipe(...pipe$1) {
   return {
-    ...pipe2[0],
-    pipe: pipe2,
+    ...pipe$1[0],
+    pipe: pipe$1,
     get "~standard"() {
       return /* @__PURE__ */ _getStandardProps(this);
     },
-    "~run"(dataset, config2) {
-      for (const item of pipe2) {
+    "~run"(dataset, config$1) {
+      for (const item of pipe$1)
         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);
-          }
+          if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly)
+            dataset = item["~run"](dataset, config$1);
         }
-      }
       return dataset;
     }
   };
 }
 // @__NO_SIDE_EFFECTS__
-function safeParse(schema, input, config2) {
-  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
+function safeParse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
   return {
     typed: dataset.typed,
     success: !dataset.issues,