compiles but not working

src/mol-script/transpilers/helper.ts

@@ -121,7 +121,7 @@ export function combineOperators(opList: any[], rule: P.MonadicParser<any>) {
 export function infixOp(re: RegExp, group: number = 0) {
     return P.MonadicParser.whitespace.then(P.MonadicParser.regexp(re, group).skip(P.MonadicParser.whitespace));
     // return P.optWhitespace.then(P.MonadicParser.regexp(re, group).lookahead(P.whitespace))
-    // return P.MonadicParser.regexp(re, group).skip(P.whitespace)
+    // return P.MonadicParser.regexp(re, group).skip(P.whitespace
 }
 
 export function prefixOp(re: RegExp, group: number = 0) {
@@ -216,7 +216,7 @@ export function getPropertyRules(properties: PropertyDict) {
     Object.keys(properties).sort(strLenSortFn).forEach(name => {
         const ps = properties[name];
         const errorFn = makeError(`property '${name}' not supported`);
-        const rule = P.MonadicParser.regexp(ps.regex).map(x => {
+        const rule = P.MonadicParser.regexp(ps.regex).map((x:any) => {
             if (ps.isUnsupported) errorFn();
             return testExpr(ps.property, ps.map(x));
         });
@@ -235,7 +235,7 @@ export function getNamedPropertyRules(properties: PropertyDict) {
     Object.keys(properties).sort(strLenSortFn).forEach(name => {
         const ps = properties[name];
         const errorFn = makeError(`property '${name}' not supported`);
-        const rule = P.MonadicParser.regexp(ps.regex).map(x => {
+        const rule = P.MonadicParser.regexp(ps.regex).map((x:any) => {
             if (ps.isUnsupported) errorFn();
             return testExpr(ps.property, ps.map(x));
         });
@@ -247,7 +247,7 @@ export function getNamedPropertyRules(properties: PropertyDict) {
                 nameRule.then(P.MonadicParser.seq(
                     P.MonadicParser.regexp(/>=|<=|=|!=|>|</).trim(P.MonadicParser.optWhitespace),
                     P.MonadicParser.regexp(ps.regex).map(ps.map)
-                )).map(x => {
+                )).map((x:any) => {
                     if (ps.isUnsupported) errorFn();
                     return testExpr(ps.property, { op: x[0], val: x[1] });
                 }).map(groupMap)
@@ -298,7 +298,7 @@ export function getPropertyNameRules(properties: PropertyDict, lookahead: RegExp
     Object.keys(properties).sort(strLenSortFn).forEach(name => {
         const ps = properties[name];
         const errorFn = makeError(`property '${name}' not supported`);
-        const rule = P.MonadicParser.regexp(getNamesRegex(name, ps.abbr)).lookahead(lookahead).map(() => {
+        const rule = (P.MonadicParser as any).regexp(getNamesRegex(name, ps.abbr)).lookahead(lookahead).map(() => {
             if (ps.isUnsupported) errorFn();
             return ps.property;
         });

src/mol-script/transpilers/pymol/operators.ts

@@ -92,7 +92,7 @@ export const operators: OperatorList = [
         type: h.postfix,
         rule: h
             .postfixOp(/GAP\s+([-+]?[0-9]*\.?[0-9]+)/i, 1)
-            .map((x) => parseFloat(x)),
+            .map((x:any) => parseFloat(x)),
         map: (distance: number, target: Expression) => {
             return B.struct.filter.within({
                 '0': B.struct.generator.atomGroups(),
@@ -112,7 +112,7 @@ export const operators: OperatorList = [
         type: h.postfix,
         rule: h
             .postfixOp(/(AROUND|a\.)\s+([-+]?[0-9]*\.?[0-9]+)/i, 2)
-            .map((x) => parseFloat(x)),
+            .map((x:any) => parseFloat(x)),
         map: (radius: number, target: Expression) => {
             return B.struct.modifier.exceptBy({
                 '0': B.struct.filter.within({
@@ -133,7 +133,7 @@ export const operators: OperatorList = [
         type: h.postfix,
         rule: h
             .postfixOp(/(EXPAND|x\.)\s+([-+]?[0-9]*\.?[0-9]+)/i, 2)
-            .map((x) => parseFloat(x)),
+            .map((x:any) => parseFloat(x)),
         map: (radius: number, selection: Expression) => {
             return B.struct.modifier.includeSurroundings({ 0: selection, radius });
         },
@@ -353,7 +353,7 @@ export const operators: OperatorList = [
         name: 'extend',
         abbr: ['xt.'],
         type: h.postfix,
-        rule: h.postfixOp(/(EXTEND|xt\.)\s+([0-9]+)/i, 2).map((x) => parseInt(x)),
+        rule: h.postfixOp(/(EXTEND|xt\.)\s+([0-9]+)/i, 2).map((x:any) => parseInt(x)),
         map: (count: number, selection: Expression) => {
             return h.asAtoms(
                 B.struct.modifier.includeConnected({

src/mol-script/transpilers/vmd/operators.ts

@@ -30,7 +30,7 @@ export const operators: OperatorList = [
         '@examples': ['within 5 of name FE'],
         name: 'within',
         type: h.prefix,
-        rule: h.prefixOp(/WITHIN\s+([-+]?[0-9]*\.?[0-9]+)\s+OF/i, 1).map(x => parseFloat(x)),
+        rule: h.prefixOp(/WITHIN\s+([-+]?[0-9]*\.?[0-9]+)\s+OF/i, 1).map((x:any) => parseFloat(x)),
         map: (radius: number, selection: Expression) => {
             return B.struct.modifier.includeSurroundings({ 0: selection, radius });
         }
@@ -40,7 +40,7 @@ export const operators: OperatorList = [
         '@examples': ['exwithin 10 of resname HEM'],
         name: 'exwithin',
         type: h.prefix,
-        rule: h.prefixOp(/EXWITHIN\s+([-+]?[0-9]*\.?[0-9]+)\s+OF/i, 1).map(x => parseFloat(x)),
+        rule: h.prefixOp(/EXWITHIN\s+([-+]?[0-9]*\.?[0-9]+)\s+OF/i, 1).map((x:any) => parseFloat(x)),
         map: (radius: number, target: Expression) => {
             return B.struct.modifier.exceptBy({
                 '0': B.struct.filter.within({
@@ -55,7 +55,7 @@ export const operators: OperatorList = [
         '@examples': ['same resid as name FE'],
         name: 'same',
         type: h.prefix,
-        rule: h.prefixOp(new RegExp(`SAME\\s+(${propNames})\\s+AS`, 'i'), 1).map(x => properties[x].property),
+        rule: h.prefixOp(new RegExp(`SAME\\s+(${propNames})\\s+AS`, 'i'), 1).map((x:any) => properties[x].property),
         map: (property: Expression, source: Expression) => {
             return B.struct.filter.withSameAtomProperties({
                 '0': B.struct.generator.atomGroups(),

src/mol-script/transpilers/vmd/parser.ts

@@ -198,7 +198,7 @@ const lang = P.MonadicParser.createLanguage({
         return P.MonadicParser.alt(
             P.MonadicParser.regexp(new RegExp(`(?!(${w}))[A-Z0-9_]+`, 'i')),
             P.MonadicParser.regexp(/'((?:[^"\\]|\\.)*)'/, 1),
-            P.MonadicParser.regexp(/"((?:[^"\\]|\\.)*)"/, 1).map(x => B.core.type.regex([`^${x}$`, 'i']))
+            P.MonadicParser.regexp(/"((?:[^"\\]|\\.)*)"/, 1).map((x:any) => B.core.type.regex([`^${x}$`, 'i']))
         ).desc('string');
     },
 

src/mol-util/monadic-parser.ts

@@ -267,6 +267,28 @@ export namespace MonadicParser {
         return language;
     }
 
+   
+    //    function seq() {
+    //var parsers = [].slice.call(arguments);
+//	var numParsers = parsers.length;
+//	for (var j = 0; j < numParsers; j += 1) {
+//	    assertParser(parsers[j]);
+//	}
+//	return Parsimmon(function(input, i) {
+//	    var result;
+//	    var accum = new Array(numParsers);
+//	    for (var j = 0; j < numParsers; j += 1) {
+    //		result = mergeReplies(parsers[j]._(input, i), result);
+    //if (!result.status) {
+//		    return result;
+//		}
+//		accum[j] = result.value;
+//		i = result.index;
+//	    }
+//	    return mergeReplies(makeSuccess(i, accum), result);
+//	});
+  //  }
+
     export function seq<A>(a: MonadicParser<A>): MonadicParser<[A]>
     export function seq<A, B>(a: MonadicParser<A>, b: MonadicParser<B>): MonadicParser<[A, B]>
     export function seq<A, B, C>(a: MonadicParser<A>, b: MonadicParser<B>, c: MonadicParser<C>): MonadicParser<[A, B, C]>
@@ -346,10 +368,13 @@ export namespace MonadicParser {
         return RegExp('^(?:' + re.source + ')', flags(re));
     }
 
+   
+
+    //return new MonadicParser<any[]>((input, index) => {
     export function regexp(re: RegExp, group = 0) {
         const anchored = anchoredRegexp(re);
         const expected = '' + re;
-        return new MonadicParser(function (input, i) {
+        return new MonadicParser<any>( function (input:any, i:any){
             const match = anchored.exec(input.slice(i));
             if (match) {
                 if (0 <= group && group <= match.length) {
@@ -482,10 +507,16 @@ export namespace MonadicParser {
     export function of(A:any){
 	return succeed(A);
     }
+
+    export function regex(A:any){
+	return regexp(A);
+    }
+    
     MonadicParser.createLanguage = createLanguage;
     MonadicParser.seq = seq;
     MonadicParser.seqMap = seqMap;
     MonadicParser.of = succeed;
+    MonadicParser.regex = regexp;
     MonadicParser.regexp = regexp;
 //    MonadicParser.regexp.lookahead = lookahead;
     //MonadicParser.RegExp = regexp;