parser-combinators 1.2.0 → 1.2.2

package/dist/index.min.js

@@ -0,0 +1,4 @@
+var a=(e,n)=>()=>(n||e((n={exports:{}}).exports,n),n.exports);var l=a(p=>{"use strict";Object.defineProperty(p,"__esModule",{value:!0});p.ParseError=void 0;p.isFailure=be;p.success=k;p.failure=ee;p.result=ve;p.fail=Pe;function be(e){return!e.success}function k(e,n){return{success:!0,value:n,ctx:e}}function ee(e,n,t){return{success:!1,expected:n,ctx:e,history:t}}function ve(e){return n=>k(n,e)}function Pe(e){return n=>ee(n,e,[e])}var B=class extends Error{constructor(n,t,r,s){super(n),this.index=r,this.history=s,[this.line,this.column,this.row]=this.getInputData(t,r)}getInputData(n,t){let r=n.split(`
+`),s=0;for(;t>0;){if(r[s].length>t)return[r[s],t+1,s+1];t-=r[s].length+1,s+=1}return[r[s],t+1,s+1]}getPrettyErrorMessage(){return`${this.message} (line ${this.row}, col ${this.column}):
+${this.line}
+${(this.column>0?"-".repeat(this.column-1):"")+"^"}`}};p.ParseError=B});var te=a(z=>{"use strict";Object.defineProperty(z,"__esModule",{value:!0});z.anyString=Oe;var re=l();function Oe(e){let n=`'${e[e.length-1][0]}'`,t;return Object.assign(r=>{t??=we(e);let s=Me(t,r.text,r.index);return s?(0,re.success)({...r,index:s.end},e[s.matchIndex][0]):(0,re.failure)(r,n,["any",n])},{parserType:"anyString",matches:e})}function we(e){let n=new Map;return e.forEach((t,r)=>w(n,t,r)),n}function w(e,n,t,r=0){if(r>=n[0].length)e.matchIndex!=null?e.matchIndex=Math.min(e.matchIndex,t):e.matchIndex=t;else{let s=n[0][r],u=s.toLowerCase(),i=s.toUpperCase(),g=new Map;if(n[1]&&u!==i){let q=e.get(u)??g,_=e.get(i)??g;e.set(u,q),e.set(i,_),w(q,n,t,r+1),q!==_&&w(_,n,t,r+1)}else{let q=e.get(s)??g;e.set(s,q);let _=e.get(u);if(_===e.get(i)){let Z=new Map(_.entries());Z.matchIndex=_.matchIndex,e.set(i,Z)}w(q,n,t,r+1)}}}function Me(e,n,t){let r,s,u=e;for(let i=t;i<n.length;i++){let g=n[i];if(u.matchIndex!=null&&(s==null||u.matchIndex<=s)&&(r=i,s=u.matchIndex),u=u.get(g),!u)break}return u&&u.matchIndex!=null&&(s==null||u.matchIndex<=s)&&(r=n.length,s=u.matchIndex),r==null?void 0:{end:r,matchIndex:s}}});var M=a(f=>{"use strict";Object.defineProperty(f,"__esModule",{value:!0});f.toggleFusions=f.shouldPerformFusions=void 0;f.ref=Fe;f.expect=se;f.expectErase=Se;f.surely=$e;f.token=Te;f.lookaround=Ie;var h=l(),je=()=>ne;f.shouldPerformFusions=je;var ne=!0,me=e=>{ne=e};f.toggleFusions=me;function Fe(e,n,t){return r=>{let s=e(r);return!(0,h.isFailure)(s)&&!n(s.value)?(0,h.failure)(s.ctx,t??"check",[`ref: ${t??"check"}`]):s}}function se(e,n){return t=>{let r=e(t);return(0,h.isFailure)(r)?(0,h.failure)(r.ctx,n,[n,...r.history]):r}}function Se(e,n){return t=>{let r=e(t);return(0,h.isFailure)(r)?(0,h.failure)(r.ctx,n,[n]):r}}function $e(e){return se(e,"surely")}function Te(e){return n=>{let t=e(n);return t.success?{...t,value:{value:t.value,start:n.index,end:t.ctx.index}}:t}}function Ie(e){return n=>{let t=e(n);return t.success?(0,h.success)(n,void 0):(0,h.failure)(n,t.expected,["lookaround",...t.history])}}});var ue=a(R=>{"use strict";Object.defineProperty(R,"__esModule",{value:!0});R.any=ze;var D=l(),Ee=te(),Ce=M(),Be=["str","stri","anyString"];function ze(...e){let n={};if((0,Ce.shouldPerformFusions)()&&e.every(t=>"parserType"in t&&typeof t.parserType=="string"&&Be.includes(t.parserType))){let r=e.flatMap(s=>{switch(s.parserType){case"anyString":return s.matches;case"str":return[[s.match,!1]];case"stri":return[[s.match,!0]]}});if(r.length>10)return(0,Ee.anyString)(r);n={parserType:"anyString",matches:r}}return Object.assign(t=>{let r=[];for(let u of e){let i=u(t);if((0,D.isFailure)(i)){if(i.history.includes("surely"))return(0,D.failure)(i.ctx,i.expected,i.history.filter(g=>g!=="surely"));r.push(i)}else return i}let s=r.reduce((u,i)=>u.history.length>i.history.length?u:i);return(0,D.failure)(s.ctx,s.expected,["any",...s.history])},n)}});var v=a(Q=>{"use strict";Object.defineProperty(Q,"__esModule",{value:!0});Q.seq=De;var N=l();function De(...e){return n=>{let t=[];for(let r of e){let s=r(n);if(n=s.ctx,(0,N.isFailure)(s))return(0,N.failure)(s.ctx,s.expected,["seq",...s.history]);t.push(s.value)}return(0,N.success)(n,t)}}});var oe=a(A=>{"use strict";Object.defineProperty(A,"__esModule",{value:!0});A.between=Ne;var ie=l(),Re=v();function Ne(e,n,t){let r=(0,Re.seq)(e,n,t);return s=>{let u=r(s);if((0,ie.isFailure)(u)){let i=[...u.history];return i.splice(0,1),(0,ie.failure)(u.ctx,u.expected,["between",...i])}return{...u,value:u.value[1]}}}});var ce=a(H=>{"use strict";Object.defineProperty(H,"__esModule",{value:!0});H.exhaust=Qe;var P=l();function Qe(e,n=null){return t=>{let r=[];for(;;){let s=e(t);if((0,P.isFailure)(s))return n===null||(0,P.isFailure)(n(t))?(0,P.failure)(s.ctx,s.expected,["exhaust",...s.history]):(0,P.success)(t,r);if(t=s.ctx,r.push(s.value),s.ctx.index===s.ctx.text.length)return(0,P.success)(s.ctx,r)}}}});var m=a(L=>{"use strict";Object.defineProperty(L,"__esModule",{value:!0});L.map=Ae;var j=l();function Ae(e,n){return t=>{let r=e(t);if((0,j.isFailure)(r))return(0,j.failure)(r.ctx,r.expected,["map",...r.history]);try{let s=n(r.value);return(0,j.success)(r.ctx,s)}catch{return(0,j.failure)(r.ctx,"Error while mapping",["map"])}}}});var F=a(U=>{"use strict";Object.defineProperty(U,"__esModule",{value:!0});U.opt=He;var ae=l();function He(e){return n=>{let t=e(n);return(0,ae.isFailure)(t)?(0,ae.success)(n,null):t}}});var fe=a(b=>{"use strict";Object.defineProperty(b,"__esModule",{value:!0});b.many=V;b.zeroOrMany=Ue;b.oneOrMany=le;b.oneOrManyRed=Ve;var S=l(),x=m(),Le=F(),$=v();function V(e){return n=>{let t=[];for(;;){let r=e(n);if((0,S.isFailure)(r))return(0,S.success)(n,t);n=r.ctx,t.push(r.value)}}}function Ue(e,n){return(0,x.map)((0,Le.opt)(le(e,n)),t=>t??[])}function le(e,n=void 0){let t=(0,x.map)((0,$.seq)(e,V(n?(0,x.map)((0,$.seq)(n,e),([,r])=>r):e)),([r,s])=>[r,...s]);return r=>{let s=t(r);if((0,S.isFailure)(s)){let u=[...s.history];return u.splice(0,2),(0,S.failure)(s.ctx,s.expected,["oneOrMany",...u])}return s}}function Ve(e,n,t){return(0,x.map)((0,x.map)((0,$.seq)((0,x.map)(e,r=>[null,r]),V((0,$.seq)(n,e))),([r,s])=>[r,...s]),r=>{let s=r[0][1];for(let u=1;u<r.length;u++)s=t(s,r[u][1],r[u][0]);return s})}});var G=a(W=>{"use strict";Object.defineProperty(W,"__esModule",{value:!0});W.regex=We;var de=l();function We(e,n){let t=new RegExp(e,typeof e=="string"?"y":e.flags+"y");return r=>{t.lastIndex=r.index;let s=t.exec(r.text);return s!==null&&s.index===r.index?(0,de.success)({...r,index:r.index+s[0].length},s[0]):(0,de.failure)(r,n,[n])}}});var J=a(I=>{"use strict";Object.defineProperty(I,"__esModule",{value:!0});I.str=Ge;I.stri=Ke;var T=l();function Ge(e){let n=`'${e}'`;return Object.assign(t=>t.text.startsWith(e,t.index)?(0,T.success)({...t,index:t.index+e.length},e):(0,T.failure)(t,n,[n]),{parserType:"str",match:e})}var Je=new Intl.Collator("en",{sensitivity:"accent"});function Ke(e){let n=e.toLowerCase(),t=`'${n}'`;return Object.assign(r=>{let s=r.text.slice(r.index,r.index+e.length);return Je.compare(e,s)==0?(0,T.success)({...r,index:r.index+e.length},n):(0,T.failure)(r,t,[t])},{parserType:"stri",match:n})}});var ye=a(E=>{"use strict";Object.defineProperty(E,"__esModule",{value:!0});E.recoverBySkippingChars=Xe;E.recoverByAddingChars=Ye;var pe=l();function Xe(e,n){return t=>{let r=null;for(let s=0;s<=n;s++){let u=e({index:t.index+s,path:t.path,text:t.text});if((0,pe.isFailure)(u))r??=u;else return u}return r}}function Ye(e,n){return t=>{let r=null;for(let s=0;s<=n.length;s++){let u=n.slice(0,s),i=e({index:t.index,path:t.path,text:`${t.text.slice(0,t.index)}${u}${t.text.slice(t.index)}`});if((0,pe.isFailure)(i))r??=i;else return i}return r}}});var ge=a(o=>{"use strict";Object.defineProperty(o,"__esModule",{value:!0});o.eof=o.realP=o.real=o.intP=o.int=o.boolP=o.bool=o.wspaces=o.spacesPlus=o.spaces=void 0;var he=l(),C=m(),Ze=F(),O=G(),ke=v(),er=J(),rr=M();o.spaces=(0,O.regex)(/ */,"spaces");o.spacesPlus=(0,O.regex)(/ +/,"spaces");o.wspaces=(0,Ze.opt)((0,O.regex)(/(?:\s|\t|\n|\r)+/,"whitespace characters"));o.bool=(0,O.regex)(/true|false/,"boolean");o.boolP=(0,C.map)(o.bool,e=>e==="true");o.int=(0,O.regex)(/\d+/,"integer");o.intP=(0,C.map)(o.int,e=>parseInt(e,10));o.real=(0,rr.expect)((0,C.map)((0,ke.seq)(o.int,(0,er.str)("."),o.int),([e,,n])=>`${e}.${n}`),"real");o.realP=(0,C.map)(o.real,e=>parseFloat(e));var tr=e=>e.index===e.text.length?(0,he.success)(e,void 0):(0,he.failure)(e,"End Of File",["EOF"]);o.eof=tr});var qe=a(c=>{"use strict";var nr=c&&c.__createBinding||(Object.create?(function(e,n,t,r){r===void 0&&(r=t);var s=Object.getOwnPropertyDescriptor(n,t);(!s||("get"in s?!n.__esModule:s.writable||s.configurable))&&(s={enumerable:!0,get:function(){return n[t]}}),Object.defineProperty(e,r,s)}):(function(e,n,t,r){r===void 0&&(r=t),e[r]=n[t]})),d=c&&c.__exportStar||function(e,n){for(var t in e)t!=="default"&&!Object.prototype.hasOwnProperty.call(n,t)&&nr(n,e,t)};Object.defineProperty(c,"__esModule",{value:!0});c.stri=c.str=void 0;d(ue(),c);d(oe(),c);d(ce(),c);d(fe(),c);d(m(),c);d(F(),c);d(G(),c);d(v(),c);var _e=J();Object.defineProperty(c,"str",{enumerable:!0,get:function(){return _e.str}});Object.defineProperty(c,"stri",{enumerable:!0,get:function(){return _e.stri}});d(ye(),c);d(M(),c);d(ge(),c)});var xe=a(X=>{"use strict";Object.defineProperty(X,"__esModule",{value:!0});X.ParseText=sr;var K=l();function sr(e,n,t=""){let r=n({text:e,path:t,index:0});if((0,K.isFailure)(r))throw new K.ParseError(`Parse error, expected ${[...r.history].pop()} at char ${r.ctx.index}`,e,r.ctx.index,r.history);if(r.ctx.index!==e.length)throw new K.ParseError(`Parse error, expected end of text at char ${r.ctx.index}`,e,r.ctx.index,[]);return r.value}});var ir=a(y=>{var ur=y&&y.__createBinding||(Object.create?(function(e,n,t,r){r===void 0&&(r=t);var s=Object.getOwnPropertyDescriptor(n,t);(!s||("get"in s?!n.__esModule:s.writable||s.configurable))&&(s={enumerable:!0,get:function(){return n[t]}}),Object.defineProperty(e,r,s)}):(function(e,n,t,r){r===void 0&&(r=t),e[r]=n[t]})),Y=y&&y.__exportStar||function(e,n){for(var t in e)t!=="default"&&!Object.prototype.hasOwnProperty.call(n,t)&&ur(n,e,t)};Object.defineProperty(y,"__esModule",{value:!0});Y(l(),y);Y(qe(),y);Y(xe(),y)});export default ir();

