@types/parsimmon - npm Package Compare versions

Comparing version 1.10.6 to 1.10.7

parsimmon/index.d.ts

@@ -377,3 +377,3 @@ // Type definitions for Parsimmon 1.10
      */
-    function lookahead(arg: Parser<any> | string | RegExp): Parser<''>;
+    function lookahead(arg: Parser<any> | string | RegExp): Parser<"">;
 
@@ -397,5 +397,26 @@ /**
     function seq<T, U, V, W>(p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>): Parser<[T, U, V, W]>;
-    function seq<T, U, V, W, X>(p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>, p5: Parser<X>): Parser<[T, U, V, W, X]>;
-    function seq<T, U, V, W, X, Y>(p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>, p5: Parser<X>, p6: Parser<Y>): Parser<[T, U, V, W, X, Y]>;
-    function seq<T, U, V, W, X, Y, Z>(p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>, p5: Parser<X>, p6: Parser<Y>, p7: Parser<Z>): Parser<[T, U, V, W, X, Y, Z]>;
+    function seq<T, U, V, W, X>(
+        p1: Parser<T>,
+        p2: Parser<U>,
+        p3: Parser<V>,
+        p4: Parser<W>,
+        p5: Parser<X>,
+    ): Parser<[T, U, V, W, X]>;
+    function seq<T, U, V, W, X, Y>(
+        p1: Parser<T>,
+        p2: Parser<U>,
+        p3: Parser<V>,
+        p4: Parser<W>,
+        p5: Parser<X>,
+        p6: Parser<Y>,
+    ): Parser<[T, U, V, W, X, Y]>;
+    function seq<T, U, V, W, X, Y, Z>(
+        p1: Parser<T>,
+        p2: Parser<U>,
+        p3: Parser<V>,
+        p4: Parser<W>,
+        p5: Parser<X>,
+        p6: Parser<Y>,
+        p7: Parser<Z>,
+    ): Parser<[T, U, V, W, X, Y, Z]>;
     function seq<T>(...parsers: Array<Parser<T>>): Parser<T[]>;
@@ -418,19 +439,76 @@ function seq<T extends any[]>(...parsers: T): Parser<UnParser<T>>;
     function seqMap<T, U, V, W>(p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, cb: (a1: T, a2: U, a3: V) => W): Parser<W>;
-    function seqMap<T, U, V, W, X>(p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>, cb: (a1: T, a2: U, a3: V, a4: W) => X): Parser<X>;
-    function seqMap<T, U, V, W, X, Y>(p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>, p5: Parser<X>, cb: (a1: T, a2: U, a3: V, a4: W, a5: X) => Y): Parser<Y>;
-    function seqMap<T, U, V, W, X, Y, Z>(p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>, p5: Parser<X>, p6: Parser<Y>, cb: (a1: T, a2: U, a3: V, a4: W, a5: X, a6: Y) => Z): Parser<Z>;
+    function seqMap<T, U, V, W, X>(
+        p1: Parser<T>,
+        p2: Parser<U>,
+        p3: Parser<V>,
+        p4: Parser<W>,
+        cb: (a1: T, a2: U, a3: V, a4: W) => X,
+    ): Parser<X>;
+    function seqMap<T, U, V, W, X, Y>(
+        p1: Parser<T>,
+        p2: Parser<U>,
+        p3: Parser<V>,
+        p4: Parser<W>,
+        p5: Parser<X>,
+        cb: (a1: T, a2: U, a3: V, a4: W, a5: X) => Y,
+    ): Parser<Y>;
+    function seqMap<T, U, V, W, X, Y, Z>(
+        p1: Parser<T>,
+        p2: Parser<U>,
+        p3: Parser<V>,
+        p4: Parser<W>,
+        p5: Parser<X>,
+        p6: Parser<Y>,
+        cb: (a1: T, a2: U, a3: V, a4: W, a5: X, a6: Y) => Z,
+    ): Parser<Z>;
     function seqMap<T, U, V, W, X, Y, Z, A>(
-        p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>, p5: Parser<X>, p6: Parser<Y>, p7: Parser<Z>,
-        cb: (a1: T, a2: U, a3: V, a4: W, a5: X, a6: Y, a7: Z) => A): Parser<A>;
+        p1: Parser<T>,
+        p2: Parser<U>,
+        p3: Parser<V>,
+        p4: Parser<W>,
+        p5: Parser<X>,
+        p6: Parser<Y>,
+        p7: Parser<Z>,
+        cb: (a1: T, a2: U, a3: V, a4: W, a5: X, a6: Y, a7: Z) => A,
+    ): Parser<A>;
     function seqMap<T, U, V, W, X, Y, Z, A, B>(
-        p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>, p5: Parser<X>, p6: Parser<Y>, p7: Parser<Z>, p8: Parser<A>,
-        cb: (a1: T, a2: U, a3: V, a4: W, a5: X, a6: Y, a7: Z, a8: A) => B): Parser<B>;
+        p1: Parser<T>,
+        p2: Parser<U>,
+        p3: Parser<V>,
+        p4: Parser<W>,
+        p5: Parser<X>,
+        p6: Parser<Y>,
+        p7: Parser<Z>,
+        p8: Parser<A>,
+        cb: (a1: T, a2: U, a3: V, a4: W, a5: X, a6: Y, a7: Z, a8: A) => B,
+    ): Parser<B>;
     function seqMap<T, U, V, W, X, Y, Z, A, B, C>(
-        p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>, p5: Parser<X>, p6: Parser<Y>, p7: Parser<Z>, p8: Parser<A>, p9: Parser<B>,
-        cb: (a1: T, a2: U, a3: V, a4: W, a5: X, a6: Y, a7: Z, a8: A, a9: B) => C): Parser<C>;
+        p1: Parser<T>,
+        p2: Parser<U>,
+        p3: Parser<V>,
+        p4: Parser<W>,
+        p5: Parser<X>,
+        p6: Parser<Y>,
+        p7: Parser<Z>,
+        p8: Parser<A>,
+        p9: Parser<B>,
+        cb: (a1: T, a2: U, a3: V, a4: W, a5: X, a6: Y, a7: Z, a8: A, a9: B) => C,
+    ): Parser<C>;
     function seqMap<T, U, V, W, X, Y, Z, A, B, C, D>(
-        p1: Parser<T>, p2: Parser<U>, p3: Parser<V>, p4: Parser<W>, p5: Parser<X>, p6: Parser<Y>, p7: Parser<Z>, p8: Parser<A>, p9: Parser<B>, p10: Parser<C>,
-        cb: (a1: T, a2: U, a3: V, a4: W, a5: X, a6: Y, a7: Z, a8: A, a9: B, a10: C) => D): Parser<D>;
+        p1: Parser<T>,
+        p2: Parser<U>,
+        p3: Parser<V>,
+        p4: Parser<W>,
+        p5: Parser<X>,
+        p6: Parser<Y>,
+        p7: Parser<Z>,
+        p8: Parser<A>,
+        p9: Parser<B>,
+        p10: Parser<C>,
+        cb: (a1: T, a2: U, a3: V, a4: W, a5: X, a6: Y, a7: Z, a8: A, a9: B, a10: C) => D,
+    ): Parser<D>;
 
-    function seqObj<T, Key extends keyof T = keyof T>(...args: Array<[Key, Parser<T[Key]>] | Parser<any>>): Parser<{ [K in Key]: T[K] }>;
+    function seqObj<T, Key extends keyof T = keyof T>(
+        ...args: Array<[Key, Parser<T[Key]>] | Parser<any>>
+    ): Parser<{ [K in Key]: T[K] }>;
 
@@ -461,3 +539,5 @@ interface SuccessReply<T> {
      */
