How to use moo - 10 common examples

throw new SyntaxError(`${unterminatedEscape} (${oct})`);
  }

  return {char: String.fromCodePoint(codePoint), newIndex: i + 3};
}

const unterminatedEscape = 'Unterminated escape sequence';

export type Token = {
  value: string,
  type: TokenType,
};

type TokenType = $Keys;

export const lexer = Moo.compile(lexerRules);
// Ignore whitespace and comment tokens
lexer.next = (next => () => {
  let tok;
  while ((tok = next.call(lexer)) && ['WS', 'comment'].includes(tok.type)) {}
  return tok;
})(lexer.next);

export function Tokenize(input: string): Array {
  lexer.reset(input);

  const tokens = [];
  let token;
  while ((token = lexer.next())) {
    tokens.push({value: token.value, type: token.type});
  }
  return tokens;

(function () {
function id(x) { return x[0]; }

const moo = require("moo"); // this 'require' creates a node dependency

const lexer = moo.compile({
  oscMsg:       ['oscIn'],
  mlModel:       ['mlmodel'],
  osc:          ['osc',    '∞'],
  sinosc:       ['sin',    '~'],
  cososc:       ['cos',    '≈'],
  triosc:       ['tri',    '∆'],
  sawosc:       ['saw',    '◊'],
  phasosc:      ['phasor', 'Ø'],
  squareosc:    ['square', '∏'],
  pulseosc:     ['pulse',  '^'],
  gateosc:      ['gate',   '≠'],
  patternosc:   ['patt',   '¶'],
  bus:          ['bus',    '‡' ],
  wnoise:       ['wnoise', 'Ω'],
  pnoise:       ['pnoise'],
  bnoise:       ['bnoise'],

// @ts-ignore
function id(d: any[]): any { return d[0]; }
declare var parameter: any;
declare var semicolon: any;
declare var lparen: any;
declare var rparen: any;
declare var or: any;
declare var annot: any;
declare var pair: any;
declare var singleArgData: any;
declare var doubleArgData: any;
declare var data: any;

    const moo = require("moo");

    const lexer = moo.compile({
        wspace: /[ \t]+/,
        lparen: '(',
        rparen: ')',
        annot: /:[^ );]+|%[^ );]+/,
        parameter: 'parameter',
        or: 'or',
        pair: 'pair',
        data: ['bytes', 'int', 'nat', 'bool', 'string', 'timestamp', 'signature', 'key', 'key_hash', 'mutez', 'address', 'unit', 'operation'],
        singleArgData: ['option', 'list', 'contract'],
        doubleArgData: ['lambda', 'map', 'big_map'],
        semicolon: ';'
    });


    import { Parameter, EntryPoint } from '../../../types/tezos/ContractIntrospectionTypes';

(function () {
function id(x) { return x[0]; }

const moo = require("moo"); // this 'require' creates a node dependency

const lexer = moo.compile({
  separator:    /,/,
  paramEnd:     /}/,
  paramBegin:   /{/,
  sample:       { match: /\\[a-zA-Z0-9]+/, lineBreaks: true, value: x => x.slice(0, x.length)},
  variable:     /:[a-zA-Z0-9]+:/,
  oscAddress:   /(?:\/[a-zA-Z0-9]+)+/,
  sample2:      /@[a-zA-Z0-9]+/,
  number:       /-?(?:[0-9]|[1-9][0-9]+)(?:\.[0-9]+)?(?:[eE][-+]?[0-9]+)?\b/,
  add:          /\+/,
  mult:         /\*/,
  div:          /\//,
  dot:          /\./,
  hash:         /\#/,
  hyphen:       /\-/,
  ndash:        /\–/,
  mdash:        /\—/,

(function () {
function id(x) { return x[0]; }

const moo = require("moo"); // this 'require' creates a node dependency

const lexer = moo.compile({
  osc: ['osc'],
  sinosc: ['sin'],
  cososc: ['cos'],
  sawosc: ['saw'],
  triosc: ['tri'],
  squareosc: ['square'],
  pulseosc: ['pulse'],
  wnoise: ['wnoise'],
  pnoise: ['pnoise'],
  bnoise: ['bnoise'],
  phasosc: ['phasor'],
  tpb: ['tpb'],
  functionkeyword: ['gain', 'adsr', 'dyn', 'dist', 'filter', 'delay', 'flang', 'chorus', 'samp'],
  o: /o/,
  x: /x/,
  at: /@/,

(function () {
function id(x) { return x[0]; }

const moo = require("moo"); // this 'require' creates a node dependency

const lexer = moo.compile({
  separator:      /,/,
  paramEnd:       /}/,
  paramBegin:     /{/,
  oscAddress:     /(?:\/[a-zA-Z0-9]+)+/,
  sample:         /(?:\\[a-zA-Z0-9]+)+/,
  add:            /\+/,
  mult:           /\*/,
  div:            /\//,
  dot:            /\./,
  hash:           /\#/,
  hyphen:         /\-/,
  ndash:          /\–/,
  mdash:          /\—/,
  comma:          /\,/,
  colon:          /\:/,
  semicolon:      /\;/,

},
      []
    );
  };

const moo = require("moo");

const escapeNearley = (x) => {
    return x.replace(/\t/g, '\\t') // Replace tab due to Nearley bug #nearley/issues/413
        .replace(/\f/g, '\\f')
        .replace(/\r/g, '\\r');
}

// we use lexer states to distinguish between the tokens
// in the text and the tokens inside the variables
const lexer = moo.states({
    main: {
        // a chunk is everything up until '[{', even across newlines. We then trim off the '[{'
        // we also push the lexer into the 'var' state
        Chunk: {
            match: /[^]*?\[{/,
            lineBreaks: true,
            push: 'var',
            value: x => escapeNearley(x.slice(0, -2))
        },
        // we now need to consume everything up until the end of the buffer.
        // note that the order of these two rules is important!
        LastChunk : {
            match: /[^]+/,
            lineBreaks: true,
            value: x => escapeNearley(x)
        }

value: x => JSON.parse(x),
        next: 'main',
    },
    btstring: {
        match: /`[^`]*`/,
        value: x => x.slice(1, -1),
        next: 'main',
    },
}, literals([
    ",", "|", "$", "%", "(", ")",
    ":?", ":*", ":+",
    "@include", "@builtin", "@",
    "]",
]))

var lexer = moo.states({
    main: Object.assign({}, rules, {
        charclass: {
            match: /\.|\[(?:\\.|[^\\\n])+?\]/,
            value: x => new RegExp(x),
        },
    }),
    // Both macro arguments and charclasses are both enclosed in [ ].
    // We disambiguate based on whether the previous token was a `word`.
    afterWord: Object.assign({}, rules, {
        "[": {match: "[", next: 'main'},
    }),
})

function insensitive(sl) {
    var s = sl.literal;
    var result = [];

},
  ],
  // `!=` needs explicit token because it is ambiguous:
  // can mean either vector comparator or label matcher.
  // Must be declared above binComp and labelOp, because their definitions
  // include `!=`, too.
  neq: '!=',
  binComp: BINARY_COMPARATORS,
  arithmetic: BINARY_ARITHMETIC_OPS,
  labelOp: LABEL_OPERATORS,
  // Allows greedy-matching identifiers, e.g.
  // `by` will be emitted as %clauseOp, but
  // `byteCount` will be emitted as %identifier
  identifier: {
    match: /\w+/,
    type: Moo.keywords({
      aggOp: AGGREGATION_OPERATORS,
      aggClause: AGGR_CLAUSE_TYPES,
      groupClause: GROUP_CLAUSE_TYPES,
      matchClause: MATCH_CLAUSE_TYPES,
      setOp: BINARY_SET_OPS,
    }),
  },
  string: [
    {
      // double-quoted string with no escape sequences;
      // shortcut for performance
      match: /"[^"\\]*"/,
      value: s => s.slice(1, -1),
    },
    {
      // single-quoted string with no escape sequences;

import * as moo from 'moo';

let lexer = moo.compile({
    lparen: '(',
    word:  /[a-z]+/,
    rparen: ')',
    keyword: ['while', 'if', 'else', 'moo', 'cows']
});

lexer = moo.states({
    main: {
        strstart: {match: '`', push: 'lit'},
        ident:    /\w+/,
        lbrace:   {match: '{', push: 'main'},
        rbrace:   {match: '}', pop: 1},
        colon:    ':',
        space:    {match: /\s+/, lineBreaks: true},
    },
    lit: {