package/dist/index.min.mjs

@@ -0,0 +1,4 @@
+"use strict";(()=>{function c(e){return!e.success}function l(e,n){return{success:!0,value:n,ctx:e}}function i(e,n,t){return{success:!1,expected:n,ctx:e,history:t}}function z(e){return n=>l(n,e)}function N(e){return n=>i(n,e,[e])}var d=class extends Error{constructor(n,t,r,s){super(n),this.index=r,this.history=s,[this.line,this.column,this.row]=this.getInputData(t,r)}getInputData(n,t){let r=n.split(`
+`),s=0;for(;t>0;){if(r[s].length>t)return[r[s],t+1,s+1];t-=r[s].length+1,s+=1}return[r[s],t+1,s+1]}getPrettyErrorMessage(){return`${this.message} (line ${this.row}, col ${this.column}):
+${this.line}
+${(this.column>0?"-".repeat(this.column-1):"")+"^"}`}};function T(e){let n=`'${e[e.length-1][0]}'`,t;return Object.assign(r=>{t??=P(e);let s=S(t,r.text,r.index);return s?l({...r,index:s.end},e[s.matchIndex][0]):i(r,n,["any",n])},{parserType:"anyString",matches:e})}function P(e){let n=new Map;return e.forEach((t,r)=>g(n,t,r)),n}function g(e,n,t,r=0){if(r>=n[0].length)e.matchIndex!=null?e.matchIndex=Math.min(e.matchIndex,t):e.matchIndex=t;else{let s=n[0][r],o=s.toLowerCase(),u=s.toUpperCase(),a=new Map;if(n[1]&&o!==u){let m=e.get(o)??a,x=e.get(u)??a;e.set(o,m),e.set(u,x),g(m,n,t,r+1),m!==x&&g(x,n,t,r+1)}else{let m=e.get(s)??a;e.set(s,m);let x=e.get(o);if(x===e.get(u)){let $=new Map(x.entries());$.matchIndex=x.matchIndex,e.set(u,$)}g(m,n,t,r+1)}}}function S(e,n,t){let r,s,o=e;for(let u=t;u<n.length;u++){let a=n[u];if(o.matchIndex!=null&&(s==null||o.matchIndex<=s)&&(r=u,s=o.matchIndex),o=o.get(a),!o)break}return o&&o.matchIndex!=null&&(s==null||o.matchIndex<=s)&&(r=n.length,s=o.matchIndex),r==null?void 0:{end:r,matchIndex:s}}var I=()=>M,M=!0,H=e=>{M=e};function L(e,n,t){return r=>{let s=e(r);return!c(s)&&!n(s.value)?i(s.ctx,t??"check",[`ref: ${t??"check"}`]):s}}function w(e,n){return t=>{let r=e(t);return c(r)?i(r.ctx,n,[n,...r.history]):r}}function A(e,n){return t=>{let r=e(t);return c(r)?i(r.ctx,n,[n]):r}}function U(e){return w(e,"surely")}function V(e){return n=>{let t=e(n);return t.success?{...t,value:{value:t.value,start:n.index,end:t.ctx.index}}:t}}function W(e){return n=>{let t=e(n);return t.success?l(n,void 0):i(n,t.expected,["lookaround",...t.history])}}var O=["str","stri","anyString"];function Y(...e){let n={};if(I()&&e.every(t=>"parserType"in t&&typeof t.parserType=="string"&&O.includes(t.parserType))){let r=e.flatMap(s=>{switch(s.parserType){case"anyString":return s.matches;case"str":return[[s.match,!1]];case"stri":return[[s.match,!0]]}});if(r.length>10)return T(r);n={parserType:"anyString",matches:r}}return Object.assign(t=>{let r=[];for(let o of e){let u=o(t);if(c(u)){if(u.history.includes("surely"))return i(u.ctx,u.expected,u.history.filter(a=>a!=="surely"));r.push(u)}else return u}let s=r.reduce((o,u)=>o.history.length>u.history.length?o:u);return i(s.ctx,s.expected,["any",...s.history])},n)}function f(...e){return n=>{let t=[];for(let r of e){let s=r(n);if(n=s.ctx,c(s))return i(s.ctx,s.expected,["seq",...s.history]);t.push(s.value)}return l(n,t)}}function ne(e,n,t){let r=f(e,n,t);return s=>{let o=r(s);if(c(o)){let u=[...o.history];return u.splice(0,1),i(o.ctx,o.expected,["between",...u])}return{...o,value:o.value[1]}}}function ie(e,n=null){return t=>{let r=[];for(;;){let s=e(t);if(c(s))return n===null||c(n(t))?i(s.ctx,s.expected,["exhaust",...s.history]):l(t,r);if(t=s.ctx,r.push(s.value),s.ctx.index===s.ctx.text.length)return l(s.ctx,r)}}}function p(e,n){return t=>{let r=e(t);if(c(r))return i(r.ctx,r.expected,["map",...r.history]);try{let s=n(r.value);return l(r.ctx,s)}catch{return i(r.ctx,"Error while mapping",["map"])}}}function y(e){return n=>{let t=e(n);return c(t)?l(n,null):t}}function b(e){return n=>{let t=[];for(;;){let r=e(n);if(c(r))return l(n,t);n=r.ctx,t.push(r.value)}}}function de(e,n){return p(y(k(e,n)),t=>t??[])}function k(e,n=void 0){let t=p(f(e,b(n?p(f(n,e),([,r])=>r):e)),([r,s])=>[r,...s]);return r=>{let s=t(r);if(c(s)){let o=[...s.history];return o.splice(0,2),i(s.ctx,s.expected,["oneOrMany",...o])}return s}}function ge(e,n,t){return p(p(f(p(e,r=>[null,r]),b(f(n,e))),([r,s])=>[r,...s]),r=>{let s=r[0][1];for(let o=1;o<r.length;o++)s=t(s,r[o][1],r[o][0]);return s})}function h(e,n){let t=new RegExp(e,typeof e=="string"?"y":e.flags+"y");return r=>{t.lastIndex=r.index;let s=t.exec(r.text);return s!==null&&s.index===r.index?l({...r,index:r.index+s[0].length},s[0]):i(r,n,[n])}}function F(e){let n=`'${e}'`;return Object.assign(t=>t.text.startsWith(e,t.index)?l({...t,index:t.index+e.length},e):i(t,n,[n]),{parserType:"str",match:e})}var E=new Intl.Collator("en",{sensitivity:"accent"});function q(e){let n=e.toLowerCase(),t=`'${n}'`;return Object.assign(r=>{let s=r.text.slice(r.index,r.index+e.length);return E.compare(e,s)==0?l({...r,index:r.index+e.length},n):i(r,t,[t])},{parserType:"stri",match:n})}function Ie(e,n){return t=>{let r=null;for(let s=0;s<=n;s++){let o=e({index:t.index+s,path:t.path,text:t.text});if(c(o))r??=o;else return o}return r}}function Me(e,n){return t=>{let r=null;for(let s=0;s<=n.length;s++){let o=n.slice(0,s),u=e({index:t.index,path:t.path,text:`${t.text.slice(0,t.index)}${o}${t.text.slice(t.index)}`});if(c(u))r??=u;else return u}return r}}var je=h(/ */,"spaces"),ze=h(/ +/,"spaces"),Ne=y(h(/(?:\s|\t|\n|\r)+/,"whitespace characters")),C=h(/true|false/,"boolean"),Qe=p(C,e=>e==="true"),v=h(/\d+/,"integer"),Re=p(v,e=>parseInt(e,10)),j=w(p(f(v,F("."),v),([e,,n])=>`${e}.${n}`),"real"),Be=p(j,e=>parseFloat(e)),De=e=>e.index===e.text.length?l(e,void 0):i(e,"End Of File",["EOF"]);function tr(e,n,t=""){let r=n({text:e,path:t,index:0});if(c(r))throw new d(`Parse error, expected ${[...r.history].pop()} at char ${r.ctx.index}`,e,r.ctx.index,r.history);if(r.ctx.index!==e.length)throw new d(`Parse error, expected end of text at char ${r.ctx.index}`,e,r.ctx.index,[]);return r.value}})();

