decoders 2.0.0-beta1 → 2.0.0-beta13

package/cjs/stdlib/tuple.js

@@ -1,173 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.tuple1 = tuple1;
-exports.tuple2 = tuple2;
-exports.tuple3 = tuple3;
-exports.tuple4 = tuple4;
-exports.tuple5 = tuple5;
-exports.tuple6 = tuple6;
-
-var _annotate = require("../annotate");
-
-var _composition = require("./composition");
-
-var _result = require("../result");
-
-var _array = require("./array");
-
-var ntuple = function ntuple(n) {
-  return (0, _composition.compose)(_array.poja, (0, _composition.predicate)(function (arr) {
-    return arr.length === n;
-  }, "Must be a " + n + "-tuple"));
-};
-/**
- * Builds a Decoder that returns Ok for 1-tuple of [T], given a Decoder for T.
- * Err otherwise.
- */
-
-
-function tuple1(decoder1) {
-  return (0, _composition.compose)(ntuple(1), function (blobs) {
-    var blob1 = blobs[0];
-    var result1 = decoder1(blob1);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)((0, _result.errValue)(result1)));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 2-tuples of [T1, T2], given Decoders
- * for T1 and T2.  Err otherwise.
- */
-
-
-function tuple2(decoder1, decoder2) {
-  return (0, _composition.compose)(ntuple(2), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 3-tuples of [T1, T2, T3], given
- * Decoders for T1, T2, and T3.  Err otherwise.
- */
-
-
-function tuple3(decoder1, decoder2, decoder3) {
-  return (0, _composition.compose)(ntuple(3), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 4-tuples of [T1, T2, T3, T4], given
- * Decoders for T1, T2, T3, and T4.  Err otherwise.
- */
-
-
-function tuple4(decoder1, decoder2, decoder3, decoder4) {
-  return (0, _composition.compose)(ntuple(4), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2],
-        blob4 = blobs[3];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-    var result4 = decoder4(blob4);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
- * Decoders for T1, T2, T3, T4, and T5.  Err otherwise.
- */
-
-
-function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
-  return (0, _composition.compose)(ntuple(5), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2],
-        blob4 = blobs[3],
-        blob5 = blobs[4];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-    var result4 = decoder4(blob4);
-    var result5 = decoder5(blob5);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4), (0, _result.unwrap)(result5)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4), (0, _result.isErr)(result5) ? (0, _result.errValue)(result5) : (0, _result.value)(result5)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
- * Decoders for T1, T2, T3, T4, T5, and T6.  Err otherwise.
- */
-
-
-function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {
-  return (0, _composition.compose)(ntuple(6), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2],
-        blob4 = blobs[3],
-        blob5 = blobs[4],
-        blob6 = blobs[5];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-    var result4 = decoder4(blob4);
-    var result5 = decoder5(blob5);
-    var result6 = decoder6(blob6);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4), (0, _result.unwrap)(result5), (0, _result.unwrap)(result6)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4), (0, _result.isErr)(result5) ? (0, _result.errValue)(result5) : (0, _result.value)(result5), (0, _result.isErr)(result6) ? (0, _result.errValue)(result6) : (0, _result.value)(result6)]));
-    }
-  });
-}

package/cjs/stdlib/tuple.js.flow

