decoders 1.25.4 → 2.0.0-beta1

package/{array.d.ts → ts/array.d.ts}

@@ -1,4 +1,4 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export const poja: Decoder<unknown[]>;
 export function array<T>(decoder: Decoder<T>): Decoder<T[]>;

package/{boolean.d.ts → ts/boolean.d.ts}

@@ -1,4 +1,4 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export const boolean: Decoder<boolean>;
 export const truthy: Decoder<boolean>;

package/{constants.d.ts → ts/constants.d.ts}

@@ -1,4 +1,4 @@
-import { Decoder, Scalar } from './types';
+import { Decoder, Scalar } from '../_types';
 
 // Constants
 

package/{date.d.ts → ts/date.d.ts}

@@ -1,4 +1,4 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export const date: Decoder<Date>;
 export const iso8601: Decoder<Date>;

package/{describe.d.ts → ts/describe.d.ts}

@@ -1,3 +1,3 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export function describe<T>(decoder: Decoder<T>, msg: string): Decoder<T>;

package/{dispatch.d.ts → ts/dispatch.d.ts}

@@ -1,8 +1,8 @@
-import { Decoder, $DecoderType } from './types';
+import { Decoder, DecoderType } from '../_types';
 
 export type $Values<T extends object> = T[keyof T];
 
 export function dispatch<O extends { [key: string]: Decoder<any> }>(
     field: string,
-    mapping: O
-): Decoder<$Values<{ [key in keyof O]: $DecoderType<O[key]> }>>;
+    mapping: O,
+): Decoder<$Values<{ [key in keyof O]: DecoderType<O[key]> }>>;

package/{either.d.ts → ts/either.d.ts}