package/dist-esm/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./parsers";
+export * from "./parser";

package/dist-esm/index.js

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./parsers";
+export * from "./parser";

package/dist-esm/parser.d.ts

@@ -0,0 +1,9 @@
+import { Parser } from './types';
+/** Parses the given string.
+ * @param text The string to parse.
+ * @param parser The parser to use.
+ * @param path The path of the parsed text. Can be used for error reporting.
+ * @returns The result of the parse.
+ * @throws {ParseError} if the parsing fails or the parser does not consume the full input.
+ */
+export declare function ParseText<T>(text: string, parser: Parser<T>, path?: string): T;

package/dist-esm/parser.js

@@ -0,0 +1,18 @@
+import { isFailure, ParseError } from './types';
+/** Parses the given string.
+ * @param text The string to parse.
+ * @param parser The parser to use.
+ * @param path The path of the parsed text. Can be used for error reporting.
+ * @returns The result of the parse.
+ * @throws {ParseError} if the parsing fails or the parser does not consume the full input.
+ */
+export function ParseText(text, parser, path = '') {
+    const res = parser({ text, path, index: 0 });
+    if (isFailure(res)) {
+        throw new ParseError(`Parse error, expected ${[...res.history].pop()} at char ${res.ctx.index}`, text, res.ctx.index, res.history);
+    }
+    if (res.ctx.index !== text.length) {
+        throw new ParseError(`Parse error, expected end of text at char ${res.ctx.index}`, text, res.ctx.index, []);
+    }
+    return res.value;
+}