@@ -1,220 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
-import { err, errValue, isErr, ok, unwrap, value } from '../result';
-import { poja } from './array';
-import type { Decoder } from '../_types';
-
-const ntuple = (n: number) =>
-    compose(
-        poja,
-        predicate((arr) => arr.length === n, `Must be a ${n}-tuple`),
-    );
-
-/**
- * Builds a Decoder that returns Ok for 1-tuple of [T], given a Decoder for T.
- * Err otherwise.
- */
-export function tuple1<T>(decoder1: Decoder<T>): Decoder<[T]> {
-    return compose(ntuple(1), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1] = blobs;
-
-        const result1 = decoder1(blob1);
-        try {
-            return ok([unwrap(result1)]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(annotate(errValue(result1)));
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 2-tuples of [T1, T2], given Decoders
- * for T1 and T2.  Err otherwise.
- */
-export function tuple2<T1, T2>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-): Decoder<[T1, T2]> {
-    return compose(ntuple(2), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        try {
-            return ok([unwrap(result1), unwrap(result2)]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(
-                annotate([
-                    isErr(result1) ? errValue(result1) : value(result1),
-                    isErr(result2) ? errValue(result2) : value(result2),
-                ]),
-            );
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 3-tuples of [T1, T2, T3], given
- * Decoders for T1, T2, and T3.  Err otherwise.
- */
-export function tuple3<T1, T2, T3>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-): Decoder<[T1, T2, T3]> {
-    return compose(ntuple(3), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        try {
-            return ok([unwrap(result1), unwrap(result2), unwrap(result3)]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(
-                annotate([
-                    isErr(result1) ? errValue(result1) : value(result1),
-                    isErr(result2) ? errValue(result2) : value(result2),
-                    isErr(result3) ? errValue(result3) : value(result3),
-                ]),
-            );
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 4-tuples of [T1, T2, T3, T4], given
- * Decoders for T1, T2, T3, and T4.  Err otherwise.
- */
-export function tuple4<T1, T2, T3, T4>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-    decoder4: Decoder<T4>,
-): Decoder<[T1, T2, T3, T4]> {
-    return compose(ntuple(4), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3, blob4] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        const result4 = decoder4(blob4);
-        try {
-            return ok([
-                unwrap(result1),
-                unwrap(result2),
-                unwrap(result3),
-                unwrap(result4),
-            ]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(
-                annotate([
-                    isErr(result1) ? errValue(result1) : value(result1),
-                    isErr(result2) ? errValue(result2) : value(result2),
-                    isErr(result3) ? errValue(result3) : value(result3),
-                    isErr(result4) ? errValue(result4) : value(result4),
-                ]),
-            );
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
- * Decoders for T1, T2, T3, T4, and T5.  Err otherwise.
- */
-export function tuple5<T1, T2, T3, T4, T5>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-    decoder4: Decoder<T4>,
-    decoder5: Decoder<T5>,
-): Decoder<[T1, T2, T3, T4, T5]> {
-    return compose(ntuple(5), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3, blob4, blob5] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        const result4 = decoder4(blob4);
-        const result5 = decoder5(blob5);
-        try {
-            return ok([
-                unwrap(result1),
-                unwrap(result2),
-                unwrap(result3),
-                unwrap(result4),
-                unwrap(result5),
-            ]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(
-                annotate([
-                    isErr(result1) ? errValue(result1) : value(result1),
-                    isErr(result2) ? errValue(result2) : value(result2),
-                    isErr(result3) ? errValue(result3) : value(result3),
-                    isErr(result4) ? errValue(result4) : value(result4),
-                    isErr(result5) ? errValue(result5) : value(result5),
-                ]),
-            );
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
- * Decoders for T1, T2, T3, T4, T5, and T6.  Err otherwise.
- */
-export function tuple6<T1, T2, T3, T4, T5, T6>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-    decoder4: Decoder<T4>,
-    decoder5: Decoder<T5>,
-    decoder6: Decoder<T6>,
-): Decoder<[T1, T2, T3, T4, T5, T6]> {
-    return compose(ntuple(6), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3, blob4, blob5, blob6] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        const result4 = decoder4(blob4);
-        const result5 = decoder5(blob5);
-        const result6 = decoder6(blob6);
-        try {
-            return ok([
-                unwrap(result1),
-                unwrap(result2),
-                unwrap(result3),
-                unwrap(result4),
-                unwrap(result5),
-                unwrap(result6),
-            ]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(
-                annotate([
-                    isErr(result1) ? errValue(result1) : value(result1),
-                    isErr(result2) ? errValue(result2) : value(result2),
-                    isErr(result3) ? errValue(result3) : value(result3),
-                    isErr(result4) ? errValue(result4) : value(result4),
-                    isErr(result5) ? errValue(result5) : value(result5),
-                    isErr(result6) ? errValue(result6) : value(result6),
-                ]),
-            );
-        }
-    });
-}

package/es/_guard.js

@@ -1,15 +0,0 @@
-import * as Result from './result';
-import { formatInline } from './format';
-export function guard(decoder, formatter) {
-  if (formatter === void 0) {
-    formatter = formatInline;
-  }
-
-  return function (blob) {
-    return Result.unwrap(Result.mapError(decoder(blob), function (annotation) {
-      var err = new Error('\n' + formatter(annotation));
-      err.name = 'Decoding error';
-      return err;
-    }));
-  };
-}

package/es/format/index.js

@@ -1,2 +0,0 @@
-export { formatInline } from './inline';
-export { formatShort } from './short';

package/es/format/short.js

@@ -1,4 +0,0 @@
-import { summarize as _summarize } from '../_utils';
-export function formatShort(ann) {
-  return _summarize(ann, []).join('\n');
-}

package/es/index.js

@@ -1,37 +0,0 @@
-/**
- * Elm-like JSON decoders, for use with Flow.
- * See http://elmplayground.com/decoding-json-in-elm-1 for an introduction.
- *
- * Why? All JSON responses coming from our API endpoints are just that: free-form
- * JSON data.  To Flow, the only type classification possilbe is "any" -- effectively
- * turning off all type checks for anything related to JSON.  To the receiving end
- * (our frontend), the structure of that data is completely opaque to any type
- * checkers since JSON values can be anything: an object, an array, null, a string,
- * a bool, etc.  Our type system is not a runtime type system, so we need a way of
- * "converting" an any-type JSON value into a type that we want to work with in our
- * frontend code base.
- *
- * Elm's solution to this problem is to define composable decoders: functions that
- * take anything and either fail with an error, or guarantee to return the expected
- * type.  In our case, it's fine to fail with a runtime error.
- *
- */
-export { guard } from './_guard';
-export { compose, map, predicate } from './stdlib/composition';
-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, jsonObject, jsonArray } 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/es/result.js

@@ -1,139 +0,0 @@
-/**
- * Result <value> <error>
- *     = Ok <value>
- *     | Err <error>
- */
-
-/**
- * Create a new Result instance representing a successful computation.
- */
-export function ok(value) {
-  return {
-    type: 'ok',
-    value: value
-  };
-}
-/**
- * Create a new Result instance representing a failed computation.
- */
-
-export function err(error) {
-  return {
-    type: 'err',
-    error: error
-  };
-}
-export function toString(result) {
-  return result.type === 'ok' ? "Ok(" + String(result.value) + ")" : "Err(" + String(result.error) + ")";
-}
-export function isOk(result) {
-  return result.type === 'ok';
-}
-export function isErr(result) {
-  return result.type === 'err';
-}
-export function withDefault(result, defaultValue) {
-  return result.type === 'ok' ? result.value : defaultValue;
-}
-export function value(result) {
-  return result.type === 'ok' ? result.value : undefined;
-}
-export function errValue(result) {
-  return result.type === 'err' ? result.error : undefined;
-}
-/**
- * Unwrap the value from this Result instance if this is an "Ok" result.
- * Otherwise, will throw the "Err" error via a runtime exception.
- */
-
-export function unwrap(result) {
-  if (result.type === 'ok') {
-    return result.value;
-  } else {
-    throw result.error;
-  }
-}
-export function expect(result, message) {
-  if (result.type === 'ok') {
-    return result.value;
-  } else {
-    throw message instanceof Error ? message : new Error(message);
-  }
-}
-export function dispatch(result, okCallback, errCallback) {
-  return result.type === 'ok' ? okCallback(result.value) : errCallback(result.error);
-}
-/**
- * If the given result is OK, defers to the other result. Otherwise returns the
- * error result.
- *
- * It's like saying A && B, but on Result.
- *
- * Examples:
- *
- *     Result.ok(42)     && Result.ok('hi')    // => Ok('hi')
- *     Result.err('boo') && Result.ok('hi')    // => Err('boo')
- *     Result.ok(42)     && Result.err('boo')  // => Err('boo')
- *     Result.err('boo') && Result.err('boo')  // => Err('boo')
- *
- */
-// export function and<T, E, T2>(
-//     result1: Result<T, E>,
-//     result2: Result<T2, E>,
-// ): Result<T2, E> {
-//     return result1.type === 'ok' ? result2 : result1;
-// }
-
-/**
- * If the given result is OK, return that result. Otherwise, defers to the
- * other result.
- *
- * It's like saying A || B, but on Result.
- *
- * Examples:
- *
- *     Result.ok(42)      || Result.ok('hi')    // => Ok(42)
- *     Result.err('boo')  || Result.ok('hi')    // => Ok('hi')
- *     Result.ok(42)      || Result.err('boo')  // => Ok(42)
- *     Result.err('bleh') || Result.err('boo')  // => Err('boo')
- *
- */
-// export function or<T, E, E2>(
-//     result1: Result<T, E>,
-//     result2: Result<T, E2>,
-// ): Result<T, E2> {
-//     return result1.type === 'ok' ? result1 : result2;
-// }
-
-/**
- * Like .and(), aka &&, but the second argument gets evaluated lazily only if
- * the first result is an Ok result. If so, it has access to the Ok value from
- * the first argument.
- */
-
-export function andThen(result1, lazyResult2) {
-  return result1.type === 'ok' ? lazyResult2(result1.value) : result1;
-}
-/**
- * Like .or(), aka ||, but the second argument gets evaluated lazily only if
- * the first result is an Err result. If so, it has access to the Err value
- * from the first argument.
- */
-
-export function orElse(result1, lazyResult2) {
-  return result1.type === 'ok' ? result1 : lazyResult2(result1.error);
-}
-/**
- * Transform an Ok result. Will not touch Err results.
- */
-
-export function map(result, mapper) {
-  return result.type === 'ok' ? ok(mapper(result.value)) : result;
-}
-/**
- * Transform an Err value. Will not touch Ok results.
- */
-
-export function mapError(result, mapper) {
-  return result.type === 'ok' ? result : err(mapper(result.error));
-}

package/es/stdlib/array.js

@@ -1,91 +0,0 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
-
-/**
- * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
- * Array" ^_^
- */
-export var poja = function poja(blob) {
-  if (!Array.isArray(blob)) {
-    return Result.err(annotate(blob, 'Must be an array'));
-  }
-
-  return 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 array of Result instances, loop over 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
- */
-
-function all(items, blobs) {
-  var results = [];
-
-  for (var index = 0; index < items.length; ++index) {
-    var result = items[index];
-
-    if (result.type === 'ok') {
-      results.push(result.value);
-    } else {
-      var ann = result.error; // Rewrite the annotation to include the index information, and inject it into the original blob
-
-      var clone = [].concat(blobs);
-      clone.splice(index, 1, annotate(ann, ann.text ? ann.text + " (at index " + index + ")" : "index " + 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 Result.err(annotate(clone));
-    }
-  }
-
-  return 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.
- */
-
-
-export function array(decoder) {
-  return compose(poja, members(decoder));
-}
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, but will reject
- * empty arrays.
- */
-
-export function nonEmptyArray(decoder) {
-  return compose(array(decoder), predicate(function (arr) {
-    return arr.length > 0;
-  }, 'Must be non-empty array'));
-}