@@ -1,24 +1,24 @@
-import { Decoder, Scalar } from './types';
+import { Decoder, Scalar } from '../_types';
 
 export function either<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2>;
 export function either2<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2>;
 export function either3<T1, T2, T3>(
     d1: Decoder<T1>,
     d2: Decoder<T2>,
-    d3: Decoder<T3>
+    d3: Decoder<T3>,
 ): Decoder<T1 | T2 | T3>;
 export function either4<T1, T2, T3, T4>(
     d1: Decoder<T1>,
     d2: Decoder<T2>,
     d3: Decoder<T3>,
-    d4: Decoder<T4>
+    d4: Decoder<T4>,
 ): Decoder<T1 | T2 | T3 | T4>;
 export function either5<T1, T2, T3, T4, T5>(
     d1: Decoder<T1>,
     d2: Decoder<T2>,
     d3: Decoder<T3>,
     d4: Decoder<T4>,
-    d5: Decoder<T5>
+    d5: Decoder<T5>,
 ): Decoder<T1 | T2 | T3 | T4 | T5>;
 export function either6<T1, T2, T3, T4, T5, T6>(
     d1: Decoder<T1>,
@@ -26,7 +26,7 @@ export function either6<T1, T2, T3, T4, T5, T6>(
     d3: Decoder<T3>,
     d4: Decoder<T4>,
     d5: Decoder<T5>,
-    d6: Decoder<T6>
+    d6: Decoder<T6>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6>;
 export function either7<T1, T2, T3, T4, T5, T6, T7>(
     d1: Decoder<T1>,
@@ -35,7 +35,7 @@ export function either7<T1, T2, T3, T4, T5, T6, T7>(
     d4: Decoder<T4>,
     d5: Decoder<T5>,
     d6: Decoder<T6>,
-    d7: Decoder<T7>
+    d7: Decoder<T7>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
 export function either8<T1, T2, T3, T4, T5, T6, T7, T8>(
     d1: Decoder<T1>,
@@ -45,7 +45,7 @@ export function either8<T1, T2, T3, T4, T5, T6, T7, T8>(
     d5: Decoder<T5>,
     d6: Decoder<T6>,
     d7: Decoder<T7>,
-    d8: Decoder<T8>
+    d8: Decoder<T8>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
 export function either9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
     d1: Decoder<T1>,
@@ -56,6 +56,6 @@ export function either9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
     d6: Decoder<T6>,
     d7: Decoder<T7>,
     d8: Decoder<T8>,
-    d9: Decoder<T9>
+    d9: Decoder<T9>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
 export function oneOf<T extends Scalar>(constants: readonly T[]): Decoder<T>;

package/{fail.d.ts → ts/fail.d.ts}

@@ -1,3 +1,3 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export function fail(msg: string): Decoder<never>;

package/ts/index.d.ts

@@ -0,0 +1,42 @@
+export { Decoder, Guard } from './_types';
+export { DecoderType, GuardType } from './_types';
+
+export { guard } from './_guard';
+export { compose, map, predicate } from './_utils';
+
+export { JSONArray, JSONObject, JSONValue } from './stdlib/json';
+
+export { array, nonEmptyArray, poja } from './stdlib/array';
+export { boolean, numericBoolean, truthy } from './stdlib/boolean';
+export {
+    constant,
+    hardcoded,
+    mixed,
+    null_,
+    undefined_,
+    unknown,
+} from './stdlib/constants';
+export { date, iso8601 } from './stdlib/date';
+export { describe } from './stdlib/describe';
+export { dispatch } from './stdlib/dispatch';
+export {
+    either,
+    either3,
+    either4,
+    either5,
+    either6,
+    either7,
+    either8,
+    either9,
+    oneOf,
+} from './stdlib/either';
+export { fail } from './stdlib/fail';
+export { instanceOf } from './stdlib/instanceOf';
+export { json, jsonArray, jsonObject } from './stdlib/json';
+export { lazy } from './stdlib/lazy';
+export { mapping, dict } from './stdlib/mapping';
+export { integer, number, positiveInteger, positiveNumber } from './stdlib/number';
+export { exact, inexact, object, pojo } from './stdlib/object';
+export { maybe, nullable, optional } from './stdlib/optional';
+export { email, nonEmptyString, regex, string, url } from './stdlib/string';
+export { tuple1, tuple2, tuple3, tuple4, tuple5, tuple6 } from './stdlib/tuple';

package/ts/inline.d.ts

@@ -0,0 +1,3 @@
+import { Annotation } from '../annotate';
+
+export function formatInline(ann: Annotation): string;

package/{instanceOf.d.ts → ts/instanceOf.d.ts}

@@ -1,3 +1,3 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export function instanceOf<T>(klass: new (...args: any) => T): Decoder<T>;

package/{json.d.ts → ts/json.d.ts}

@@ -1,4 +1,4 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
 export interface JSONObject {

package/{lazy.d.ts → ts/lazy.d.ts}

@@ -1,3 +1,3 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export function lazy<T>(decoderFn: () => Decoder<T>): Decoder<T>;

package/{mapping.d.ts → ts/mapping.d.ts}

@@ -1,4 +1,4 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>>;
 export function dict<T>(decoder: Decoder<T>): Decoder<{ [key: string]: T }>;

package/{number.d.ts → ts/number.d.ts}

@@ -1,4 +1,4 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export const integer: Decoder<number>;
 export const number: Decoder<number>;

package/{object.d.ts → ts/object.d.ts}

@@ -1,14 +1,14 @@
-import { $DecoderType, Decoder } from './types';
-import { AllowImplicit } from './helpers';
+import { Decoder, DecoderType } from '../_types';
+import { AllowImplicit } from './_helpers';
 
-export type ObjectDecoderType<T> = AllowImplicit<
-    { [key in keyof T]: $DecoderType<T[key]> }
->;
+export type ObjectDecoderType<T> = AllowImplicit<{
+    [key in keyof T]: DecoderType<T[key]>;
+}>;
 
 export const pojo: Decoder<{ [key: string]: unknown }>;
 
 export function object<O extends { [key: string]: Decoder<any> }>(
-    mapping: O
+    mapping: O,
 ): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
 //         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //         This is basically just equivalent to:
@@ -19,13 +19,13 @@ export function object<O extends { [key: string]: Decoder<any> }>(
 //         work with while developing.
 
 export function exact<O extends { [key: string]: Decoder<any> }>(
-    mapping: O
+    mapping: O,
 ): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
 //         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //         Ditto (see above)
 
 export function inexact<O extends { [key: string]: Decoder<any> }>(
-    mapping: O
+    mapping: O,
 ): Decoder<
     { [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] } & {
         [extra: string]: unknown;

package/{optional.d.ts → ts/optional.d.ts}

@@ -1,4 +1,4 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export function optional<T>(decoder: Decoder<T>): Decoder<T | undefined>;
 export function nullable<T>(decoder: Decoder<T>): Decoder<T | null>;

package/ts/result.d.ts

@@ -0,0 +1,39 @@
+export interface Ok<T> {
+    readonly type: 'ok';
+    readonly value: T;
+}
+
+export interface Err<E> {
+    readonly type: 'err';
+    readonly error: E;
+}
+
+export type Result<T, E> = Ok<T> | Err<E>;
+
+export function ok<T>(value: T): Ok<T>;
+export function err<E>(error: E): Err<E>;
+export function toString(result: Result<unknown, unknown>): string;
+export function isOk(result: Result<unknown, unknown>): boolean;
+export function isErr(result: Result<unknown, unknown>): boolean;
+export function withDefault<T>(result: Result<T, unknown>, defaultValue: T): T;
+export function value<T>(result: Result<T, unknown>): void | T;
+export function errValue<E>(result: Result<unknown, E>): void | E;
+export function unwrap<T>(result: Result<T, unknown>): T;
+export function expect<T>(result: Result<T, unknown>, message: string | Error): T;
+export function dispatch<T, E, O>(
+    result: Result<T, E>,
+    okCallback: (value: T) => O,
+    errCallback: (error: E) => O,
+): O;
+export function andThen<T, E, V>(
+    result: Result<T, E>,
+    callback: (value: T) => Result<V, E>,
+): Result<V, E>;
+export function map<T, E, T2>(
+    result: Result<T, E>,
+    mapper: (value: T) => T2,
+): Result<T2, E>;
+export function mapError<T, E, E2>(
+    result: Result<T, E>,
+    mapper: (error: E) => E2,
+): Result<T, E2>;

package/ts/short.d.ts

@@ -0,0 +1,3 @@
+import { Annotation } from '../annotate';
+
+export function formatShort(ann: Annotation): string;

package/{string.d.ts → ts/string.d.ts}

@@ -1,4 +1,4 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export const string: Decoder<string>;
 export const nonEmptyString: Decoder<string>;

package/{tuple.d.ts → ts/tuple.d.ts}

@@ -1,24 +1,24 @@
-import { Decoder } from './types';
+import { Decoder } from '../_types';
 
 export function tuple1<T1>(d1: Decoder<T1>): Decoder<[T1]>;
 export function tuple2<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<[T1, T2]>;
 export function tuple3<T1, T2, T3>(
     d1: Decoder<T1>,
     d2: Decoder<T2>,
-    d3: Decoder<T3>
+    d3: Decoder<T3>,
 ): Decoder<[T1, T2, T3]>;
 export function tuple4<T1, T2, T3, T4>(
     d1: Decoder<T1>,
     d2: Decoder<T2>,
     d3: Decoder<T3>,
-    d4: Decoder<T4>
+    d4: Decoder<T4>,
 ): Decoder<[T1, T2, T3, T4]>;
 export function tuple5<T1, T2, T3, T4, T5>(
     d1: Decoder<T1>,
     d2: Decoder<T2>,
     d3: Decoder<T3>,
     d4: Decoder<T4>,
-    d5: Decoder<T5>
+    d5: Decoder<T5>,
 ): Decoder<[T1, T2, T3, T4, T5]>;
 export function tuple6<T1, T2, T3, T4, T5, T6>(
     d1: Decoder<T1>,
@@ -26,5 +26,5 @@ export function tuple6<T1, T2, T3, T4, T5, T6>(
     d3: Decoder<T3>,
     d4: Decoder<T4>,
     d5: Decoder<T5>,
-    d6: Decoder<T6>
+    d6: Decoder<T6>,
 ): Decoder<[T1, T2, T3, T4, T5, T6]>;

package/array.js

@@ -1,133 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.array = array;
-exports.nonEmptyArray = nonEmptyArray;
-exports.poja = void 0;
-
-var _debrief = require("debrief");
-
-var _Result = require("lemons/Result");
-
-var _utils = require("./utils");
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-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."); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-/**
- * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
- * Array" ^_^
- */
-var poja = function poja(blob) {
-  if (!Array.isArray(blob)) {
-    return (0, _Result.Err)((0, _debrief.annotate)(blob, 'Must be an array'));
-  }
-
-  return (0, _Result.Ok)( // NOTE: Since Flow 0.98, Array.isArray() returns $ReadOnlyArray<mixed>
-  // instead of Array<mixed>.  For rationale, see
-  // https://github.com/facebook/flow/issues/7684.  In this case, we
-  // don't want to output read-only types because it's up to the user of
-  // decoders to determine what they want to do with the decoded output.
-  // If they want to write items into the array, that's fine!
-  // The fastest way to turn a read-only array into a normal array in
-  // Javascript is to use .slice() on it, see this benchmark:
-  // http://jsben.ch/lO6C5
-  blob.slice());
-};
-/**
- * Given an iterable of Result instances, exhaust them all and return:
- * - An [index, err] tuple, indicating the (index of the) first Err instance
- *   encountered; or
- * - a new Ok with an array of all unwrapped Ok'ed values
- */
-
-
-exports.poja = poja;
-
-function all(iterable, blobs) {
-  var results = [];
-  var index = 0;
-
-  var _iterator = _createForOfIteratorHelper(iterable),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var result = _step.value;
-
-      try {
-        var value = result.unwrap();
-        results.push(value);
-      } catch (ann) {
-        // Rewrite the annotation to include the index information, and inject it into the original blob
-        var clone = _toConsumableArray(blobs);
-
-        clone.splice(index, 1, (0, _debrief.annotate)(ann, ann.annotation !== undefined ? "".concat(ann.annotation, " (at index ").concat(index, ")") : "index ".concat(index))); // const errValue = [];
-        // if (index > 0) {
-        //     errValue.push('...'); // TODO: make special mark, not string!
-        // }
-        // errValue.push(
-        // );
-        // if (index < iterable.length - 1) {
-        //     errValue.push('...'); // TODO: make special mark, not string!
-        // }
-
-        return (0, _Result.Err)((0, _debrief.annotate)(clone));
-      }
-
-      index++;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-
-  return (0, _Result.Ok)(results);
-}
-/**
- * Given a T, builds a decoder that assumes an array input and returns an
- * Array<T>.
- */
-
-
-function members(decoder) {
-  return function (blobs) {
-    var results = blobs.map(decoder);
-    var result = all(results, blobs);
-    return result;
-  };
-}
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, given a Decoder
- * for `T`.  Err otherwise.
- */
-
-
-function array(decoder) {
-  return (0, _utils.compose)(poja, members(decoder));
-}
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, but will reject
- * empty arrays.
- */
-
-
-function nonEmptyArray(decoder) {
-  return (0, _utils.compose)(array(decoder), (0, _utils.predicate)(function (arr) {
-    return arr.length > 0;
-  }, 'Must be non-empty array'));
-}

package/boolean.js

@@ -1,42 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.truthy = exports.numericBoolean = exports["boolean"] = void 0;
-
-var _debrief = require("debrief");
-
-var _Result = require("lemons/Result");
-
-var _number = require("./number");
-
-var _utils = require("./utils");
-
-/**
- * Decoder that only returns Ok for boolean inputs.  Err otherwise.
- */
-var _boolean = function _boolean(blob) {
-  return typeof blob === 'boolean' ? (0, _Result.Ok)(blob) : (0, _Result.Err)((0, _debrief.annotate)(blob, 'Must be boolean'));
-};
-/**
- * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
- */
-
-
-exports["boolean"] = _boolean;
-
-var truthy = function truthy(blob) {
-  return (0, _Result.Ok)(!!blob);
-};
-/**
- * Decoder that only returns Ok for numeric input values representing booleans.
- * Returns their boolean representation.  Err otherwise.
- */
-
-
-exports.truthy = truthy;
-var numericBoolean = (0, _utils.map)(_number.number, function (n) {
-  return !!n;
-});
-exports.numericBoolean = numericBoolean;

package/constants.js

@@ -1,67 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.constant = constant;
-exports.hardcoded = hardcoded;
-exports.unknown = exports.undefined_ = exports.null_ = exports.mixed = void 0;
-
-var _debrief = require("debrief");
-
-var _Result = require("lemons/Result");
-
-/**
- * Decoder that only returns Ok for `null` inputs.  Err otherwise.
- */
-var null_ = function null_(blob) {
-  return blob === null ? (0, _Result.Ok)(blob) : (0, _Result.Err)((0, _debrief.annotate)(blob, 'Must be null'));
-};
-/**
- * Decoder that only returns Ok for `undefined` inputs.  Err otherwise.
- */
-
-
-exports.null_ = null_;
-
-var undefined_ = function undefined_(blob) {
-  return blob === undefined ? (0, _Result.Ok)(blob) : (0, _Result.Err)((0, _debrief.annotate)(blob, 'Must be undefined'));
-};
-/**
- * Decoder that only returns Ok for the given value constant.  Err otherwise.
- */
-
-
-exports.undefined_ = undefined_;
-
-function constant(value) {
-  return function (blob) {
-    return blob === value ? (0, _Result.Ok)(value) : (0, _Result.Err)((0, _debrief.annotate)(blob, "Must be constant ".concat(String(value))));
-  };
-}
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-
-
-function hardcoded(value) {
-  return function (_) {
-    return (0, _Result.Ok)(value);
-  };
-}
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-
-
-var mixed = function mixed(blob) {
-  return (0, _Result.Ok)(blob);
-};
-/**
- * Alias of mixed.
- */
-
-
-exports.mixed = mixed;
-var unknown = mixed;
-exports.unknown = unknown;

package/date.js

@@ -1,42 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.iso8601 = exports.date = void 0;
-
-var _debrief = require("debrief");
-
-var _Result = require("lemons/Result");
-
-var _string = require("./string");
-
-var _utils = require("./utils");
-
-// Only matches the shape.  This "over-matches" some values that still aren't
-// valid dates (like 9999-99-99), but those will be caught by JS Date's
-// internal validations
-var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
-
-var date = function date(value) {
-  return (0, _utils.isDate)(value) ? (0, _Result.Ok)(value) : (0, _Result.Err)((0, _debrief.annotate)(value, 'Must be a Date'));
-};
-/**
- * Decoder that only returns Ok for strings that are valid ISO8601 date
- * strings.  Err otherwise.
- */
-
-
-exports.date = date;
-var iso8601 = (0, _utils.map)( // Input itself needs to match the ISO8601 regex...
-(0, _string.regex)(iso8601_re, 'Must be ISO8601 format'), // Make sure it is a _valid_ date
-function (value) {
-  var date = new Date(value);
-
-  if (isNaN(date.getTime())) {
-    throw new Error('Must be valid date/time value');
-  }
-
-  return date;
-});
-exports.iso8601 = iso8601;