package/dist-esm/parsers/any.d.ts

@@ -0,0 +1,16 @@
+import { Parser } from '../types';
+/** Parses the input using any passed parser, trying from left to right.
+ * @returns A parser returning the result of the first parser that succeeds, or the failure that has come the furthest.
+ */
+export declare function any<T, U, V, W, X, Z, I, J, K, L, M>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>, Parser<K>, Parser<L>, Parser<M>]): Parser<T | U | V | W | X | Z | I | J | K | L | M>;
+export declare function any<T, U, V, W, X, Z, I, J, K, L>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>, Parser<K>, Parser<L>]): Parser<T | U | V | W | X | Z | I | J | K | L>;
+export declare function any<T, U, V, W, X, Z, I, J, K>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>, Parser<K>]): Parser<T | U | V | W | X | Z | I | J | K>;
+export declare function any<T, U, V, W, X, Z, I, J>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>]): Parser<T | U | V | W | X | Z | I | J>;
+export declare function any<T, U, V, W, X, Z, I>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>]): Parser<T | U | V | W | X | Z | I>;
+export declare function any<T, U, V, W, X, Z>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>]): Parser<T | U | V | W | X | Z>;
+export declare function any<T, U, V, W, X>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>]): Parser<T | U | V | W | X>;
+export declare function any<T, U, V, W>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>]): Parser<T | U | V | W>;
+export declare function any<T, U, V>(...parsers: [Parser<T>, Parser<U>, Parser<V>]): Parser<T | U | V>;
+export declare function any<T, U>(...parsers: [Parser<T>, Parser<U>]): Parser<T | U>;
+export declare function any<T>(...parsers: [Parser<T>]): Parser<T>;
+export declare function any<T>(...parsers: Parser<T>[]): Parser<T>;

package/dist-esm/parsers/any.js

@@ -0,0 +1,44 @@
+import { failure, isFailure } from '../types';
+import { anyString } from './anyString';
+import { shouldPerformFusions } from './utilities';
+const optimizableTypes = ['str', 'stri', 'anyString'];
+export function any(...parsers) {
+    let marker = {};
+    if (shouldPerformFusions() && parsers.every(p => 'parserType' in p && typeof p.parserType === 'string' && optimizableTypes.includes(p.parserType))) {
+        const optimizableParsers = parsers;
+        const matches = optimizableParsers.flatMap(p => {
+            switch (p.parserType) {
+                case 'anyString':
+                    return p.matches;
+                case 'str':
+                    return [[p.match, false]];
+                case 'stri':
+                    return [[p.match, true]];
+            }
+        });
+        // Not fusing if not enough matches
+        // We do pass the matches forward though, because a parser above may want to fuse
+        if (matches.length > 10) {
+            return anyString(matches);
+        }
+        else {
+            marker = { parserType: 'anyString', matches };
+        }
+    }
+    return Object.assign((ctx) => {
+        const expected = [];
+        for (const parser of parsers) {
+            const res = parser(ctx);
+            if (isFailure(res)) {
+                if (res.history.includes('surely')) {
+                    return failure(res.ctx, res.expected, res.history.filter(h => h !== 'surely'));
+                }
+                expected.push(res);
+            }
+            else
+                return res;
+        }
+        const longest = expected.reduce((a, b) => a.history.length > b.history.length ? a : b);
+        return failure(longest.ctx, longest.expected, ['any', ...longest.history]);
+    }, marker);
+}

package/dist-esm/parsers/anyString.d.ts

@@ -0,0 +1,15 @@
+import { Parser } from "../types";
+import { StrIParser, StrParser } from "./str";
+type AnyStringParser<T> = Parser<T> & {
+    parserType: 'anyString';
+    /**
+     * if flag is true, match case-insensitive
+     */
+    matches: (readonly [string, boolean])[];
+};
+export type OptimizableStrParser<T> = AnyStringParser<T> | StrParser<T> | StrIParser<T>;
+/**
+ * Optimization for `any(str(), str(), ...)` which replaces the parser tree with one parser which tries all strings together
+ */
+export declare function anyString<T extends string>(matches: (readonly [string, boolean])[]): AnyStringParser<T>;
+export {};

package/dist-esm/parsers/anyString.js

