@appliedblockchain/parser-combinators - npm Package Compare versions

Comparing version 3.0.0 to 4.0.0

either.js

@@ -1,20 +0,19 @@
-// @flow strict
-
-const Invalid = require('./invalid')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const either /*: <A, B>(P<A>, P<B>) => P<A | B> */ = /*:: <A, B> */
-  (a, b) =>
-    input => {
-      try {
-        return a(input)
-      } catch (err) {
-        if (err instanceof Invalid) {
-          return b(input)
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.either = void 0;
+const invalid_1 = __importDefault(require("./invalid"));
+exports.either = (a, b) => input => {
+    try {
+        return a(input);
+    }
+    catch (err) {
+        if (err instanceof invalid_1.default) {
+            return b(input);
         }
-        throw err
-      }
+        throw err;
     }
-
-module.exports = either
+};
+exports.default = exports.either;

exhaustive-result.js

@@ -1,17 +0,15 @@
-// @flow strict
-
-const Invalid = require('./invalid')
-
-/*:: import type { Parser } from './types/parser' */
-
-const exhaustiveResult /*: <R>(Parser<R>) => (string => R) */ = /*:: <R> */
-  (a) =>
-    input => {
-      const [ s, r ] = a(input)
-      if (s !== '') {
-        throw new Invalid(`Unparsed ${s}.`)
-      }
-      return r
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exhaustiveResult = void 0;
+const invalid_1 = __importDefault(require("./invalid"));
+exports.exhaustiveResult = a => input => {
+    const [s, r] = a(input);
+    if (s !== '') {
+        throw new invalid_1.default(`Unparsed ${s}.`);
     }
-
-module.exports = exhaustiveResult
+    return r;
+};
+exports.default = exports.exhaustiveResult;

exhaustive-union.js

@@ -1,53 +0,19 @@
-// @flow strict
-
-const exhaustive = require('./exhaustive')
-const Invalid = require('./invalid')
-const maybe = require('./maybe')
-
-/*::
-
-import type { Parser } from './types/parser'
-
-declare function union<A>(Parser<A>): Parser<A>;
-declare function union<A,B>(Parser<A>,Parser<B>): Parser<A|B>;
-declare function union<A,B,C>(Parser<A>,Parser<B>,Parser<C>): Parser<A|B|C>;
-declare function union<A,B,C,D>(Parser<A>,Parser<B>,Parser<C>,Parser<D>): Parser<A|B|C|D>;
-declare function union<A,B,C,D,E>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>): Parser<A|B|C|D|E>;
-declare function union<A,B,C,D,E,F>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>): Parser<A|B|C|D|E|F>;
-declare function union<A,B,C,D,E,F,G>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>): Parser<A|B|C|D|E|F|G>;
-declare function union<A,B,C,D,E,F,G,H>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>): Parser<A|B|C|D|E|F|G|H>;
-declare function union<A,B,C,D,E,F,G,H,I>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>): Parser<A|B|C|D|E|F|G|H|I>;
-declare function union<A,B,C,D,E,F,G,H,I,J>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>): Parser<A|B|C|D|E|F|G|H|I|J>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>): Parser<A|B|C|D|E|F|G|H|I|J|K>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>): Parser<A|B|C|D|E|F|G|H|I|J|K|L>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>,Parser<X>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>,Parser<X>,Parser<Y>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>,Parser<X>,Parser<Y>,Parser<Z>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z>;
-
-*/
-
-// $FlowFixMe
-const exhaustiveUnion =
-  (...as /*: Parser<any>[] */) =>
-    (input /*: string */) => {
-      for (const a of as) {
-        const [ s, r ] = maybe(exhaustive(a))(input)
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exhaustiveUnion = void 0;
+const exhaustive_1 = __importDefault(require("./exhaustive"));
+const invalid_1 = __importDefault(require("./invalid"));
+const maybe_1 = __importDefault(require("./maybe"));
+exports.exhaustiveUnion = (...as) => (input) => {
+    for (const a of as) {
+        const [s, r] = maybe_1.default(exhaustive_1.default(a))(input);
         if (typeof r !== 'undefined') {
-          return [ s, r ]
+            return [s, r];
         }
-      }
-      throw new Invalid(input)
     }
-
-module.exports = exhaustiveUnion
+    throw new invalid_1.default(input);
+};
+exports.default = exports.exhaustiveUnion;

exhaustive.js

@@ -1,17 +0,15 @@
-// @flow strict
-
-const Invalid = require('./invalid')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const exhaustive /*: <A>(P<A>) => P<A> */ = /*:: <A> */
-  (a) =>
-    input => {
-      const [ s, r ] = a(input)
-      if (s !== '') {
-        throw new Invalid(input)
-      }
-      return [ s, r ]
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exhaustive = void 0;
+const invalid_1 = __importDefault(require("./invalid"));
+exports.exhaustive = a => input => {
+    const [s, r] = a(input);
+    if (s !== '') {
+        throw new invalid_1.default(input);
     }
-
-module.exports = exhaustive
+    return [s, r];
+};
+exports.default = exports.exhaustive;

index.js

@@ -1,53 +0,57 @@
-// @flow strict
-
-const either = require('./either')
-const exhaustive = require('./exhaustive')
-const exhaustiveResult = require('./exhaustive-result')
-const exhaustiveUnion = require('./exhaustive-union')
-const Invalid = require('./invalid')
-const left = require('./left')
-const literal = require('./literal')
-const map = require('./map')
-const maybe = require('./maybe')
-const pair = require('./pair')
-const plus = require('./plus')
-const predicate = require('./predicate')
-const range = require('./range')
-const regex = require('./regex')
-const right = require('./right')
-const separated = require('./separated')
-const sequence = require('./sequence')
-const star = require('./star')
-const then = require('./then')
-const times = require('./times')
-const union = require('./union')
-const whileChar = require('./while-char')
-const ws0 = require('./ws0')
-const ws1 = require('./ws1')
-
-module.exports = {
-  either,
-  exhaustive,
-  exhaustiveResult,
-  exhaustiveUnion,
-  Invalid,
-  left,
-  literal,
-  map,
-  maybe,
-  pair,
-  plus,
-  predicate,
-  range,
-  regex,
-  right,
-  sequence,
-  separated,
-  star,
-  then,
-  times,
-  union,
-  whileChar,
-  ws0,
-  ws1
-}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const either_1 = __importDefault(require("./either"));
+const exhaustive_1 = __importDefault(require("./exhaustive"));
+const exhaustive_result_1 = __importDefault(require("./exhaustive-result"));
+const exhaustive_union_1 = __importDefault(require("./exhaustive-union"));
+const invalid_1 = __importDefault(require("./invalid"));
+const left_1 = __importDefault(require("./left"));
+const literal_1 = __importDefault(require("./literal"));
+const map_1 = __importDefault(require("./map"));
+const maybe_1 = __importDefault(require("./maybe"));
+const naive_1 = __importDefault(require("./naive"));
+const pair_1 = __importDefault(require("./pair"));
+const plus_1 = __importDefault(require("./plus"));
+const predicate_1 = __importDefault(require("./predicate"));
+const range_1 = __importDefault(require("./range"));
+const regex_1 = __importDefault(require("./regex"));
+const right_1 = __importDefault(require("./right"));
+const separated_1 = __importDefault(require("./separated"));
+const sequence_1 = __importDefault(require("./sequence"));
+const star_1 = __importDefault(require("./star"));
+const then_1 = __importDefault(require("./then"));
+const times_1 = __importDefault(require("./times"));
+const union_1 = __importDefault(require("./union"));
+const while_char_1 = __importDefault(require("./while-char"));
+const ws0_1 = __importDefault(require("./ws0"));
+const ws1_1 = __importDefault(require("./ws1"));
+exports.default = {
+    either: either_1.default,
+    exhaustive: exhaustive_1.default,
+    exhaustiveResult: exhaustive_result_1.default,
+    exhaustiveUnion: exhaustive_union_1.default,
+    Invalid: invalid_1.default,
+    left: left_1.default,
+    literal: literal_1.default,
+    map: map_1.default,
+    maybe: maybe_1.default,
+    naive: naive_1.default,
+    pair: pair_1.default,
+    plus: plus_1.default,
+    predicate: predicate_1.default,
+    range: range_1.default,
+    regex: regex_1.default,
+    right: right_1.default,
+    sequence: sequence_1.default,
+    separated: separated_1.default,
+    star: star_1.default,
+    then: then_1.default,
+    times: times_1.default,
+    union: union_1.default,
+    whileChar: while_char_1.default,
+    ws0: ws0_1.default,
+    ws1: ws1_1.default
+};

invalid.js

@@ -1,5 +0,7 @@
-// @flow strict
-
-class Invalid extends Error {}
-
-module.exports = Invalid
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Invalid = void 0;
+class Invalid extends Error {
+}
+exports.Invalid = Invalid;
+exports.default = Invalid;

left.js

@@ -1,12 +0,10 @@
-// @flow strict
-
-const pair = require('./pair')
-const map = require('./map')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const left /*: <A, B>(P<A>, P<B>) => P<A> */ = /*:: <A, B> */
-  (a, b) =>
-    map(pair(a, b), _ => _[0])
-
-module.exports = left
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.left = void 0;
+const map_1 = __importDefault(require("./map"));
+const pair_1 = __importDefault(require("./pair"));
+exports.left = (a, b) => map_1.default(pair_1.default(a, b), _ => _[0]);
+exports.default = exports.left;

literal.js

@@ -1,16 +0,14 @@
-// @flow strict
-
-const Invalid = require('./invalid')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const literal /*: string => P<string> */ =
-  expected =>
-    input => {
-      if (input.startsWith(expected)) {
-        return [ input.slice(expected.length), expected ]
-      }
-      throw new Invalid(input)
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.literal = void 0;
+const invalid_1 = __importDefault(require("./invalid"));
+exports.literal = expected => input => {
+    if (input.startsWith(expected)) {
+        return [input.slice(expected.length), expected];
     }
-
-module.exports = literal
+    throw new invalid_1.default(input);
+};
+exports.default = exports.literal;

map.js

@@ -1,12 +0,8 @@
-// @flow strict
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const map /*: <B, A, F: A => B>(P<A>, A => B) => P<B> */ = /*:: <B, A, F> */
-  (a, f) =>
-    input => {
-      const [ s, r ] = a(input)
-      return [ s, f(r) ]
-    }
-
-module.exports = map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = void 0;
+exports.map = (a, f) => input => {
+    const [s, r] = a(input);
+    return [s, f(r)];
+};
+exports.default = exports.map;

maybe.js

@@ -1,20 +0,19 @@
-// @flow strict
-
-const Invalid = require('./invalid')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const maybe /*: <A>(P<A>) => P<?A> */ = /*:: <A> */
-  (a) =>
-    input => {
-      try {
-        return a(input)
-      } catch (err) {
-        if (err instanceof Invalid) {
-          return [ input, undefined ]
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybe = void 0;
+const invalid_1 = __importDefault(require("./invalid"));
+exports.maybe = a => input => {
+    try {
+        return a(input);
+    }
+    catch (err) {
+        if (err instanceof invalid_1.default) {
+            return [input, undefined];
         }
-        throw err
-      }
+        throw err;
     }
-
-module.exports = maybe
+};
+exports.default = exports.maybe;

naive/date-time.js

@@ -1,19 +0,17 @@
-// @flow
-
-const Invalid = require('../invalid')
-const map = require('../map')
-const regex = require('../regex')
-
-/*:: import type { Parser } from '../types/parser' */
-
-const dateTime /*: Parser<Date> */ =
-  input =>
-    map(regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/), ([ _ ]) => {
-      const r = new Date(_)
-      if (isNaN(r)) {
-        throw new Invalid(input)
-      }
-      return r
-    })(input)
-
-module.exports = dateTime
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateTime = void 0;
+const invalid_1 = __importDefault(require("../invalid"));
+const map_1 = __importDefault(require("../map"));
+const regex_1 = __importDefault(require("../regex"));
+exports.dateTime = input => map_1.default(regex_1.default(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/), ([_]) => {
+    const r = new Date(_);
+    if (isNaN(r.getTime())) {
+        throw new invalid_1.default(input);
+    }
+    return r;
+})(input);
+exports.default = exports.dateTime;

naive/date.js

@@ -1,19 +0,17 @@
-// @flow
-
-const Invalid = require('../invalid')
-const map = require('../map')
-const regex = require('../regex')
-
-/*:: import type { Parser } from '../types/parser' */
-
-const date /*: Parser<Date> */ =
-  input =>
-    map(regex(/^\d{4}-\d{2}-\d{2}/), ([ _ ]) => {
-      const r = new Date(_)
-      if (isNaN(r)) {
-        throw new Invalid(input)
-      }
-      return r
-    })(input)
-
-module.exports = date
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.date = void 0;
+const invalid_1 = __importDefault(require("../invalid"));
+const map_1 = __importDefault(require("../map"));
+const regex_1 = __importDefault(require("../regex"));
+exports.date = input => map_1.default(regex_1.default(/^\d{4}-\d{2}-\d{2}/), ([_]) => {
+    const r = new Date(_);
+    if (isNaN(r.getTime())) {
+        throw new invalid_1.default(input);
+    }
+    return r;
+})(input);
+exports.default = exports.date;

naive/decimal.js

@@ -1,23 +0,21 @@
-// @flow
-
-const Invalid = require('../invalid')
-
-/*:: import type { Parser } from '../types/parser' */
-
-const digits = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' ]
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decimal = void 0;
+const invalid_1 = __importDefault(require("../invalid"));
+const digits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
 /** Parses unsigned, decimal integer. Assumes it'll fit into js integer. Leading zero is allowed. */
-const decimal /*: Parser<number> */ =
-  input => {
+exports.decimal = input => {
     for (let i = 0; i < input.length; i++) {
-      if (!digits.includes(input[i])) {
-        if (i === 0) {
-          throw new Invalid(input)
+        if (!digits.includes(input[i])) {
+            if (i === 0) {
+                throw new invalid_1.default(input);
+            }
+            return [input.slice(i), parseInt(input.slice(0, i), 10)];
         }
-        return [ input.slice(i), parseInt(input.slice(0, i), 10) ]
-      }
     }
-    return [ '', parseInt(input, 10) ]
-  }
-
-module.exports = decimal
+    return ['', parseInt(input, 10)];
+};
+exports.default = exports.decimal;

naive/signed-decimal.js

@@ -1,14 +0,13 @@
-// @flow
-
-const decimal = require('./decimal')
-const literal = require('../literal')
-const map = require('../map')
-const maybe = require('../maybe')
-const sequence = require('../sequence')
-
-/*:: import type { Parser } from '../types/parser' */
-
-const signedDecimal /*: Parser<number> */=
-  map(sequence(maybe(literal('-')), decimal), ([ sign, _ ]) => sign ? -_ : _)
-
-module.exports = signedDecimal
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signedDecimal = void 0;
+const decimal_1 = __importDefault(require("./decimal"));
+const literal_1 = __importDefault(require("../literal"));
+const map_1 = __importDefault(require("../map"));
+const maybe_1 = __importDefault(require("../maybe"));
+const sequence_1 = __importDefault(require("../sequence"));
+exports.signedDecimal = map_1.default(sequence_1.default(maybe_1.default(literal_1.default('-')), decimal_1.default), ([sign, _]) => sign ? -_ : _);
+exports.default = exports.signedDecimal;

package.json

 {
   "name": "@appliedblockchain/parser-combinators",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "Monadic parser combinators.",
   "main": "index.js",
   "scripts": {
-    "test": "eslint . && flow check && jest",
-    "update": "npm-check --update --save-exact"
+    "test": "eslint . && tsc --noEmit && jest",
+    "update": "npm-check --update --save-exact",
+    "prepublishOnly": "tsc"
   },
@@ -20,28 +21,36 @@ "keywords": [
     "@appliedblockchain/eslint-config": "2.6.0",
-    "eslint": "7.0.0",
-    "flow-bin": "0.125.1",
-    "jest": "26.0.1",
-    "npm-check": "5.9.2"
+    "@tsconfig/node12": "1.0.7",
+    "@types/jest": "26.0.14",
+    "@typescript-eslint/eslint-plugin": "4.2.0",
+    "@typescript-eslint/parser": "4.2.0",
+    "eslint": "7.10.0",
+    "eslint-plugin-jest": "24.0.2",
+    "jest": "26.4.2",
+    "npm-check": "5.9.2",
+    "ts-jest": "26.4.0",
+    "typescript": "4.0.3"
   },
   "eslintConfig": {
-    "extends": "@appliedblockchain",
-    "rules": {
-      "no-empty": 0,
-      "no-param-reassign": [
-        2,
-        {
-          "props": true
-        }
-      ]
-    }
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+      "@typescript-eslint"
+    ],
+    "extends": [
+      "plugin:@typescript-eslint/recommended",
+      "@appliedblockchain"
+    ]
   },
   "eslintIgnore": [
-    "flow-typed/*",
-    "wip/*"
+    "wip/*",
+    "*.js"
   ],
   "jest": {
-    "modulePathIgnorePatterns": [
-      "<rootDir>/wip"
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "/wip/"
     ]
   }
 }

pair.js

@@ -1,13 +0,9 @@
-// @flow strict
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const pair /*: <A, B>(P<A>, P<B>) => P<[A, B]> */ = /*:: <A, B> */
-  (a, b) =>
-    input => {
-      const [ sa, ra ] = a(input)
-      const [ sb, rb ] = b(sa)
-      return [ sb, [ ra, rb ] ]
-    }
-
-module.exports = pair
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pair = void 0;
+exports.pair = (a, b) => input => {
+    const [sa, ra] = a(input);
+    const [sb, rb] = b(sa);
+    return [sb, [ra, rb]];
+};
+exports.default = exports.pair;

plus.js

@@ -1,11 +0,9 @@
-// @flow strict
-
-const star = require('./star')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const plus /*: <A>(P<A>) => P<A[]> */ = /*:: <A> */
-  (a) =>
-    star(a, 1)
-
-module.exports = plus
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plus = void 0;
+const star_1 = __importDefault(require("./star"));
+exports.plus = a => star_1.default(a, 1);
+exports.default = exports.plus;

predicate.js

@@ -1,17 +0,15 @@
-// @flow strict
-
-const Invalid = require('./invalid')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const predicate /*: <A>(P<A>, A => boolean) => P<A> */ = /*:: <A> */
-  (a, f) =>
-    input => {
-      const [ s, r ] = a(input)
-      if (!f(r)) {
-        throw new Invalid(input)
-      }
-      return [ s, r ]
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.predicate = void 0;
+const invalid_1 = __importDefault(require("./invalid"));
+exports.predicate = (a, f) => input => {
+    const [s, r] = a(input);
+    if (!f(r)) {
+        throw new invalid_1.default(input);
     }
-
-module.exports = predicate
+    return [s, r];
+};
+exports.default = exports.predicate;

range.js

@@ -1,14 +0,12 @@
-// @flow strict
-
-const map = require('./map')
-const pair = require('./pair')
-const star = require('./star')
-const times = require('./times')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const range /*: <A>(P<A>, number, number) => P<A[]> */ = /*:: <A> */
-  (a, min, max) =>
-    map(pair(times(a, min), star(a, max - min)), _ => [ ..._[0], ..._[1] ])
-
-module.exports = range
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.range = void 0;
+const map_1 = __importDefault(require("./map"));
+const pair_1 = __importDefault(require("./pair"));
+const star_1 = __importDefault(require("./star"));
+const times_1 = __importDefault(require("./times"));
+exports.range = (a, min, max) => map_1.default(pair_1.default(times_1.default(a, min), star_1.default(a, max - min)), _ => [..._[0], ..._[1]]);
+exports.default = exports.range;

regex.js

@@ -1,20 +0,18 @@
-// @flow strict
-
-const Invalid = require('./invalid')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const regex /*: RegExp => P<string[]> */ =
-  re =>
-    input => {
-      if (re.flags.includes('g')) {
-        throw new TypeError(`Expected regex without g flag ${String(re)}.`)
-      }
-      const r = input.match(re)
-      if (!r) {
-        throw new Invalid(input)
-      }
-      return [ input.slice(r[0].length), r ]
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regex = void 0;
+const invalid_1 = __importDefault(require("./invalid"));
+exports.regex = re => input => {
+    if (re.flags.includes('g')) {
+        throw new TypeError(`Expected regex without g flag ${String(re)}.`);
     }
-
-module.exports = regex
+    const r = input.match(re);
+    if (!r) {
+        throw new invalid_1.default(input);
+    }
+    return [input.slice(r[0].length), r];
+};
+exports.default = exports.regex;

right.js

@@ -1,12 +0,10 @@
-// @flow strict
-
-const pair = require('./pair')
-const map = require('./map')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const right /*: <A, B>(P<A>, P<B>) => P<B> */ = /*:: <A, B> */
-  (a, b) =>
-    map(pair(a, b), _ => _[1])
-
-module.exports = right
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.right = void 0;
+const pair_1 = __importDefault(require("./pair"));
+const map_1 = __importDefault(require("./map"));
+exports.right = (a, b) => map_1.default(pair_1.default(a, b), _ => _[1]);
+exports.default = exports.right;

separated.js

@@ -1,15 +0,13 @@
-// @flow strict
-
-const map = require('./map')
-const sequence = require('./sequence')
-const star = require('./star')
-const right = require('./right')
-const maybe = require('./maybe')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const separated /*: <A>(P<A>, P<mixed>) => P<A[]> */ = /*:: <A> */
-  (a, s) =>
-    map(sequence(maybe(a), star(right(s, a))), ([ first, rest ]) => (typeof first === 'undefined' ? [] : [ first, ...rest ]))
-
-module.exports = separated
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.separated = void 0;
+const map_1 = __importDefault(require("./map"));
+const sequence_1 = __importDefault(require("./sequence"));
+const star_1 = __importDefault(require("./star"));
+const right_1 = __importDefault(require("./right"));
+const maybe_1 = __importDefault(require("./maybe"));
+exports.separated = (a, s) => map_1.default(sequence_1.default(maybe_1.default(a), star_1.default(right_1.default(s, a))), ([first, rest]) => (typeof first === 'undefined' ? [] : [first, ...rest]));
+exports.default = exports.separated;

sequence.js

@@ -1,50 +0,14 @@
-// @flow strict
-
-/*::
-
-import type { Parser } from './types/parser'
-
-declare function seq<A>(Parser<A>): Parser<[A]>;
-declare function seq<A,B>(Parser<A>,Parser<B>): Parser<[A,B]>;
-declare function seq<A,B,C>(Parser<A>,Parser<B>,Parser<C>): Parser<[A,B,C]>;
-declare function seq<A,B,C,D>(Parser<A>,Parser<B>,Parser<C>,Parser<D>): Parser<[A,B,C,D]>;
-declare function seq<A,B,C,D,E>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>): Parser<[A,B,C,D,E]>;
-declare function seq<A,B,C,D,E,F>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>): Parser<[A,B,C,D,E,F]>;
-declare function seq<A,B,C,D,E,F,G>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>): Parser<[A,B,C,D,E,F,G]>;
-declare function seq<A,B,C,D,E,F,G,H>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>): Parser<[A,B,C,D,E,F,G,H]>;
-declare function seq<A,B,C,D,E,F,G,H,I>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>): Parser<[A,B,C,D,E,F,G,H,I]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>): Parser<[A,B,C,D,E,F,G,H,I,J]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>): Parser<[A,B,C,D,E,F,G,H,I,J,K]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>,Parser<X>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>,Parser<X>,Parser<Y>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y]>;
-declare function seq<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>,Parser<X>,Parser<Y>,Parser<Z>): Parser<[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z]>;
-
-*/
-
-// $FlowFixMe
-const sequence =
-  (...as /*: Parser<any>[] */) =>
-    (input /*: string */) => {
-      const rs = []
-      let s = input
-      for (const a of as) {
-        const r = a(s)
-        s = r[0]
-        rs.push(r[1])
-      }
-      return [ s, rs ]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequence = void 0;
+exports.sequence = (...as) => input => {
+    const rs = [];
+    let s = input;
+    for (const a of as) {
+        const r = a(s);
+        s = r[0];
+        rs.push(r[1]);
     }
-
-module.exports = sequence
+    return [s, rs];
+};
+exports.default = exports.sequence;

star.js

@@ -1,29 +0,28 @@
-// @flow strict
-
-const Invalid = require('./invalid')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const star /*: <A>(P<A>, min?: number) => P<A[]> */ = /*:: <A> */
-  (a, min = 0) =>
-    input => {
-      const r = []
-      let s = input
-      const eat = _ => ((s = _[0]), r.push(_[1]), true)
-      while (true) {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.star = void 0;
+const invalid_1 = __importDefault(require("./invalid"));
+exports.star = (a, min = 0) => input => {
+    const r = [];
+    let s = input;
+    const eat = (_) => ((s = _[0]), r.push(_[1]), true);
+    while (true) {
         try {
-          eat(a(s))
-        } catch (err) {
-          if (err instanceof Invalid) {
-            break
-          }
-          throw err
+            eat(a(s));
         }
-      }
-      if (r.length < min) {
-        throw new Invalid(input)
-      }
-      return [ s, r ]
+        catch (err) {
+            if (err instanceof invalid_1.default) {
+                break;
+            }
+            throw err;
+        }
     }
-
-module.exports = star
+    if (r.length < min) {
+        throw new invalid_1.default(input);
+    }
+    return [s, r];
+};
+exports.default = exports.star;

then.js

@@ -1,12 +0,8 @@
-// @flow strict
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const then /*: <A, B>(P<A>, A => P<B>) => P<B> */ = /*:: <A, B> */
-  (a, f) =>
-    input => {
-      const [ s, r ] = a(input)
-      return f(r)(s)
-    }
-
-module.exports = then
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.then = void 0;
+exports.then = (a, f) => input => {
+    const [s, r] = a(input);
+    return f(r)(s);
+};
+exports.default = exports.then;

times.js

@@ -1,17 +0,13 @@
-// @flow strict
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const times /*: <A>(P<A>, number) => P<A[]> */ = /*:: <A> */
-  (a, n) =>
-    input => {
-      const r = []
-      let s = input
-      const eat = _ => ((s = _[0]), r.push(_[1]))
-      for (let i = 0; i < n; i++) {
-        eat(a(s))
-      }
-      return [ s, r ]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.times = void 0;
+exports.times = (a, n) => input => {
+    const r = [];
+    let s = input;
+    const eat = (_) => ((s = _[0]), r.push(_[1]));
+    for (let i = 0; i < n; i++) {
+        eat(a(s));
     }
-
-module.exports = times
+    return [s, r];
+};
+exports.default = exports.times;

types/parser.js

@@ -1,8 +0,2 @@
-// @flow
-
-/*::
-
-import type { Result } from './result'
-export type Parser<R> = string => Result<R>
-
-*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

types/result.js

@@ -1,7 +0,2 @@
-// @flow
-
-/*::
-
-export type Result<R> = [ string, R ]
-
-*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

union.js

@@ -1,52 +0,18 @@
-// @flow strict
-
-const Invalid = require('./invalid')
-const maybe = require('./maybe')
-
-/*::
-
-import type { Parser } from './types/parser'
-
-declare function union<A>(Parser<A>): Parser<A>;
-declare function union<A,B>(Parser<A>,Parser<B>): Parser<A|B>;
-declare function union<A,B,C>(Parser<A>,Parser<B>,Parser<C>): Parser<A|B|C>;
-declare function union<A,B,C,D>(Parser<A>,Parser<B>,Parser<C>,Parser<D>): Parser<A|B|C|D>;
-declare function union<A,B,C,D,E>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>): Parser<A|B|C|D|E>;
-declare function union<A,B,C,D,E,F>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>): Parser<A|B|C|D|E|F>;
-declare function union<A,B,C,D,E,F,G>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>): Parser<A|B|C|D|E|F|G>;
-declare function union<A,B,C,D,E,F,G,H>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>): Parser<A|B|C|D|E|F|G|H>;
-declare function union<A,B,C,D,E,F,G,H,I>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>): Parser<A|B|C|D|E|F|G|H|I>;
-declare function union<A,B,C,D,E,F,G,H,I,J>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>): Parser<A|B|C|D|E|F|G|H|I|J>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>): Parser<A|B|C|D|E|F|G|H|I|J|K>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>): Parser<A|B|C|D|E|F|G|H|I|J|K|L>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>,Parser<X>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>,Parser<X>,Parser<Y>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y>;
-declare function union<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z>(Parser<A>,Parser<B>,Parser<C>,Parser<D>,Parser<E>,Parser<F>,Parser<G>,Parser<H>,Parser<I>,Parser<J>,Parser<K>,Parser<L>,Parser<M>,Parser<N>,Parser<O>,Parser<P>,Parser<Q>,Parser<R>,Parser<S>,Parser<T>,Parser<U>,Parser<V>,Parser<W>,Parser<X>,Parser<Y>,Parser<Z>): Parser<A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z>;
-
-*/
-
-// $FlowFixMe
-const union =
-  (...as /*: Parser<any>[] */) =>
-    (input /*: string */) => {
-      for (const a of as) {
-        const [ s, r ] = maybe(a)(input)
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.union = void 0;
+const invalid_1 = __importDefault(require("./invalid"));
+const maybe_1 = __importDefault(require("./maybe"));
+exports.union = (...as) => input => {
+    for (const a of as) {
+        const [s, r] = maybe_1.default(a)(input);
         if (typeof r !== 'undefined') {
-          return [ s, r ]
+            return [s, r];
         }
-      }
-      throw new Invalid(input)
     }
-
-module.exports = union
+    throw new invalid_1.default(input);
+};
+exports.default = exports.union;

while-char.js

@@ -1,23 +0,21 @@
-// @flow strict
-
-const { inspect } = require('util')
-const Invalid = require('./invalid')
-
-/*:: import type { Parser as P } from './types/parser' */
-
-const whileChar /*: (string, min?: number) => P<string> */ =
-  (chars, min = 0) =>
-    input => {
-      let i
-      for (i = 0; i < input.length; i++) {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whileChar = void 0;
+const util_1 = require("util");
+const invalid_1 = __importDefault(require("./invalid"));
+exports.whileChar = (chars, min = 0) => input => {
+    let i;
+    for (i = 0; i < input.length; i++) {
         if (!chars.includes(input[i])) {
-          break
+            break;
         }
-      }
-      if (i < min) {
-        throw new Invalid(`Expected ${min} minimum characters passing predicate, character ${inspect(input[i])} didn't pass.`)
-      }
-      return [ input.slice(i), input.slice(0, i) ]
     }
-
-module.exports = whileChar
+    if (i < min) {
+        throw new invalid_1.default(`Expected ${min} minimum characters passing predicate, character ${util_1.inspect(input[i])} didn't pass.`);
+    }
+    return [input.slice(i), input.slice(0, i)];
+};
+exports.default = exports.whileChar;

ws0.js

@@ -1,8 +0,9 @@
-// @flow strict
-
-const whileChar = require('./while-char')
-
-const ws0 =
-  whileChar(' \t\r\n')
-
-module.exports = ws0
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ws0 = void 0;
+const while_char_1 = __importDefault(require("./while-char"));
+exports.ws0 = while_char_1.default(' \t\r\n');
+exports.default = exports.ws0;

ws1.js

@@ -1,8 +0,9 @@
-// @flow strict
-
-const whileChar = require('./while-char')
-
-const ws1 =
-  whileChar(' \t\r\n', 1)
-
-module.exports = ws1
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ws1 = void 0;
+const while_char_1 = __importDefault(require("./while-char"));
+exports.ws1 = while_char_1.default(' \t\r\n', 1);
+exports.default = exports.ws1;

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Number of package files

67

increased by52.27%

Worsened metrics

Total package byte prevSize

30861

decreased by-59.36%

Dev dependency count

11

increased by120%

Lines of code

877

decreased by-55.73%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes