Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
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: {