@@ -0,0 +1,82 @@
+import { failure, success } from "../types";
+/**
+ * Optimization for `any(str(), str(), ...)` which replaces the parser tree with one parser which tries all strings together
+ */
+export function anyString(matches) {
+    const lastMatchInQuotes = `'${matches[matches.length - 1][0]}'`;
+    let tree;
+    return Object.assign((ctx) => {
+        tree ??= createSearchTree(matches);
+        const result = searchThroughTree(tree, ctx.text, ctx.index);
+        if (result) {
+            return success({ ...ctx, index: result.end }, matches[result.matchIndex][0]);
+        }
+        else {
+            return failure(ctx, lastMatchInQuotes, ['any', lastMatchInQuotes]);
+        }
+    }, { parserType: 'anyString', matches });
+}
+function createSearchTree(matches) {
+    const tree = new Map();
+    matches.forEach((match, index) => addMatchToTree(tree, match, index));
+    return tree;
+}
+function addMatchToTree(node, match, idIndex, charIndex = 0) {
+    if (charIndex >= match[0].length) {
+        if (node.matchIndex != undefined) {
+            node.matchIndex = Math.min(node.matchIndex, idIndex);
+        }
+        else {
+            node.matchIndex = idIndex;
+        }
+    }
+    else {
+        const char = match[0][charIndex];
+        const lowercase = char.toLowerCase();
+        const uppercase = char.toUpperCase();
+        const newNode = new Map();
+        if (match[1] && (lowercase !== uppercase)) {
+            const lower = node.get(lowercase) ?? newNode;
+            const upper = node.get(uppercase) ?? newNode;
+            node.set(lowercase, lower);
+            node.set(uppercase, upper);
+            addMatchToTree(lower, match, idIndex, charIndex + 1);
+            if (lower !== upper) {
+                addMatchToTree(upper, match, idIndex, charIndex + 1);
+            }
+        }
+        else {
+            const charNode = node.get(char) ?? newNode;
+            node.set(char, charNode);
+            const lower = node.get(lowercase);
+            if (lower === node.get(uppercase)) {
+                const copy = new Map(lower.entries());
+                copy.matchIndex = lower.matchIndex;
+                node.set(uppercase, copy);
+            }
+            addMatchToTree(charNode, match, idIndex, charIndex + 1);
+        }
+    }
+}
+function searchThroughTree(node, text, start) {
+    let lastSuccessIndex = undefined;
+    let lastSuccessMatchIndex = undefined;
+    let currentNode = node;
+    for (let index = start; index < text.length; index++) {
+        const char = text[index];
+        if (currentNode.matchIndex != undefined && (lastSuccessMatchIndex == undefined || currentNode.matchIndex <= lastSuccessMatchIndex)) {
+            lastSuccessIndex = index;
+            lastSuccessMatchIndex = currentNode.matchIndex;
+        }
+        currentNode = currentNode.get(char);
+        if (!currentNode)
+            break;
+    }
+    if (currentNode && currentNode.matchIndex != undefined && (lastSuccessMatchIndex == undefined || currentNode.matchIndex <= lastSuccessMatchIndex)) {
+        lastSuccessIndex = text.length;
+        lastSuccessMatchIndex = currentNode.matchIndex;
+    }
+    return lastSuccessIndex == undefined
+        ? undefined
+        : { end: lastSuccessIndex, matchIndex: lastSuccessMatchIndex };
+}

package/dist-esm/parsers/between.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from '../types';
+/** Parses a sequence of three parsers.
+ * @returns A parser returning only the middle parser's result.
+ */
+export declare function between<T, U, V>(left: Parser<U>, parser: Parser<T>, right: Parser<V>): Parser<T>;

package/dist-esm/parsers/between.js

@@ -0,0 +1,17 @@
+import { failure, isFailure } from '../types';
+import { seq } from './seq';
+/** Parses a sequence of three parsers.
+ * @returns A parser returning only the middle parser's result.
+ */
+export function between(left, parser, right) {
+    const sequence = seq(left, parser, right);
+    return (ctx) => {
+        const res = sequence(ctx);
+        if (isFailure(res)) {
+            const newHistory = [...res.history];
+            newHistory.splice(0, 1);
+            return failure(res.ctx, res.expected, ['between', ...newHistory]);
+        }
+        return { ...res, value: res.value[1] };
+    };
+}

package/dist-esm/parsers/exhaust.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from '../types';
+/** Parses using the passed in parser, until the input is exhausted or until the `until` condition is satisfied.
+ * @returns A parser returning an array of parsed results.
+ */
+export declare function exhaust<T, V>(parser: Parser<T>, until?: Parser<V> | null): Parser<T[]>;

package/dist-esm/parsers/exhaust.js

@@ -0,0 +1,22 @@
+import { failure, isFailure, success } from '../types';
+/** Parses using the passed in parser, until the input is exhausted or until the `until` condition is satisfied.
+ * @returns A parser returning an array of parsed results.
+ */
+export function exhaust(parser, until = null) {
+    return (ctx) => {
+        const results = [];
+        while (true) {
+            const res = parser(ctx);
+            if (isFailure(res)) {
+                if (until === null || isFailure(until(ctx))) {
+                    return failure(res.ctx, res.expected, ['exhaust', ...res.history]);
+                }
+                return success(ctx, results);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+            if (res.ctx.index === res.ctx.text.length)
+                return success(res.ctx, results);
+        }
+    };
+}

package/dist-esm/parsers/index.d.ts

@@ -0,0 +1,12 @@
+export * from './any';
+export * from './between';
+export * from './exhaust';
+export * from './many';
+export * from './map';
+export * from './opt';
+export * from './regex';
+export * from './seq';
+export { str, stri } from './str';
+export * from './recovery';
+export * from './utilities';
+export * from './values';

package/dist-esm/parsers/index.js

@@ -0,0 +1,12 @@
+export * from './any';
+export * from './between';
+export * from './exhaust';
+export * from './many';
+export * from './map';
+export * from './opt';
+export * from './regex';
+export * from './seq';
+export { str, stri } from './str';
+export * from './recovery';
+export * from './utilities';
+export * from './values';

package/dist-esm/parsers/many.d.ts

@@ -0,0 +1,17 @@
+import { Parser } from '../types';
+/** Parses zero or more occurences of the given parser.
+ * @returns A parser returning an array of many parses.
+ */
+export declare function many<T>(parser: Parser<T>): Parser<T[]>;
+/** Parses zero or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning an array of many parses, omitting the separator.
+ */
+export declare function zeroOrMany<T, V>(item: Parser<T>, separator: Parser<V>): Parser<T[]>;
+/** Parses one or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning an array of many parses, omitting the separator.
+ */
+export declare function oneOrMany<T, V>(item: Parser<T>, separator?: Parser<V> | undefined): Parser<T[]>;
+/** Parses one or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning the result of many parses, reduced using the `reducer` function passed in.
+ */
+export declare function oneOrManyRed<T, V, U = T>(item: Parser<T>, separator: Parser<V>, reducer: (left: U | T, right: T, sep: V) => U): Parser<U | T>;

package/dist-esm/parsers/many.js

@@ -0,0 +1,55 @@
+import { failure, isFailure, success } from '../types';
+import { map } from './map';
+import { opt } from './opt';
+import { seq } from './seq';
+/** Parses zero or more occurences of the given parser.
+ * @returns A parser returning an array of many parses.
+ */
+export function many(parser) {
+    return (ctx) => {
+        const results = [];
+        while (true) {
+            const res = parser(ctx);
+            if (isFailure(res)) {
+                return success(ctx, results);
+            }
+            ctx = res.ctx;
+            results.push(res.value);
+        }
+    };
+}
+/** Parses zero or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning an array of many parses, omitting the separator.
+ */
+export function zeroOrMany(item, separator) {
+    return map(opt(oneOrMany(item, separator)), t => t ?? []);
+}
+/** Parses one or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning an array of many parses, omitting the separator.
+ */
+export function oneOrMany(item, separator = undefined) {
+    const sequencer = map(seq(item, many(separator
+        ? map(seq(separator, item), ([, t]) => t)
+        : item)), ([t, ts]) => ([t, ...ts]));
+    return (ctx) => {
+        const res = sequencer(ctx);
+        if (isFailure(res)) {
+            const newHistory = [...res.history];
+            newHistory.splice(0, 2);
+            return failure(res.ctx, res.expected, ['oneOrMany', ...newHistory]);
+        }
+        return res;
+    };
+}
+/** Parses one or more occurences of the given parser, separated with the separator parser.
+ * @returns A parser returning the result of many parses, reduced using the `reducer` function passed in.
+ */
+export function oneOrManyRed(item, separator, reducer) {
+    return map(map(seq(map(item, (x) => [null, x]), many(seq(separator, item))), ([t, ts]) => ([t, ...ts])), ts => {
+        let result = ts[0][1];
+        for (let i = 1; i < ts.length; i++) {
+            result = reducer(result, ts[i][1], ts[i][0]);
+        }
+        return result;
+    });
+}

package/dist-esm/parsers/map.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from '../types';
+/** Parses the input using the given parser, then maps the output.
+ * @returns A parser that parses the same input, but has output mapped using the mapping function.
+ */
+export declare function map<A, B>(parser: Parser<A>, mapper: (val: A) => B): Parser<B>;

package/dist-esm/parsers/map.js

@@ -0,0 +1,18 @@
+import { failure, isFailure, success } from '../types';
+/** Parses the input using the given parser, then maps the output.
+ * @returns A parser that parses the same input, but has output mapped using the mapping function.
+ */
+export function map(parser, mapper) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (isFailure(res))
+            return failure(res.ctx, res.expected, ['map', ...res.history]);
+        try {
+            const newValue = mapper(res.value);
+            return success(res.ctx, newValue);
+        }
+        catch {
+            return failure(res.ctx, 'Error while mapping', ['map']);
+        }
+    };
+}

