How to use the parsimmon.string function in parsimmon

seq(string(';'), takeWhile(c => c !== '\n'), string('\n')),
    string('\n')
  )
);

type Macro = { kind: 'macro', name: string; body: string; };

const equ: Parser = seqMap(
  optLineSpace.then(token).skip(lineSpace), string('EQU').skip(lineSpace),
  takeWhile(c => c !== ';' && c !== '\n'), eol,
  (name, _, body, _2) => ({ kind: 'macro', name, body } as Macro)
);

const equs: Parser = seqMap(
  optLineSpace.then(token).skip(lineSpace), string('EQUS').skip(lineSpace),
  string('"').then(takeWhile(c => c !== '"')).skip(string('"')), eol,
  (name, _, body, _2) => ({ kind: 'macro', name, body } as Macro)
);

// This parser needs to be information-preserving.
type Statement = { kind: 'statement', tokens: string[] };

const statement: Parser =
  optLineSpace.then(
    alt(token, lineSpace)
      .many()
      .map((tokens) => ({ kind: 'statement', tokens } as Statement))
  ).skip(eol);

const file: Parser<(Macro|Statement)[]> = alt(
  equs,
  equ,

const parser = options => r => Pa
    .seq(
        r.CAST,
        Pa.string('('),
        Pa.optWhitespace,
        r.expr.map(data => data.output),
        Pa.whitespace,
        r.AS,
        Pa.whitespace,
        r.castType,
        Pa.optWhitespace,
        Pa.string(')')
    )
    .map(data => {
        const operator = new Operator();
        operator.setName(data[0]);
        operator.addParam(data[3]);
        operator.addParam(data[7]);

        const expr = new Expr();

Pa.string('MINUTE_MICROSECOND'),
                Pa.string('MINUTE_SECOND'),
                Pa.string('MINUTE'),
                Pa.string('HOUR_MICROSECOND'),
                Pa.string('HOUR_SECOND'),
                Pa.string('HOUR_MINUTE'),
                Pa.string('HOUR'),
                Pa.string('DAY_MICROSECOND'),
                Pa.string('DAY_SECOND'),
                Pa.string('DAY_MINUTE'),
                Pa.string('DAY_HOUR'),
                Pa.string('DAY'),
                Pa.string('WEEK'),
                Pa.string('MONTH'),
                Pa.string('QUARTER'),
                Pa.string('YEAR_MONTH'),
                Pa.string('YEAR')
            );
        },

INTERVAL_UNIT () {
            return Pa.alt(
                Pa.string('MICROSECOND'),
                Pa.string('SECOND_MICROSECOND'),
                Pa.string('SECOND'),
                Pa.string('MINUTE_MICROSECOND'),
                Pa.string('MINUTE_SECOND'),
                Pa.string('MINUTE'),
                Pa.string('HOUR_MICROSECOND'),
                Pa.string('HOUR_SECOND'),
                Pa.string('HOUR_MINUTE'),
                Pa.string('HOUR'),
                Pa.string('DAY_MICROSECOND'),
                Pa.string('DAY_SECOND'),
                Pa.string('DAY_MINUTE'),
                Pa.string('DAY_HOUR'),
                Pa.string('DAY'),
                Pa.string('WEEK'),
                Pa.string('MONTH'),
                Pa.string('QUARTER'),
                Pa.string('YEAR_MONTH'),
                Pa.string('YEAR')
            );
        },

  LBRACK: _ => P.string('[').trim(P.optWhitespace),

    GT: _ => P.string('>').trim(P.optWhitespace),
    COLON: _ => P.string(':').trim(P.optWhitespace),

(
      segments: [
        SimpleObjectProjectionItemType,
        [WrappedObjectProjectionNodeType]
      ]
    ): ObjectProjectionItemType =>
      segments[1].length === 0
        ? segments[0]
        : {
          type: 'RecursiveItem',
          name: segments[0].value,
          value: segments[1][0]
        }
  )

  const AliasParser = P.seq(SimpleItemParser, P.string(':').trim(crap))

  const AliasableItemParser = P.seq(
    AliasParser.atMost(1),
    RecursiveItemParser
  ).map(
    ([alias, item]: [
      [ObjectProjectionNodeType, string],
      ObjectProjectionNodeType
    ]): ObjectProjectionNodeType =>
      alias.length === 1 ? { ...item, alias: alias[0][0].value } : item
  )

  const FragmentParser = P.string('...')
    .then(crap)
    .then(IdentifierParser)
    .map((value: {value: string}): FragmentObjectProjectionItemType => ({

    DOT: _ => P.string('.').trim(P.optWhitespace),
    USCORE: _ => P.string('_').trim(P.optWhitespace),

Attribute: function () {
        return P.seqMap(
            Wxml.Attr,
            P.optWhitespace,
            P.string('='),
            P.optWhitespace,
            Wxml.singleQuoteString
            .or(Wxml.doubleQuoteString),
            whitespaces,
            function (...r) {
                return [r[0], r[4]];
            }
        )
        .or(P.seqMap(
            Wxml.Attr,
            whitespaces,
            function (r1, r2) {
                return [r1, null]
            }
        ));
    },

STRING_SQ (r) {
            return Pa
                .seq(
                    Pa.string("'"),
                    Pa.alt(r.SCHAR, Pa.string('"'), r.ESCAPED_SQ, r.ESCAPED_ESCAPE_CHAR).many().tie(),
                    Pa.string("'")
                )
                .tie();
        },