decoders 2.3.0-test4 → 2.4.0

package/dist/index.js

@@ -1,110 +1,45 @@
-// src/_utils.ts
-var INDENT = "  ";
-function lazyval(value) {
-  return typeof value === "function" ? value() : value;
+// src/lib/utils.ts
+function isNumber(value) {
+  return typeof value === "number";
 }
-function subtract(xs, ys) {
-  const result = /* @__PURE__ */ new Set();
-  for (const x of xs) {
-    if (!ys.has(x)) {
-      result.add(x);
-    }
-  }
-  return result;
+function isString(value) {
+  return typeof value === "string";
+}
+function isBigInt(value) {
+  return typeof value === "bigint";
 }
-function asDate(value) {
-  return !!value && Object.prototype.toString.call(value) === "[object Date]" && !isNaN(value) ? value : null;
+function isDate(value) {
+  return !!value && Object.prototype.toString.call(value) === "[object Date]" && !isNaN(value);
 }
 function isPojo(value) {
   return value !== null && value !== void 0 && typeof value === "object" && // This still seems to be the only reliable way to determine whether
   // something is a pojo... ¯\_(ツ)_/¯
   Object.prototype.toString.call(value) === "[object Object]";
 }
-function isMultiline(s) {
-  return s.indexOf("\n") >= 0;
-}
-function indent(s, prefix = INDENT) {
-  if (isMultiline(s)) {
-    return s.split("\n").map((line) => `${prefix}${line}`).join("\n");
-  } else {
-    return `${prefix}${s}`;
-  }
-}
-function summarize(ann, keypath = []) {
-  const result = [];
-  if (ann.type === "array") {
-    const items = ann.items;
-    let index = 0;
-    for (const ann2 of items) {
-      for (const item of summarize(ann2, [...keypath, index++])) {
-        result.push(item);
-      }
-    }
-  } else if (ann.type === "object") {
-    const fields = ann.fields;
-    for (const key of Object.keys(fields)) {
-      const value = fields[key];
-      for (const item of summarize(value, [...keypath, key])) {
-        result.push(item);
-      }
-    }
-  }
-  const text = ann.text;
-  if (!text) {
-    return result;
-  }
-  let prefix;
-  if (keypath.length === 0) {
-    prefix = "";
-  } else if (keypath.length === 1) {
-    prefix = typeof keypath[0] === "number" ? `Value at index ${keypath[0]}: ` : `Value at key ${JSON.stringify(keypath[0])}: `;
-  } else {
-    prefix = `Value at keypath ${keypath.map(String).join(".")}: `;
-  }
-  return [...result, `${prefix}${text}`];
-}
 
-// src/annotate.ts
+// src/core/annotate.ts
 var _register = /* @__PURE__ */ new WeakSet();
 function brand(ann) {
   _register.add(ann);
   return ann;
 }
-function object(fields, text) {
+function makeObjectAnn(fields, text) {
   return brand({ type: "object", fields, text });
 }
-function array(items, text) {
-  return brand({
-    type: "array",
-    items,
-    text
-  });
+function makeArrayAnn(items, text) {
+  return brand({ type: "array", items, text });
 }
-function func(text) {
-  return brand({
-    type: "function",
-    text
-  });
+function makeFunctionAnn(text) {
+  return brand({ type: "function", text });
 }
-function unknown(value, text) {
-  return brand({
-    type: "unknown",
-    value,
-    text
-  });
+function makeUnknownAnn(value, text) {
+  return brand({ type: "unknown", value, text });
 }
-function scalar(value, text) {
-  return brand({
-    type: "scalar",
-    value,
-    text
-  });
+function makeScalarAnn(value, text) {
+  return brand({ type: "scalar", value, text });
 }
-function circularRef(text) {
-  return brand({
-    type: "circular-ref",
-    text
-  });
+function makeCircularRefAnn(text) {
+  return brand({ type: "circular-ref", text });
 }
 function updateText(annotation, text) {
   if (text !== void 0) {
@@ -114,52 +49,54 @@ function updateText(annotation, text) {
   }
 }
 function merge(objAnnotation, fields) {
-  const newFields = { ...objAnnotation.fields, ...fields };
-  return object(newFields, objAnnotation.text);
+  const newFields = new Map([...objAnnotation.fields, ...fields]);
+  return makeObjectAnn(newFields, objAnnotation.text);
 }
-function asAnnotation(thing) {
-  return typeof thing === "object" && thing !== null && _register.has(thing) ? thing : void 0;
+function isAnnotation(thing) {
+  return _register.has(thing);
 }
-function annotateArray(value, text, seen) {
-  seen.add(value);
-  const items = value.map((v) => annotate(v, void 0, seen));
-  return array(items, text);
+function annotateArray(arr, text, seen) {
+  seen.add(arr);
+  const items = [];
+  for (const value of arr) {
+    items.push(annotate(value, void 0, seen));
+  }
+  return makeArrayAnn(items, text);
 }
 function annotateObject(obj, text, seen) {
   seen.add(obj);
-  const fields = {};
+  const fields = /* @__PURE__ */ new Map();
   for (const key of Object.keys(obj)) {
     const value = obj[key];
-    fields[key] = annotate(value, void 0, seen);
+    fields.set(key, annotate(value, void 0, seen));
   }
-  return object(fields, text);
+  return makeObjectAnn(fields, text);
 }
 function annotate(value, text, seen) {
   if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "symbol" || typeof value.getMonth === "function") {
-    return scalar(value, text);
+    return makeScalarAnn(value, text);
   }
-  const ann = asAnnotation(value);
-  if (ann) {
-    return updateText(ann, text);
+  if (isAnnotation(value)) {
+    return updateText(value, text);
   }
   if (Array.isArray(value)) {
     if (seen.has(value)) {
-      return circularRef(text);
+      return makeCircularRefAnn(text);
     } else {
       return annotateArray(value, text, seen);
     }
   }
   if (isPojo(value)) {
     if (seen.has(value)) {
-      return circularRef(text);
+      return makeCircularRefAnn(text);
     } else {
       return annotateObject(value, text, seen);
     }
   }
   if (typeof value === "function") {
-    return func(text);
+    return makeFunctionAnn(text);
   }
-  return unknown(value, text);
+  return makeUnknownAnn(value, text);
 }
 function public_annotate(value, text) {
   return annotate(value, text, /* @__PURE__ */ new WeakSet());
@@ -168,7 +105,56 @@ function public_annotateObject(obj, text) {
   return annotateObject(obj, text, /* @__PURE__ */ new WeakSet());
 }
 
-// src/format.ts
+// src/lib/text.ts
+var INDENT = "  ";
+function isMultiline(s) {
+  return s.indexOf("\n") >= 0;
+}
+function indent(s, prefix = INDENT) {
+  if (isMultiline(s)) {
+    return s.split("\n").map((line) => `${prefix}${line}`).join("\n");
+  } else {
+    return `${prefix}${s}`;
+  }
+}
+var quotePattern = /'/g;
+function quote(value) {
+  return typeof value === "string" ? "'" + value.replace(quotePattern, "\\'") + "'" : JSON.stringify(value);
+}
+
+// src/core/format.ts
+function summarize(ann, keypath = []) {
+  const result = [];
+  if (ann.type === "array") {
+    const items = ann.items;
+    let index = 0;
+    for (const ann2 of items) {
+      for (const item of summarize(ann2, [...keypath, index++])) {
+        result.push(item);
+      }
+    }
+  } else if (ann.type === "object") {
+    const fields = ann.fields;
+    for (const [key, value] of fields) {
+      for (const item of summarize(value, [...keypath, key])) {
+        result.push(item);
+      }
+    }
+  }
+  const text = ann.text;
+  if (!text) {
+    return result;
+  }
+  let prefix;
+  if (keypath.length === 0) {
+    prefix = "";
+  } else if (keypath.length === 1) {
+    prefix = typeof keypath[0] === "number" ? `Value at index ${keypath[0]}: ` : `Value at key ${quote(keypath[0])}: `;
+  } else {
+    prefix = `Value at keypath ${quote(keypath.map(String).join("."))}: `;
+  }
+  return [...result, `${prefix}${text}`];
+}
 function serializeString(s, width = 80) {
   let ser = JSON.stringify(s);
   if (ser.length <= width) {
@@ -195,13 +181,11 @@ function serializeArray(annotation, prefix) {
 }
 function serializeObject(annotation, prefix) {
   const { fields } = annotation;
-  const fieldNames = Object.keys(fields);
-  if (fieldNames.length === 0) {
+  if (fields.size === 0) {
     return "{}";
   }
   const result = [];
-  for (const key of fieldNames) {
-    const valueAnnotation = fields[key];
+  for (const [key, valueAnnotation] of fields) {
     const kser = serializeValue(key);
     const valPrefix = `${prefix}${INDENT}${" ".repeat(kser.length + 2)}`;
     const [vser, vann] = serializeAnnotation(valueAnnotation, `${prefix}${INDENT}`);
@@ -215,16 +199,15 @@ function serializeObject(annotation, prefix) {
 function serializeValue(value) {
   if (typeof value === "string") {
     return serializeString(value);
-  } else if (typeof value === "number" || typeof value === "boolean") {
+  } else if (typeof value === "number" || typeof value === "boolean" || typeof value === "symbol") {
     return value.toString();
   } else if (value === null) {
     return "null";
   } else if (value === void 0) {
     return "undefined";
   } else {
-    const valueAsDate = asDate(value);
-    if (valueAsDate !== null) {
-      return `new Date(${JSON.stringify(valueAsDate.toISOString())})`;
+    if (isDate(value)) {
+      return `new Date(${quote(value.toISOString())})`;
     } else if (value instanceof Date) {
       return "(Invalid Date)";
     } else {
@@ -268,7 +251,7 @@ function formatShort(ann) {
   return summarize(ann, []).join("\n");
 }
 
-// src/result.ts
+// src/core/Result.ts
 function ok(value) {
   return { ok: true, value, error: void 0 };
 }
@@ -276,7 +259,7 @@ function err(error) {
   return { ok: false, value: void 0, error };
 }
 
-// src/Decoder.ts
+// src/core/Decoder.ts
 function noThrow(fn) {
   return (t) => {
     try {
@@ -303,7 +286,7 @@ function define(fn) {
     return fn(
       blob,
       ok,
-      (msg) => err(typeof msg === "string" ? public_annotate(blob, msg) : msg)
+      (msg) => err(isAnnotation(msg) ? msg : public_annotate(blob, msg))
     );
   }
   function verify(blob, formatter = formatInline) {
@@ -333,14 +316,20 @@ function define(fn) {
   }
   function then(next) {
     return define((blob, ok2, err2) => {
-      const result = decode(blob);
-      return result.ok ? next(result.value, ok2, err2) : result;
+      const r1 = decode(blob);
+      if (!r1.ok)
+        return r1;
+      const r2 = isDecoder(next) ? next : next(r1.value, ok2, err2);
+      return isDecoder(r2) ? r2.decode(r1.value) : r2;
     });
   }
+  function pipe(next) {
+    return then(next);
+  }
   function reject(rejectFn) {
-    return then((value2, ok2, err2) => {
-      const errmsg = rejectFn(value2);
-      return errmsg === null ? ok2(value2) : err2(typeof errmsg === "string" ? public_annotate(value2, errmsg) : errmsg);
+    return then((blob, ok2, err2) => {
+      const errmsg = rejectFn(blob);
+      return errmsg === null ? ok2(blob) : err2(typeof errmsg === "string" ? public_annotate(blob, errmsg) : errmsg);
     });
   }
   function describe(message) {
@@ -353,13 +342,7 @@ function define(fn) {
       }
     });
   }
-  function peek_UNSTABLE(next) {
-    return define((blob, ok2, err2) => {
-      const result = decode(blob);
-      return result.ok ? next([blob, result.value], ok2, err2) : result;
-    });
-  }
-  return Object.freeze({
+  return brand2({
     verify,
     value,
     decode,
@@ -368,30 +351,137 @@ function define(fn) {
     reject,
     describe,
     then,
-    // EXPERIMENTAL - please DO NOT rely on this method
-    peek_UNSTABLE
+    pipe
+  });
+}
+var _register2 = /* @__PURE__ */ new WeakSet();
+function brand2(decoder) {
+  _register2.add(decoder);
+  return decoder;
+}
+function isDecoder(thing) {
+  return _register2.has(thing);
+}
+
+// src/arrays.ts
+var poja = define((blob, ok2, err2) => {
+  if (!Array.isArray(blob)) {
+    return err2("Must be an array");
+  }
+  return ok2(blob);
+});
+function all(items, blobs, ok2, err2) {
+  const results = [];
+  for (let index = 0; index < items.length; ++index) {
+    const result = items[index];
+    if (result.ok) {
+      results.push(result.value);
+    } else {
+      const ann = result.error;
+      const clone = blobs.slice();
+      clone.splice(
+        index,
+        1,
+        public_annotate(ann, ann.text ? `${ann.text} (at index ${index})` : `index ${index}`)
+      );
+      return err2(public_annotate(clone));
+    }
+  }
+  return ok2(results);
+}
+function array(decoder) {
+  const decodeFn = decoder.decode;
+  return poja.then((blobs, ok2, err2) => {
+    const results = blobs.map(decodeFn);
+    return all(results, blobs, ok2, err2);
+  });
+}
+function isNonEmpty(arr) {
+  return arr.length > 0;
+}
+function nonEmptyArray(decoder) {
+  return array(decoder).refine(isNonEmpty, "Must be non-empty array");
+}
+var ntuple = (n) => poja.refine((arr) => arr.length === n, `Must be a ${n}-tuple`);
+function tuple(...decoders) {
+  return ntuple(decoders.length).then((blobs, ok2, err2) => {
+    let allOk = true;
+    const rvs = decoders.map((decoder, i) => {
+      const blob = blobs[i];
+      const result = decoder.decode(blob);
+      if (result.ok) {
+        return result.value;
+      } else {
+        allOk = false;
+        return result.error;
+      }
+    });
+    if (allOk) {
+      return ok2(rvs);
+    } else {
+      return err2(public_annotate(rvs));
+    }
+  });
+}
+
+// src/misc.ts
+function instanceOf(klass) {
+  return define(
+    (blob, ok2, err2) => blob instanceof klass ? ok2(blob) : err2(`Must be ${klass.name} instance`)
+  );
+}
+function lazy(decoderFn) {
+  return define((blob) => decoderFn().decode(blob));
+}
+function prep(mapperFn, decoder) {
+  return define((originalInput, _, err2) => {
+    let blob;
+    try {
+      blob = mapperFn(originalInput);
+    } catch (e) {
+      return err2(
+        public_annotate(
+          originalInput,
+          // istanbul ignore next
+          e instanceof Error ? e.message : String(e)
+        )
+      );
+    }
+    const r = decoder.decode(blob);
+    return r.ok ? r : err2(public_annotate(originalInput, r.error.text));
   });
 }
 
-// src/lib/objects.ts
+// src/lib/set-methods.ts
+function difference(xs, ys) {
+  const result = /* @__PURE__ */ new Set();
+  for (const x of xs) {
+    if (!ys.has(x)) {
+      result.add(x);
+    }
+  }
+  return result;
+}
+
+// src/objects.ts
 var pojo = define(
   (blob, ok2, err2) => isPojo(blob) ? ok2(blob) : err2("Must be an object")
 );
-function object2(decodersByKey) {
-  const knownKeys = new Set(Object.keys(decodersByKey));
+function object(decoders) {
+  const knownKeys = new Set(Object.keys(decoders));
   return pojo.then((plainObj, ok2, err2) => {
     const actualKeys = new Set(Object.keys(plainObj));
-    const missingKeys = subtract(knownKeys, actualKeys);
-    const record = {};
+    const missingKeys = difference(knownKeys, actualKeys);
+    const record2 = {};
     let errors = null;
-    for (const key of Object.keys(decodersByKey)) {
-      const decoder = decodersByKey[key];
+    for (const key of Object.keys(decoders)) {
+      const decoder = decoders[key];
       const rawValue = plainObj[key];
       const result = decoder.decode(rawValue);
       if (result.ok) {
         const value = result.value;
         if (value !== void 0) {
-          record[key] = value;
+          record2[key] = value;
         }
         missingKeys.delete(key);
       } else {
@@ -400,9 +490,9 @@ function object2(decodersByKey) {
           missingKeys.add(key);
         } else {
           if (errors === null) {
-            errors = {};
+            errors = /* @__PURE__ */ new Map();
           }
-          errors[key] = ann;
+          errors.set(key, ann);
         }
       }
     }
@@ -412,32 +502,29 @@ function object2(decodersByKey) {
         objAnn = merge(objAnn, errors);
       }
       if (missingKeys.size > 0) {
-        const errMsg = Array.from(missingKeys).map((key) => `"${key}"`).join(", ");
+        const errMsg = Array.from(missingKeys).map(quote).join(", ");
         const pluralized = missingKeys.size > 1 ? "keys" : "key";
         objAnn = updateText(objAnn, `Missing ${pluralized}: ${errMsg}`);
       }
       return err2(objAnn);
     }
-    return ok2(record);
+    return ok2(record2);
   });
 }
-function exact(decodersByKey) {
-  const allowedKeys = new Set(Object.keys(decodersByKey));
+function exact(decoders) {
+  const allowedKeys = new Set(Object.keys(decoders));
   const checked = pojo.reject((plainObj) => {
     const actualKeys = new Set(Object.keys(plainObj));
-    const extraKeys = subtract(actualKeys, allowedKeys);
-    return extraKeys.size > 0 ? `Unexpected extra keys: ${Array.from(extraKeys).join(", ")}` : (
-      // Don't reject
-      null
-    );
+    const extraKeys = difference(actualKeys, allowedKeys);
+    return extraKeys.size > 0 ? `Unexpected extra keys: ${Array.from(extraKeys).map(quote).join(", ")}` : null;
   });
-  return checked.then(object2(decodersByKey).decode);
+  return checked.pipe(object(decoders));
 }
-function inexact(decodersByKey) {
-  return pojo.then((plainObj) => {
+function inexact(decoders) {
+  return pojo.pipe((plainObj) => {
     const allkeys = new Set(Object.keys(plainObj));
-    const decoder = object2(decodersByKey).transform((safepart) => {
-      const safekeys = new Set(Object.keys(decodersByKey));
+    return object(decoders).transform((safepart) => {
+      const safekeys = new Set(Object.keys(decoders));
       for (const k of safekeys)
         allkeys.add(k);
       const rv = {};
@@ -453,80 +540,16 @@ function inexact(decodersByKey) {
       }
       return rv;
     });
-    return decoder.decode(plainObj);
-  });
-}
-function dict(decoder) {
-  return pojo.then((plainObj, ok2, err2) => {
-    let rv = {};
-    let errors = null;
-    for (const key of Object.keys(plainObj)) {
-      const value = plainObj[key];
-      const result = decoder.decode(value);
-      if (result.ok) {
-        if (errors === null) {
-          rv[key] = result.value;
-        }
-      } else {
-        rv = {};
-        if (errors === null) {
-          errors = {};
-        }
-        errors[key] = result.error;
-      }
-    }
-    if (errors !== null) {
-      return err2(merge(public_annotateObject(plainObj), errors));
-    } else {
-      return ok2(rv);
-    }
   });
 }
-function mapping(decoder) {
-  return dict(decoder).transform(
-    (obj) => new Map(
-      // This is effectively Object.entries(obj), but in a way that Flow
-      // will know the types are okay
-      Object.keys(obj).map((key) => [key, obj[key]])
-    )
-  );
-}
 
-// src/lib/utilities.ts
-function instanceOf(klass) {
-  return define(
-    (blob, ok2, err2) => blob instanceof klass ? ok2(blob) : err2(`Must be ${klass.name} instance`)
-  );
-}
-function lazy(decoderFn) {
-  return define((blob) => decoderFn().decode(blob));
-}
-function prep(mapperFn, decoder) {
-  return define((originalInput, _, err2) => {
-    let blob;
-    try {
-      blob = mapperFn(originalInput);
-    } catch (e) {
-      return err2(
-        public_annotate(
-          originalInput,
-          // istanbul ignore next
-          e instanceof Error ? e.message : String(e)
-        )
-      );
-    }
-    const r = decoder.decode(blob);
-    return r.ok ? r : err2(public_annotate(originalInput, r.error.text));
-  });
-}
-
-// src/lib/unions.ts
+// src/unions.ts
 var EITHER_PREFIX = "Either:\n";
 function itemize(s) {
   return `-${indent(s).substring(1)}`;
 }
 function nest(errText) {
-  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
+  return errText.startsWith(EITHER_PREFIX) ? errText.substring(EITHER_PREFIX.length) : itemize(errText);
 }
 function either(...decoders) {
   if (decoders.length === 0) {
@@ -552,28 +575,48 @@ function oneOf(constants) {
     if (winner !== void 0) {
       return ok2(winner);
     }
-    return err2(
-      `Must be one of ${constants.map((value) => JSON.stringify(value)).join(", ")}`
-    );
+    return err2(`Must be one of ${constants.map((value) => quote(value)).join(", ")}`);
   });
 }
+function enum_(enumObj) {
+  const values = Object.values(enumObj);
+  if (!values.some(isNumber)) {
+    return oneOf(values);
+  } else {
+    const nums = values.filter(isNumber);
+    const ignore = new Set(nums.map((val) => enumObj[val]));
+    const strings = values.filter(isString).filter((val) => !ignore.has(val));
+    return oneOf([...nums, ...strings]);
+  }
+}
 function taggedUnion(field, mapping2) {
-  const base = object2({
+  const scout = object({
     [field]: prep(String, oneOf(Object.keys(mapping2)))
   }).transform((o) => o[field]);
-  return base.peek_UNSTABLE(([blob, key]) => {
-    const decoder = mapping2[key];
-    return decoder.decode(blob);
+  return select(
+    scout,
+    // peek...
+    (key) => mapping2[key]
+    // ...then select
+  );
+}
+function select(scout, selectFn) {
+  return define((blob) => {
+    const result = scout.decode(blob);
+    return result.ok ? selectFn(result.value).decode(blob) : result;
   });
 }
 
-// src/lib/basics.ts
+// src/basics.ts
+function lazyval(value) {
+  return typeof value === "function" ? value() : value;
+}
 var null_ = constant(null);
 var undefined_ = constant(void 0);
 var nullish_ = define(
-  (blob, ok2, err2) => blob == null ? ok2(blob) : (
-    // Combine error message into a single line for readability
-    err2("Must be undefined or null")
+  (blob, ok2, err2) => (
+    // Equiv to either(undefined_, null_), but combined for better error message
+    blob == null ? ok2(blob) : err2("Must be undefined or null")
   )
 );
 function optional(decoder, defaultValue) {
@@ -591,7 +634,7 @@ function nullish(decoder, defaultValue) {
 }
 function constant(value) {
   return define(
-    (blob, ok2, err2) => blob === value ? ok2(value) : err2(`Must be ${JSON.stringify(value)}`)
+    (blob, ok2, err2) => blob === value ? ok2(value) : err2(`Must be ${typeof value === "symbol" ? String(value) : quote(value)}`)
   );
 }
 function always(value) {
@@ -604,99 +647,73 @@ function never(msg) {
 }
 var fail = never;
 var hardcoded = always;
-var unknown2 = define((blob, ok2, _) => ok2(blob));
-var mixed = unknown2;
+var unknown = define((blob, ok2, _) => ok2(blob));
+var mixed = unknown;
 
-// src/lib/arrays.ts
-var poja = define((blob, ok2, err2) => {
-  if (!Array.isArray(blob)) {
-    return err2("Must be an array");
-  }
-  return ok2(blob);
+// src/booleans.ts
+var boolean = define((blob, ok2, err2) => {
+  return typeof blob === "boolean" ? ok2(blob) : err2("Must be boolean");
 });
-function all(items, blobs, ok2, err2) {
-  const results = [];
-  for (let index = 0; index < items.length; ++index) {
-    const result = items[index];
-    if (result.ok) {
-      results.push(result.value);
-    } else {
-      const ann = result.error;
-      const clone = blobs.slice();
-      clone.splice(
-        index,
-        1,
-        public_annotate(ann, ann.text ? `${ann.text} (at index ${index})` : `index ${index}`)
-      );
-      return err2(public_annotate(clone));
-    }
-  }
-  return ok2(results);
-}
-function array2(decoder) {
-  const decodeFn = decoder.decode;
-  return poja.then((blobs, ok2, err2) => {
-    const results = blobs.map(decodeFn);
-    return all(results, blobs, ok2, err2);
-  });
-}
-function isNonEmpty(arr) {
-  return arr.length > 0;
-}
-function nonEmptyArray(decoder) {
-  return array2(decoder).refine(isNonEmpty, "Must be non-empty array");
-}
-function set(decoder) {
-  return array2(decoder).transform((items) => new Set(items));
-}
-var ntuple = (n) => poja.refine((arr) => arr.length === n, `Must be a ${n}-tuple`);
-function tuple(...decoders) {
-  return ntuple(decoders.length).then((blobs, ok2, err2) => {
-    let allOk = true;
-    const rvs = decoders.map((decoder, i) => {
-      const blob = blobs[i];
-      const result = decoder.decode(blob);
+var truthy = define((blob, ok2, _) => ok2(!!blob));
+
+// src/collections.ts
+function record(fst, snd) {
+  const keyDecoder = snd !== void 0 ? fst : void 0;
+  const valueDecoder = snd !== void 0 ? snd : fst;
+  return pojo.then((input, ok2, err2) => {
+    let rv = {};
+    const errors = /* @__PURE__ */ new Map();
+    for (const key of Object.keys(input)) {
+      const value = input[key];
+      const keyResult = keyDecoder?.decode(key);
+      if (keyResult?.ok === false) {
+        return err2(
+          public_annotate(input, `Invalid key ${quote(key)}: ${formatShort(keyResult.error)}`)
+        );
+      }
+      const k = keyResult?.value ?? key;
+      const result = valueDecoder.decode(value);
       if (result.ok) {
-        return result.value;
+        if (errors.size === 0) {
+          rv[k] = result.value;
+        }
       } else {
-        allOk = false;
-        return result.error;
+        errors.set(key, result.error);
+        rv = {};
       }
-    });
-    if (allOk) {
-      return ok2(rvs);
+    }
+    if (errors.size > 0) {
+      return err2(merge(public_annotateObject(input), errors));
     } else {
-      return err2(public_annotate(rvs));
+      return ok2(rv);
     }
   });
 }
+var dict = record;
+function setFromArray(decoder) {
+  return array(decoder).transform((items) => new Set(items));
+}
+var set = setFromArray;
+function mapping(decoder) {
+  return record(decoder).transform((obj) => new Map(Object.entries(obj)));
+}
 
-// src/lib/numbers.ts
-var anyNumber = define(
-  (blob, ok2, err2) => typeof blob === "number" ? ok2(blob) : err2("Must be number")
-);
-var number = anyNumber.refine(
-  (n) => Number.isFinite(n),
-  "Number must be finite"
-);
-var integer = number.refine(
-  (n) => Number.isInteger(n),
-  "Number must be an integer"
-);
-var positiveNumber = number.refine((n) => n >= 0, "Number must be positive").transform(Math.abs);
-var positiveInteger = integer.refine((n) => n >= 0, "Number must be positive").transform(Math.abs);
-
-// src/lib/booleans.ts
-var boolean = define((blob, ok2, err2) => {
-  return typeof blob === "boolean" ? ok2(blob) : err2("Must be boolean");
-});
-var truthy = define((blob, ok2, _) => ok2(!!blob));
-var numericBoolean = number.transform((n) => !!n);
+// src/lib/size-options.ts
+function bySizeOptions(options) {
+  const size = options?.size;
+  const min = size ?? options?.min;
+  const max = size ?? options?.max;
+  const atLeast = min === max ? "" : "at least ";
+  const atMost = min === max ? "" : "at most ";
+  const tooShort = min !== void 0 && `Too short, must be ${atLeast}${min} chars`;
+  const tooLong = max !== void 0 && `Too long, must be ${atMost}${max} chars`;
+  return tooShort && tooLong ? (s) => s.length < min ? tooShort : s.length > max ? tooLong : null : tooShort ? (s) => s.length < min ? tooShort : null : tooLong ? (s) => s.length > max ? tooLong : null : () => null;
+}
 
-// src/lib/strings.ts
+// src/strings.ts
 var url_re = /^([A-Za-z]{3,9}(?:[+][A-Za-z]{3,9})?):\/\/(?:([-;:&=+$,\w]+)@)?(?:([A-Za-z0-9.-]+)(?::([0-9]{2,5}))?)(\/(?:[-+~%/.,\w]*)?(?:\?[-+=&;%@.,/\w]*)?(?:#[.,!/\w]*)?)?$/;
 var string = define(
-  (blob, ok2, err2) => typeof blob === "string" ? ok2(blob) : err2("Must be string")
+  (blob, ok2, err2) => isString(blob) ? ok2(blob) : err2("Must be string")
 );
 var nonEmptyString = regex(/\S/, "Must be non-empty string");
 function regex(regex2, msg) {
@@ -715,6 +732,15 @@ var httpsUrl = url.refine(
   (value) => value.protocol === "https:",
   "Must be an HTTPS URL"
 );
+var identifier = regex(
+  /^[a-z_][a-z0-9_]*$/i,
+  "Must be valid identifier"
+);
+function nanoid(options) {
+  return regex(/^[a-z0-9_-]+$/i, "Must be nano ID").reject(
+    bySizeOptions(options ?? { size: 21 })
+  );
+}
 var uuid = regex(
   /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
   "Must be uuid"
@@ -727,12 +753,17 @@ var uuidv4 = (
   // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)
   uuid.refine((value) => value[14] === "4", "Must be uuidv4")
 );
+var decimal = regex(/^[0-9]+$/, "Must only contain digits");
+var hexadecimal = regex(
+  /^[0-9a-f]+$/i,
+  "Must only contain hexadecimal digits"
+);
+var numeric = decimal.transform(Number);
 
-// src/lib/dates.ts
+// src/dates.ts
 var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
 var date = define((blob, ok2, err2) => {
-  const date2 = asDate(blob);
-  return date2 !== null ? ok2(date2) : err2("Must be a Date");
+  return isDate(blob) ? ok2(blob) : err2("Must be a Date");
 });
 var iso8601 = (
   // Input itself needs to match the ISO8601 regex...
@@ -747,10 +778,35 @@ var iso8601 = (
     }
   )
 );
+var datelike = either(date, iso8601).describe("Must be a Date or date string");
+
+// src/numbers.ts
+var anyNumber = define(
+  (blob, ok2, err2) => isNumber(blob) ? ok2(blob) : err2("Must be number")
+);
+var number = anyNumber.refine(
+  (n) => Number.isFinite(n),
+  "Number must be finite"
+);
+var integer = number.refine(
+  (n) => Number.isInteger(n),
+  "Number must be an integer"
+);
+var positiveNumber = number.refine(
+  (n) => n >= 0 && !Object.is(n, -0),
+  "Number must be positive"
+);
+var positiveInteger = integer.refine(
+  (n) => n >= 0 && !Object.is(n, -0),
+  "Number must be positive"
+);
+var bigint = define(
+  (blob, ok2, err2) => isBigInt(blob) ? ok2(blob) : err2("Must be bigint")
+);
 
-// src/lib/json.ts
-var jsonObject = lazy(() => dict(json));
-var jsonArray = lazy(() => array2(json));
+// src/json.ts
+var jsonObject = lazy(() => record(json));
+var jsonArray = lazy(() => array(json));
 var json = either(
   null_,
   string,
@@ -762,21 +818,27 @@ var json = either(
 export {
   always,
   anyNumber,
-  array2 as array,
+  array,
+  bigint,
   boolean,
   constant,
   date,
+  datelike,
+  decimal,
   define,
   dict,
   either,
   email,
+  enum_,
   err,
   exact,
   fail,
   formatInline,
   formatShort,
   hardcoded,
+  hexadecimal,
   httpsUrl,
+  identifier,
   inexact,
   instanceOf,
   integer,
@@ -788,6 +850,7 @@ export {
   mapping,
   maybe,
   mixed,
+  nanoid,
   never,
   nonEmptyArray,
   nonEmptyString,
@@ -795,8 +858,8 @@ export {
   nullable,
   nullish,
   number,
-  numericBoolean,
-  object2 as object,
+  numeric,
+  object,
   ok,
   oneOf,
   optional,
@@ -805,17 +868,19 @@ export {
   positiveInteger,
   positiveNumber,
   prep,
+  record,
   regex,
+  select,
   set,
+  setFromArray,
   string,
   taggedUnion,
   truthy,
   tuple,
   undefined_,
-  unknown2 as unknown,
+  unknown,
   url,
   uuid,
   uuidv1,
   uuidv4
 };
-//# sourceMappingURL=index.js.map