package/dist-esm/parsers/opt.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from '../types';
+/** Makes the parser optional.
+ * @returns A parser that succeeds with `null` result if the parsing didn't succeed.
+ */
+export declare function opt<T>(parser: Parser<T>): Parser<T | null>;

package/dist-esm/parsers/opt.js

@@ -0,0 +1,13 @@
+import { isFailure, success } from '../types';
+/** Makes the parser optional.
+ * @returns A parser that succeeds with `null` result if the parsing didn't succeed.
+ */
+export function opt(parser) {
+    return (ctx) => {
+        const parseResult = parser(ctx);
+        if (isFailure(parseResult)) {
+            return success(ctx, null);
+        }
+        return parseResult;
+    };
+}

package/dist-esm/parsers/recovery.d.ts

@@ -0,0 +1,14 @@
+import { Parser } from "../types";
+/**
+ * Tries to automatically recover a parsing failure by removing characters from the front.
+ *
+ * If the inner parser fails, the recovery parser will restart parsing skipping a character, up to {@link chars} skips
+ */
+export declare function recoverBySkippingChars<T>(parser: Parser<T>, chars: number): Parser<T>;
+/**
+ * Tries to automatically recover a parsing failure by adding characters to the front.
+ *
+ * If the inner parser fails, the recovery parser will restart parsing adding a character, up to {@link chars}
+ * @todo Inserting characters in the middle of a context string is inefficient - maybe there's a better way?
+ */
+export declare function recoverByAddingChars<T>(parser: Parser<T>, chars: string): Parser<T>;

package/dist-esm/parsers/recovery.js

@@ -0,0 +1,49 @@
+import { isFailure } from "../types";
+/**
+ * Tries to automatically recover a parsing failure by removing characters from the front.
+ *
+ * If the inner parser fails, the recovery parser will restart parsing skipping a character, up to {@link chars} skips
+ */
+export function recoverBySkippingChars(parser, chars) {
+    return (ctx) => {
+        let firstFailure = null;
+        for (let i = 0; i <= chars; i++) {
+            const result = parser({
+                index: ctx.index + i,
+                path: ctx.path,
+                text: ctx.text,
+            });
+            if (isFailure(result)) {
+                firstFailure ??= result;
+            }
+            else
+                return result;
+        }
+        return firstFailure;
+    };
+}
+/**
+ * Tries to automatically recover a parsing failure by adding characters to the front.
+ *
+ * If the inner parser fails, the recovery parser will restart parsing adding a character, up to {@link chars}
+ * @todo Inserting characters in the middle of a context string is inefficient - maybe there's a better way?
+ */
+export function recoverByAddingChars(parser, chars) {
+    return (ctx) => {
+        let firstFailure = null;
+        for (let i = 0; i <= chars.length; i++) {
+            const addedChars = chars.slice(0, i);
+            const result = parser({
+                index: ctx.index,
+                path: ctx.path,
+                text: `${ctx.text.slice(0, ctx.index)}${addedChars}${ctx.text.slice(ctx.index)}`,
+            });
+            if (isFailure(result)) {
+                firstFailure ??= result;
+            }
+            else
+                return result;
+        }
+        return firstFailure;
+    };
+}

package/dist-esm/parsers/regex.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from '../types';
+/** Parses a regex and returns the matched result of the parse.
+ * @returns A parser parsing a given regex and returning a match.
+ */
+export declare function regex(match: RegExp | string, expected: string): Parser<string>;

package/dist-esm/parsers/regex.js

@@ -0,0 +1,17 @@
+import { failure, success } from '../types';
+/** Parses a regex and returns the matched result of the parse.
+ * @returns A parser parsing a given regex and returning a match.
+ */
+export function regex(match, expected) {
+    const regexp = new RegExp(match, typeof match === 'string' ? 'y' : match.flags + 'y');
+    return (ctx) => {
+        regexp.lastIndex = ctx.index;
+        const regexMatch = regexp.exec(ctx.text);
+        if (regexMatch !== null && regexMatch.index === ctx.index) {
+            return success({ ...ctx, index: ctx.index + regexMatch[0].length }, regexMatch[0]);
+        }
+        else {
+            return failure(ctx, expected, [expected]);
+        }
+    };
+}

package/dist-esm/parsers/seq.d.ts