-    function custom<U>(parsingFunction: (success: SuccessFunctionType<U>, failure: FailureFunctionType<U>) => ParseFunctionType<U>): Parser<U>;
+    function custom<U>(
+        parsingFunction: (success: SuccessFunctionType<U>, failure: FailureFunctionType<U>) => ParseFunctionType<U>,
+    ): Parser<U>;
 
@@ -585,3 +665,3 @@ /**
      */
-     function byte(int: number): Parser<number>;
+    function byte(int: number): Parser<number>;
     /**
@@ -598,5 +678,7 @@ * Returns a parser that yields a byte (as a number) that matches the given input;
      */
-    function bitSeqObj<Key extends string>(namedAlignments: Array<[Key, number] | number>): Parser<{ [K in Key]: number }>;
+    function bitSeqObj<Key extends string>(
+        namedAlignments: Array<[Key, number] | number>,
+    ): Parser<{ [K in Key]: number }>;
 }
 
 export = Parsimmon;

parsimmon/package.json

 {
     "name": "@types/parsimmon",
-    "version": "1.10.6",
+    "version": "1.10.7",
     "description": "TypeScript definitions for Parsimmon",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/parsimmon",
     "license": "MIT",
@@ -52,4 +53,4 @@ "contributors": [
     "dependencies": {},
-    "typesPublisherContentHash": "003332719be7be86a3a60505bfc2ab8d0f3602e5d7814ce388641788eb6b081a",
-    "typeScriptVersion": "3.3"
+    "typesPublisherContentHash": "aad017caf0314c856b85da669f27a66bbf0b4b9495a6427efcfcfc4dffd35cf0",
+    "typeScriptVersion": "4.5"
 }

parsimmon/README.md

@@ -11,3 +11,3 @@ # Installation
 ### Additional Details
- * Last updated: Sun, 06 Dec 2020 03:04:46 GMT
+ * Last updated: Sun, 24 Sep 2023 06:37:27 GMT
  * Dependencies: none
@@ -14,0 +14,0 @@ * Global values: none

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

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

No website

Quality

Package does not have a website.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

27859

increased by2.71%

Lines of code

631

increased by14.94%

Number of low quality alerts

0

decreased by-100%

No dependency changes