@@ -0,0 +1,16 @@
+import { Parser } from '../types';
+/** Parses a sequence of parsers going from left to right, returning the results of the parsers.
+ * @returns A parser parsing the sequence of parsers.
+ */
+export declare function seq<T, U, V, W, X, Z, I, J, K, L, M>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>, Parser<K>, Parser<L>, Parser<M>]): Parser<[T, U, V, W, X, Z, I, J, K, L, M]>;
+export declare function seq<T, U, V, W, X, Z, I, J, K, L>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>, Parser<K>, Parser<L>]): Parser<[T, U, V, W, X, Z, I, J, K, L]>;
+export declare function seq<T, U, V, W, X, Z, I, J, K>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>, Parser<K>]): Parser<[T, U, V, W, X, Z, I, J, K]>;
+export declare function seq<T, U, V, W, X, Z, I, J>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>, Parser<J>]): Parser<[T, U, V, W, X, Z, I, J]>;
+export declare function seq<T, U, V, W, X, Z, I>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>, Parser<I>]): Parser<[T, U, V, W, X, Z, I]>;
+export declare function seq<T, U, V, W, X, Z>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>, Parser<Z>]): Parser<[T, U, V, W, X, Z]>;
+export declare function seq<T, U, V, W, X>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>, Parser<X>]): Parser<[T, U, V, W, X]>;
+export declare function seq<T, U, V, W>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>]): Parser<[T, U, V, W]>;
+export declare function seq<T, U, V>(...parsers: [Parser<T>, Parser<U>, Parser<V>]): Parser<[T, U, V]>;
+export declare function seq<T, U>(...parsers: [Parser<T>, Parser<U>]): Parser<[T, U]>;
+export declare function seq<T>(...parsers: [Parser<T>]): Parser<[T]>;
+export declare function seq<T>(...parsers: Parser<T>[]): Parser<T[]>;

package/dist-esm/parsers/seq.js

@@ -0,0 +1,14 @@
+import { failure, isFailure, success } from '../types';
+export function seq(...parsers) {
+    return (ctx) => {
+        const values = [];
+        for (const parser of parsers) {
+            const res = parser(ctx);
+            ctx = res.ctx;
+            if (isFailure(res))
+                return failure(res.ctx, res.expected, ['seq', ...res.history]);
+            values.push(res.value);
+        }
+        return success(ctx, values);
+    };
+}

package/dist-esm/parsers/str.d.ts

@@ -0,0 +1,17 @@
+import { Parser } from '../types';
+export type StrParser<T> = Parser<T> & {
+    parserType: 'str';
+    match: T;
+};
+/** Parses a string and returns it as a result of the parse.
+ * @returns A parser parsing a given string, case-sensitive.
+ */
+export declare function str<T extends string>(match: T): StrParser<T>;
+export type StrIParser<T> = Parser<T> & {
+    parserType: 'stri';
+    match: T;
+};
+/** Parses a string case-insensitively and returns it as a result of the parse.
+ * @returns A parser parsing a given string, case-insensitive.
+ */
+export declare function stri<T extends string>(match: T): StrIParser<Lowercase<T>>;

package/dist-esm/parsers/str.js

@@ -0,0 +1,32 @@
+import { failure, success } from '../types';
+/** Parses a string and returns it as a result of the parse.
+ * @returns A parser parsing a given string, case-sensitive.
+ */
+export function str(match) {
+    const inQuotes = `'${match}'`;
+    return Object.assign((ctx) => {
+        if (ctx.text.startsWith(match, ctx.index)) {
+            return success({ ...ctx, index: ctx.index + match.length }, match);
+        }
+        else {
+            return failure(ctx, inQuotes, [inQuotes]);
+        }
+    }, { parserType: 'str', match });
+}
+const collator = new Intl.Collator('en', { sensitivity: 'accent' });
+/** Parses a string case-insensitively and returns it as a result of the parse.
+ * @returns A parser parsing a given string, case-insensitive.
+ */
+export function stri(match) {
+    const lowercase = match.toLowerCase();
+    const inQuotes = `'${lowercase}'`;
+    return Object.assign((ctx) => {
+        const textSlice = ctx.text.slice(ctx.index, ctx.index + match.length);
+        if (collator.compare(match, textSlice) == 0) {
+            return success({ ...ctx, index: ctx.index + match.length }, lowercase);
+        }
+        else {
+            return failure(ctx, inQuotes, [inQuotes]);
+        }
+    }, { parserType: 'stri', match: lowercase });
+}

package/dist-esm/parsers/utilities.d.ts

@@ -0,0 +1,33 @@
+import { Parser, Token } from '../types';
+export declare const shouldPerformFusions: () => boolean;
+/**
+ * Disables all parser combinator fusions.
+ *
+ * Should probably be used only for testing performance.
+ */
+export declare const toggleFusions: (value: boolean) => void;
+/** Allows to make a condition on the result of the parsing function.
+ * @returns A parser returning the same but also performing a given check on the result.
+ */
+export declare function ref<T>(parser: Parser<T>, check: ((p: T) => boolean), expected?: string): Parser<T>;
+/** Changes the expected value for when the parser fails.
+ * @returns A parser returning the same but with a different expected value.
+ */
+export declare function expect<T>(parser: Parser<T>, expected: string): Parser<T>;
+/** Changes the expected value for when the parser fails. Erases the previous history.
+ * @returns A parser returning the same but with a different expected value.
+ */
+export declare function expectErase<T>(parser: Parser<T>, expected: string): Parser<T>;
+/**
+ * Marks a parser as a branch that has to be executed to the end by the {@link any} parser
+ */
+export declare function surely<T>(parser: Parser<T>): Parser<T>;
+/**
+ * Wraps the value returned by the parser with the token information (the start and end index in the text)
+ * @returns A parser returning the value wrapped in token information.
+ */
+export declare function token<T>(parser: Parser<T>): Parser<Token<T>>;
+/**
+ * Checks whether the parser parses successfully, but doesn't move the cursor forward
+ */
+export declare function lookaround<T>(parser: Parser<T>): Parser<void>;

package/dist-esm/parsers/utilities.js

@@ -0,0 +1,85 @@
+import { failure, isFailure, success } from '../types';
+export const shouldPerformFusions = () => performFusions;
+let performFusions = true;
+/**
+ * Disables all parser combinator fusions.
+ *
+ * Should probably be used only for testing performance.
+ */
+export const toggleFusions = (value) => {
+    performFusions = value;
+};
+/** Allows to make a condition on the result of the parsing function.
+ * @returns A parser returning the same but also performing a given check on the result.
+ */
+export function ref(parser, check, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (!isFailure(res) && !check(res.value)) {
+            return failure(res.ctx, expected ?? 'check', [`ref: ${expected ?? 'check'}`]);
+        }
+        return res;
+    };
+}
+/** Changes the expected value for when the parser fails.
+ * @returns A parser returning the same but with a different expected value.
+ */
+export function expect(parser, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (isFailure(res)) {
+            return failure(res.ctx, expected, [expected, ...res.history]);
+        }
+        return res;
+    };
+}
+/** Changes the expected value for when the parser fails. Erases the previous history.
+ * @returns A parser returning the same but with a different expected value.
+ */
+export function expectErase(parser, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (isFailure(res)) {
+            return failure(res.ctx, expected, [expected]);
+        }
+        return res;
+    };
+}
+/**
+ * Marks a parser as a branch that has to be executed to the end by the {@link any} parser
+ */
+export function surely(parser) {
+    return expect(parser, 'surely');
+}
+/**
+ * Wraps the value returned by the parser with the token information (the start and end index in the text)
+ * @returns A parser returning the value wrapped in token information.
+ */
+export function token(parser) {
+    return (ctx) => {
+        const result = parser(ctx);
+        if (result.success) {
+            return {
+                ...result,
+                value: {
+                    value: result.value,
+                    start: ctx.index,
+                    end: result.ctx.index
+                }
+            };
+        }
+        return result;
+    };
+}
+/**
+ * Checks whether the parser parses successfully, but doesn't move the cursor forward
+ */
+export function lookaround(parser) {
+    return (ctx) => {
+        const result = parser(ctx);
+        if (result.success) {
+            return success(ctx, void 0);
+        }
+        return failure(ctx, result.expected, ['lookaround', ...result.history]);
+    };
+}

package/dist-esm/parsers/values.d.ts

@@ -0,0 +1,31 @@
+import { Parser } from '../types';
+/** Parses 0 or more spaces
+ */
+export declare const spaces: Parser<string>;
+/** Parses 1 or more spaces
+ */
+export declare const spacesPlus: Parser<string>;
+/** Parses 0 or more whitespace characters
+ */
+export declare const wspaces: Parser<string | null>;
+/** Parses a boolean (true or false) and returns a string
+ */
+export declare const bool: Parser<'true' | 'false'>;
+/** Parses a boolean (true or false) and returns a boolean
+ */
+export declare const boolP: Parser<boolean>;
+/** Parses an integer and returns a string
+ */
+export declare const int: Parser<string>;
+/** Parses an integer and returns a number
+ */
+export declare const intP: Parser<number>;
+/** Parses a standard real number (X.X) and returns a string
+ */
+export declare const real: Parser<`${number}.${number}`>;
+/** Parses a standard real number (X.X) and returns a number
+ */
+export declare const realP: Parser<number>;
+/** Parses an end of text/file. Fails if the parser is not at the end.
+ */
+export declare const eof: Parser<void>;

package/dist-esm/parsers/values.js

@@ -0,0 +1,44 @@
+import { failure, success } from '../types';
+import { map } from './map';
+import { opt } from './opt';
+import { regex } from './regex';
+import { seq } from './seq';
+import { str } from './str';
+import { expect } from './utilities';
+/** Parses 0 or more spaces
+ */
+export const spaces = regex(/ */, 'spaces');
+/** Parses 1 or more spaces
+ */
+export const spacesPlus = regex(/ +/, 'spaces');
+/** Parses 0 or more whitespace characters
+ */
+export const wspaces = opt(regex(/(?:\s|\t|\n|\r)+/, 'whitespace characters'));
+/** Parses a boolean (true or false) and returns a string
+ */
+export const bool = regex(/true|false/, 'boolean');
+/** Parses a boolean (true or false) and returns a boolean
+ */
+export const boolP = map(bool, val => val === 'true');
+/** Parses an integer and returns a string
+ */
+export const int = regex(/\d+/, 'integer');
+/** Parses an integer and returns a number
+ */
+export const intP = map(int, seq => parseInt(seq, 10));
+/** Parses a standard real number (X.X) and returns a string
+ */
+export const real = expect(map(seq(int, str('.'), int), ([intPart, , decimalPart]) => `${intPart}.${decimalPart}`), 'real');
+/** Parses a standard real number (X.X) and returns a number
+ */
+export const realP = map(real, (seq) => parseFloat(seq));
+/** Parses an end of text/file. Fails if the parser is not at the end.
+ */
+export const eof = (ctx) => {
+    if (ctx.index === ctx.text.length) {
+        return success(ctx, void 0);
+    }
+    else {
+        return failure(ctx, "End Of File", ["EOF"]);
+    }
+};

package/dist-esm/types.d.ts

@@ -0,0 +1,40 @@
+export type Parser<T> = (ctx: Context) => Result<T>;
+export type Context = Readonly<{
+    text: string;
+    path: string;
+    index: number;
+}>;
+export type Result<T> = Success<T> | Failure;
+export type Success<T> = Readonly<{
+    success: true;
+    value: T;
+    ctx: Context;
+}>;
+export type Failure = Readonly<{
+    success: false;
+    expected: string;
+    ctx: Context;
+    history: string[];
+}>;
+export type TokenRange = {
+    start: number;
+    end: number;
+};
+export type Token<T> = TokenRange & {
+    value: T;
+};
+export declare function isFailure(input: unknown): input is Failure;
+export declare function success<T>(ctx: Context, value: T): Success<T>;
+export declare function failure(ctx: Context, expected: string, history: string[]): Failure;
+export declare function result<T>(value: T): Parser<T>;
+export declare function fail<T>(reason: string): Parser<T>;
+export declare class ParseError extends Error {
+    readonly index: number;
+    readonly history: string[];
+    readonly line: string;
+    readonly column: number;
+    readonly row: number;
+    constructor(message: string, input: string, index: number, history: string[]);
+    private getInputData;
+    getPrettyErrorMessage(): string;
+}

package/dist-esm/types.js

@@ -0,0 +1,38 @@
+export function isFailure(input) {
+    return !input.success;
+}
+export function success(ctx, value) {
+    return { success: true, value, ctx };
+}
+export function failure(ctx, expected, history) {
+    return { success: false, expected, ctx, history };
+}
+export function result(value) {
+    return (ctx) => success(ctx, value);
+}
+export function fail(reason) {
+    return (ctx) => failure(ctx, reason, [reason]);
+}
+export class ParseError extends Error {
+    constructor(message, input, index, history) {
+        super(message);
+        this.index = index;
+        this.history = history;
+        [this.line, this.column, this.row] = this.getInputData(input, index);
+    }
+    getInputData(input, index) {
+        const lines = input.split('\n');
+        let row = 0;
+        while (index > 0) {
+            if (lines[row].length > index) {
+                return [lines[row], index + 1, row + 1];
+            }
+            index -= lines[row].length + 1;
+            row += 1;
+        }
+        return [lines[row], index + 1, row + 1];
+    }
+    getPrettyErrorMessage() {
+        return `${this.message} (line ${this.row}, col ${this.column}):\n${this.line}\n${(this.column > 0 ? '-'.repeat(this.column - 1) : '') + '^'}`;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parser-combinators",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "license": "ISC",
   "maintainers": [
     "Micha_i"
@@ -15,9 +15,11 @@
   "homepage": "https://github.com/michalusio/Parser#readme",
   "description": "A library of parser combinators, with which you can create your own parsers. The library will be continuously improved in time.",
   "scripts": {
-    "build": "tsc",
     "start": "tsc && node .",
-    "lint": "eslint . --ext .ts",
+    "lint": "eslint src --ext .ts",
+    "build": "tsc",
+    "build-esm": "tsc --project tsconfig.esm.json",
+    "bundle": "npm run lint && npm run build && npm run build-esm",
     "test:mutate": "stryker run",
     "test:unit": "mocha",
     "test": "nyc -e '.ts' --r html -r lcov -r text npm run test:unit"
@@ -25,6 +27,7 @@
   "author": "Micha_i <isalski.michal@gmail.com> (https://github.com/michalusio)",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "type": "commonjs",
   "engines": {
     "node": ">=18"
   },
@@ -33,14 +36,15 @@
     "@stryker-mutator/mocha-runner": "^9.4.0",
     "@stryker-mutator/typescript-checker": "^9.4.0",
     "@types/mocha": "10.0.10",
-    "@types/node": "25.0.6",
+    "@types/node": "25.0.9",
     "cross-env": "10.1.0",
+    "esbuild": "0.27.2",
     "eslint": "9.39.2",
     "mocha": "11.7.5",
     "nyc": "17.1.0",
     "ts-node": "10.9.2",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.52.0"
+    "typescript-eslint": "8.53.0"
   },
   "keywords": [
     "parser",