@malloydata/malloy-filter 0.0.350 → 0.0.351

package/src/number_filter_expression.ts

@@ -7,19 +7,15 @@
 
 import type {FilterParserResponse, NumberFilter} from './filter_interface';
 import {isNumberFilter} from './filter_interface';
-import * as nearley from 'nearley';
-import fnumber_grammar from './lib/fexpr_number_parser';
-import {run_parser} from './nearley_parse';
+import {parse as peggyNumberParser} from './lib/fexpr_number_parser';
+import {run_parser} from './peggy_parse';
 
 export const NumberFilterExpression = {
   parse(src: string): FilterParserResponse<NumberFilter> {
     if (src.match(/^\s*$/)) {
       return {parsed: null, log: []};
     }
-    const fnumber_parser = new nearley.Parser(
-      nearley.Grammar.fromCompiled(fnumber_grammar)
-    );
-    const parse_result = run_parser(src, fnumber_parser);
+    const parse_result = run_parser(src, peggyNumberParser);
     if (parse_result.parsed && isNumberFilter(parse_result.parsed)) {
       return {parsed: parse_result.parsed, log: []};
     }

package/src/peggy_parse.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {FilterExpression, FilterLog} from './filter_interface';
+import {isFilterExpression} from './filter_interface';
+
+interface PeggySyntaxError {
+  message: string;
+  location?: {
+    start: {offset: number; column: number};
+    end: {offset: number; column: number};
+  };
+}
+
+function isPeggySyntaxError(e: unknown): e is PeggySyntaxError {
+  return e instanceof Error && 'location' in e;
+}
+
+export function run_parser(
+  src: string,
+  parse: (input: string) => unknown
+): {parsed: FilterExpression | null; log: FilterLog[]} {
+  try {
+    const expr = parse(src);
+    if (isFilterExpression(expr)) {
+      return {parsed: expr, log: []};
+    }
+    return {parsed: null, log: []};
+  } catch (e) {
+    if (isPeggySyntaxError(e)) {
+      const loc = e.location;
+      const startIndex = loc ? loc.start.offset : 0;
+      const endIndex = loc ? loc.end.offset - 1 : src.length - 1;
+      return {
+        parsed: null,
+        log: [
+          {
+            message: e.message,
+            startIndex,
+            endIndex: Math.max(startIndex, endIndex),
+            severity: 'error',
+          },
+        ],
+      };
+    }
+    throw e;
+  }
+}

package/src/string_filter_expression.ts

@@ -7,25 +7,16 @@
 
 import type {FilterParserResponse, StringFilter} from './filter_interface';
 import {isStringFilter} from './filter_interface';
-import * as nearley from 'nearley';
-import fstring_grammar from './lib/fexpr_string_parser';
+import {parse as peggyStringParser} from './lib/fexpr_string_parser';
 import {escape} from './clause_utils';
-import {run_parser} from './nearley_parse';
+import {run_parser} from './peggy_parse';
 
-// This could be mistake, I am replacing the hand coded lexer and parsers
-// which previously existed with nearley/moo -- As the language is still
-// in flux, it is much easier for me to maintain the code if the parser
-// is not hand coded. Full apologies to the original author of the hand
-// coded parsers.
 export const StringFilterExpression = {
   parse(src: string): FilterParserResponse<StringFilter> {
     if (src.match(/^\s*$/)) {
       return {parsed: null, log: []};
     }
-    const fstring_parser = new nearley.Parser(
-      nearley.Grammar.fromCompiled(fstring_grammar)
-    );
-    const parse_result = run_parser(src, fstring_parser);
+    const parse_result = run_parser(src, peggyStringParser);
     if (parse_result.parsed && isStringFilter(parse_result.parsed)) {
       return {parsed: parse_result.parsed, log: []};
     }

package/src/temporal_filter_expression.ts

@@ -12,19 +12,15 @@ import type {
   Duration,
 } from './filter_interface';
 import {isTemporalFilter} from './filter_interface';
-import ftemporal_grammar from './lib/ftemporal_parser';
-import * as nearley from 'nearley';
-import {run_parser} from './nearley_parse';
+import {parse as peggyTemporalParser} from './lib/ftemporal_parser';
+import {run_parser} from './peggy_parse';
 
 export const TemporalFilterExpression = {
   parse(src: string): FilterParserResponse<TemporalFilter> {
     if (src.match(/^\s*$/)) {
       return {parsed: null, log: []};
     }
-    const ftemporal_parser = new nearley.Parser(
-      nearley.Grammar.fromCompiled(ftemporal_grammar)
-    );
-    const parse_result = run_parser(src, ftemporal_parser);
+    const parse_result = run_parser(src, peggyTemporalParser);
     if (parse_result.parsed && isTemporalFilter(parse_result.parsed)) {
       return {parsed: parse_result.parsed, log: []};
     }

package/tsconfig.json

@@ -4,7 +4,8 @@
     "rootDir": "src",
     "outDir": "dist",
     "composite": true,
-    "noImplicitReturns": true
+    "noImplicitReturns": true,
+    "allowJs": true
   },
-  "include": ["src/**/*.ts"]
+  "include": ["src/**/*.ts", "src/**/*.js"]
 }

package/dist/nearley_parse.js

@@ -1,51 +0,0 @@
-"use strict";
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run_parser = run_parser;
-const filter_interface_1 = require("./filter_interface");
-function run_parser(src, parser) {
-    try {
-        parser.feed(src);
-        const results = parser.finish();
-        const expr = results[0];
-        if ((0, filter_interface_1.isFilterExpression)(expr)) {
-            return { parsed: expr, log: [] };
-        }
-        return { parsed: null, log: [] };
-    }
-    catch (e) {
-        let newMessage = e.message;
-        let col = 1;
-        let len = src.length;
-        if (e.token) {
-            const token = e.token;
-            col = token.col;
-            len = token.text.length;
-            const message = e.message;
-            const expected = message
-                .match(/(?<=A ).*(?= based on:)/g)
-                .map(s => s.replace(/\s+token/i, ''));
-            newMessage = `Unexpected ${token.type} token "${token.value}"`;
-            if (expected && expected.length) {
-                newMessage += ` Tokens expected: ${[...new Set(expected)]}`;
-            }
-        }
-        return {
-            parsed: null,
-            log: [
-                {
-                    message: newMessage,
-                    startIndex: col - 1,
-                    endIndex: col - 1 + len - 1,
-                    severity: 'error',
-                },
-            ],
-        };
-    }
-}
-//# sourceMappingURL=nearley_parse.js.map

package/dist/nearley_parse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nearley_parse.js","sourceRoot":"","sources":["../src/nearley_parse.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAMH,gCAyCC;AA3CD,yDAAsD;AAEtD,SAAgB,UAAU,CACxB,GAAW,EACX,MAAc;IAEd,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjB,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;QAChC,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,IAAA,qCAAkB,EAAC,IAAI,CAAC,EAAE,CAAC;YAC7B,OAAO,EAAC,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAC,CAAC;QACjC,CAAC;QACD,OAAO,EAAC,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAC,CAAC;IACjC,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,IAAI,UAAU,GAAG,CAAC,CAAC,OAAO,CAAC;QAC3B,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,IAAI,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC;QACrB,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;YACZ,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;YACtB,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;YAChB,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;YACxB,MAAM,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC;YAC1B,MAAM,QAAQ,GAAG,OAAO;iBACrB,KAAK,CAAC,0BAA0B,CAAC;iBACjC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC;YACxC,UAAU,GAAG,cAAc,KAAK,CAAC,IAAI,WAAW,KAAK,CAAC,KAAK,GAAG,CAAC;YAC/D,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;gBAChC,UAAU,IAAI,qBAAqB,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;YAC9D,CAAC;QACH,CAAC;QACD,OAAO;YACL,MAAM,EAAE,IAAI;YACZ,GAAG,EAAE;gBACH;oBACE,OAAO,EAAE,UAAU;oBACnB,UAAU,EAAE,GAAG,GAAG,CAAC;oBACnB,QAAQ,EAAE,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC;oBAC3B,QAAQ,EAAE,OAAO;iBAClB;aACF;SACF,CAAC;IACJ,CAAC;AACH,CAAC"}

package/src/lib/fexpr_number_parser.ts

@@ -1,126 +0,0 @@
-// Generated automatically by nearley, version 2.20.1
-// http://github.com/Hardmath123/nearley
-// Bypasses TS6133. Allow declared but unused functions.
-// @ts-ignore
-function id(d: any[]): any { return d[0]; }
-declare var NOT: any;
-declare var NULL_KW: any;
-declare var eq: any;
-declare var ne: any;
-declare var op: any;
-declare var oparen: any;
-declare var cparen: any;
-declare var TO: any;
-declare var comma: any;
-declare var cbrack: any;
-declare var obrack: any;
-declare var float: any;
-declare var numberE: any;
-declare var integer: any;
-declare var OR: any;
-declare var AND: any;
-
-import moo from 'moo';
-import {numNot, mkRange, joinNumbers, mkValues} from '../clause_utils';
-
-const kwList = moo.keywords({
-  'AND': 'and',
-  'OR': 'or',
-  'NOT': 'not',
-  'NULL_KW': 'null',
-  'TO': 'to',
-});
-
-const fnumber_lexer = moo.compile({
-  WS: /[ \t]+/,
-  id: {
-    match: /[a-zA-Z]+/,
-    type: kw => kwList(kw.toLowerCase()),
-  },
-  oparen: '(',
-  cparen: ')',
-  obrack: '[',
-  cbrack: ']',
-  comma: ',',
-  op: /<=|>=|<|>/,
-  ne: '!=',
-  eq: '=',
-  float: /-?(?:\d+)?\.\d+(?:[Ee][+-]?\d+)?/,
-  numberE: /-?\d+[Ee][+-]?\d+/,
-  integer: /-?\d+/,
-});
-
-const actual_next = fnumber_lexer.next;
-fnumber_lexer.next = (next => () => {
-  for (;;) {
-    const token = next.call(fnumber_lexer);
-    if (token === undefined || token.type !== 'WS') {
-      return token;
-    }
-  }
-})(actual_next);
-
-interface NearleyToken {
-  value: any;
-  [key: string]: any;
-};
-
-interface NearleyLexer {
-  reset: (chunk: string, info: any) => void;
-  next: () => NearleyToken | undefined;
-  save: () => any;
-  formatError: (token: never) => string;
-  has: (tokenType: string) => boolean;
-};
-
-interface NearleyRule {
-  name: string;
-  symbols: NearleySymbol[];
-  postprocess?: (d: any[], loc?: number, reject?: {}) => any;
-};
-
-type NearleySymbol = string | { literal: any } | { test: (token: any) => boolean };
-
-interface Grammar {
-  Lexer: NearleyLexer | undefined;
-  ParserRules: NearleyRule[];
-  ParserStart: string;
-};
-
-const grammar: Grammar = {
-  Lexer: fnumber_lexer,
-  ParserRules: [
-    {"name": "numberFilter", "symbols": ["numberFilter", "conjunction", "numberUnary"], "postprocess": ([left, cop, right]) => joinNumbers(left, cop[0].text, right)},
-    {"name": "numberFilter", "symbols": ["numberUnary"], "postprocess": (data) => data[0]},
-    {"name": "numberUnary$ebnf$1", "symbols": [(fnumber_lexer.has("NOT") ? {type: "NOT"} : NOT)], "postprocess": id},
-    {"name": "numberUnary$ebnf$1", "symbols": [], "postprocess": () => null},
-    {"name": "numberUnary", "symbols": ["numberUnary$ebnf$1", "clause"], "postprocess": ([notToken, clause]) => numNot(clause, notToken)},
-    {"name": "clause", "symbols": [(fnumber_lexer.has("NULL_KW") ? {type: "NULL_KW"} : NULL_KW)], "postprocess": () => ({operator: 'null' })},
-    {"name": "clause$ebnf$1", "symbols": []},
-    {"name": "clause$ebnf$1", "symbols": ["clause$ebnf$1", "numberList"], "postprocess": (d) => d[0].concat([d[1]])},
-    {"name": "clause", "symbols": ["N", "clause$ebnf$1"], "postprocess": ([n, nList]) => ({operator: '=', ...mkValues(n, nList)})},
-    {"name": "clause$ebnf$2", "symbols": []},
-    {"name": "clause$ebnf$2", "symbols": ["clause$ebnf$2", "numberList"], "postprocess": (d) => d[0].concat([d[1]])},
-    {"name": "clause", "symbols": [(fnumber_lexer.has("eq") ? {type: "eq"} : eq), "N", "clause$ebnf$2"], "postprocess": ([_, n, nList]) => ({operator: '=', ...mkValues(n, nList)})},
-    {"name": "clause$ebnf$3", "symbols": []},
-    {"name": "clause$ebnf$3", "symbols": ["clause$ebnf$3", "numberList"], "postprocess": (d) => d[0].concat([d[1]])},
-    {"name": "clause", "symbols": [(fnumber_lexer.has("ne") ? {type: "ne"} : ne), "N", "clause$ebnf$3"], "postprocess": ([_, n, nList]) => ({operator: '!=', ...mkValues(n, nList)})},
-    {"name": "clause", "symbols": [(fnumber_lexer.has("op") ? {type: "op"} : op), "N"], "postprocess": ([op, n]) => ({operator: op.text, values: [n]})},
-    {"name": "clause", "symbols": [(fnumber_lexer.has("oparen") ? {type: "oparen"} : oparen), "numberFilter", (fnumber_lexer.has("cparen") ? {type: "cparen"} : cparen)], "postprocess": ([_1, subFilter, _3]) => ({operator: "()", expr: subFilter})},
-    {"name": "clause", "symbols": ["openInterval", "N", (fnumber_lexer.has("TO") ? {type: "TO"} : TO), "N", "closeInterval"], "postprocess": ([l, b, _to, e, r]) => mkRange(l[0].text,b,e,r[0].text)},
-    {"name": "numberList", "symbols": [(fnumber_lexer.has("comma") ? {type: "comma"} : comma), "N"], "postprocess": ([_, n]) => n},
-    {"name": "closeInterval", "symbols": [(fnumber_lexer.has("cbrack") ? {type: "cbrack"} : cbrack)]},
-    {"name": "closeInterval", "symbols": [(fnumber_lexer.has("cparen") ? {type: "cparen"} : cparen)]},
-    {"name": "openInterval", "symbols": [(fnumber_lexer.has("obrack") ? {type: "obrack"} : obrack)]},
-    {"name": "openInterval", "symbols": [(fnumber_lexer.has("oparen") ? {type: "oparen"} : oparen)]},
-    {"name": "N$subexpression$1", "symbols": [(fnumber_lexer.has("float") ? {type: "float"} : float)]},
-    {"name": "N$subexpression$1", "symbols": [(fnumber_lexer.has("numberE") ? {type: "numberE"} : numberE)]},
-    {"name": "N$subexpression$1", "symbols": [(fnumber_lexer.has("integer") ? {type: "integer"} : integer)]},
-    {"name": "N", "symbols": ["N$subexpression$1"], "postprocess": ([nMatch]) => nMatch[0].text},
-    {"name": "conjunction", "symbols": [(fnumber_lexer.has("OR") ? {type: "OR"} : OR)]},
-    {"name": "conjunction", "symbols": [(fnumber_lexer.has("AND") ? {type: "AND"} : AND)]}
-  ],
-  ParserStart: "numberFilter",
-};
-
-export default grammar;

package/src/lib/fexpr_string_parser.ts

@@ -1,84 +0,0 @@
-// Generated automatically by nearley, version 2.20.1
-// http://github.com/Hardmath123/nearley
-// Bypasses TS6133. Allow declared but unused functions.
-// @ts-ignore
-function id(d: any[]): any { return d[0]; }
-declare var minus: any;
-declare var open: any;
-declare var close: any;
-declare var matchStr: any;
-declare var comma: any;
-declare var semi: any;
-declare var or: any;
-
-import moo from 'moo';
-import {conjoin, maybeNot, matchOp} from '../clause_utils';
-
-const fstring_lexer = moo.compile({
-  WS: /[ \t]+/,
-  comma: ',',
-  semi: ';',
-  or: '|',
-  open: '(',
-  close: ')',
-  minus: '-',
-  matchStr: /(?:\\[^\n]|[^\n,;()|])+/,
-});
-
-const actual_next = fstring_lexer.next;
-fstring_lexer.next = (next => () => {
-  for (;;) {
-    const token = next.call(fstring_lexer);
-    if (token == undefined || token.type !== 'WS') {
-      return token;
-    }
-  }
-})(actual_next);
-
-
-interface NearleyToken {
-  value: any;
-  [key: string]: any;
-};
-
-interface NearleyLexer {
-  reset: (chunk: string, info: any) => void;
-  next: () => NearleyToken | undefined;
-  save: () => any;
-  formatError: (token: never) => string;
-  has: (tokenType: string) => boolean;
-};
-
-interface NearleyRule {
-  name: string;
-  symbols: NearleySymbol[];
-  postprocess?: (d: any[], loc?: number, reject?: {}) => any;
-};
-
-type NearleySymbol = string | { literal: any } | { test: (token: any) => boolean };
-
-interface Grammar {
-  Lexer: NearleyLexer | undefined;
-  ParserRules: NearleyRule[];
-  ParserStart: string;
-};
-
-const grammar: Grammar = {
-  Lexer: fstring_lexer,
-  ParserRules: [
-    {"name": "stringFilter", "symbols": ["stringFilter", "conjunction", "sfUnary"], "postprocess": ([left, cop, right]) => conjoin(left, cop[0].text, right)},
-    {"name": "stringFilter", "symbols": ["sfUnary"], "postprocess": (data) => data[0]},
-    {"name": "sfUnary$ebnf$1", "symbols": [(fstring_lexer.has("minus") ? {type: "minus"} : minus)], "postprocess": id},
-    {"name": "sfUnary$ebnf$1", "symbols": [], "postprocess": () => null},
-    {"name": "sfUnary", "symbols": ["sfUnary$ebnf$1", "clause"], "postprocess": (data) => maybeNot(data)},
-    {"name": "parens", "symbols": [(fstring_lexer.has("open") ? {type: "open"} : open), "stringFilter", (fstring_lexer.has("close") ? {type: "close"} : close)], "postprocess": ([_1, subFilter, _3]) => ({operator: "()", expr: subFilter})},
-    {"name": "clause", "symbols": [(fstring_lexer.has("matchStr") ? {type: "matchStr"} : matchStr)], "postprocess": ([withStr]) => matchOp(withStr.text)},
-    {"name": "clause", "symbols": ["parens"], "postprocess": (data) => data[0]},
-    {"name": "conjunction", "symbols": [(fstring_lexer.has("comma") ? {type: "comma"} : comma)]},
-    {"name": "conjunction", "symbols": [(fstring_lexer.has("semi") ? {type: "semi"} : semi)]},
-    {"name": "conjunction", "symbols": [(fstring_lexer.has("or") ? {type: "or"} : or)]}
-  ],
-  ParserStart: "stringFilter",
-};
-
-export default grammar;

package/src/lib/ftemporal_parser.ts

@@ -1,246 +0,0 @@
-// Generated automatically by nearley, version 2.20.1
-// http://github.com/Hardmath123/nearley
-// Bypasses TS6133. Allow declared but unused functions.
-// @ts-ignore
-function id(d: any[]): any { return d[0]; }
-declare var NOT: any;
-declare var n: any;
-declare var lityear: any;
-declare var SECOND: any;
-declare var MINUTE: any;
-declare var HOUR: any;
-declare var DAY: any;
-declare var WEEK: any;
-declare var MONTH: any;
-declare var QUARTER: any;
-declare var YEAR: any;
-declare var SECONDS: any;
-declare var MINUTES: any;
-declare var HOURS: any;
-declare var DAYS: any;
-declare var WEEKS: any;
-declare var MONTHS: any;
-declare var QUARTERS: any;
-declare var YEARS: any;
-declare var NULL_KW: any;
-declare var BEFORE: any;
-declare var STARTING: any;
-declare var AFTER: any;
-declare var THROUGH: any;
-declare var TO: any;
-declare var FOR: any;
-declare var LAST: any;
-declare var NEXT: any;
-declare var THIS: any;
-declare var NOW: any;
-declare var TODAY: any;
-declare var YESTERDAY: any;
-declare var TOMORROW: any;
-declare var AGO: any;
-declare var FROM: any;
-declare var literal: any;
-declare var lit_day: any;
-declare var lit_min: any;
-declare var lit_hour: any;
-declare var lit_month: any;
-declare var lit_quarter: any;
-declare var lit_week: any;
-declare var lit_year: any;
-declare var MONDAY: any;
-declare var TUESDAY: any;
-declare var WEDNESDAY: any;
-declare var THURSDAY: any;
-declare var FRIDAY: any;
-declare var SATURDAY: any;
-declare var SUNDAY: any;
-declare var oparen: any;
-declare var cparen: any;
-declare var OR: any;
-declare var AND: any;
-
-import moo from 'moo';
-import {temporalNot, joinTemporal, timeLiteral, mkUnits} from '../clause_utils';
-
-const kwList = moo.keywords(
-  {
-      'AND': 'and',
-      'OR': 'or',
-      'NOT': 'not',
-      'NULL_KW': 'null',
-      'TO': 'to',
-      'NOW': 'now',
-      'LAST': 'last',
-      'THIS': 'this',
-      'NEXT': 'next',
-      'AGO': 'ago',
-      'FROM': 'from',
-      'BEFORE': 'before',
-      'AFTER': 'after',
-      'THROUGH': 'through',
-      'STARTING': 'starting',
-      'FOR': 'for',
-      'TODAY': 'today',
-      'YESTERDAY': 'yesterday',
-      'TOMORROW': 'tomorrow',
-      'SECOND': 'second',
-      'MINUTE': 'minute',
-      'HOUR': 'hour',
-      'DAY': 'day',
-      'WEEK': 'week',
-      'MONTH': 'month',
-      'QUARTER': 'quarter',
-      'YEAR': 'year',
-      'SECONDS': 'seconds',
-      'MINUTES': 'minutes',
-      'HOURS': 'hours',
-      'DAYS': 'days',
-      'WEEKS': 'weeks',
-      'MONTHS': 'months',
-      'QUARTERS': 'quarters',
-      'YEARS': 'years',
-      'MONDAY': 'monday',
-      'TUESDAY': 'tuesday',
-      'WEDNESDAY': 'wednesday',
-      'THURSDAY': 'thursday',
-      'FRIDAY': 'friday',
-      'SATURDAY': 'saturday',
-      'SUNDAY': 'sunday',
-    }
-);
-
-const temporal_lexer = moo.compile({
-  WS: /[ \t]+/,
-  id: {
-    match: /[a-zA-Z]+/,
-    type: kw => kwList(kw.toLowerCase()),
-  },
-  oparen: '(',
-  cparen: ')',
-  comma: ',',
-  literal: /\d\d\d\d-\d\d-\d\d[ Tt]\d\d:\d\d(?::\d\d(?:[.,]\d*)?)/,
-  lit_week: /\d\d\d\d-\d\d-\d\d-[Ww][Kk]/,
-  lit_quarter: /\d\d\d\d-[qQ][1234]/,
-  lit_min: /\d\d\d\d-\d\d-\d\d[ Tt]\d\d:\d\d/,
-  lit_hour: /\d\d\d\d-\d\d-\d\d[ Tt]\d\d/,
-  lit_day: /\d\d\d\d-\d\d-\d\d/,
-  lit_month: /\d\d\d\d-\d\d/,
-  lit_year: /\d\d\d\d/,
-  n: /\d+/,
-});
-
-const actual_next = temporal_lexer.next;
-temporal_lexer.next = (next => () => {
-  for (;;) {
-    const token = next.call(temporal_lexer);
-    if (token === undefined || token.type !== 'WS') {
-      return token;
-    }
-  }
-})(actual_next);
-
-interface NearleyToken {
-  value: any;
-  [key: string]: any;
-};
-
-interface NearleyLexer {
-  reset: (chunk: string, info: any) => void;
-  next: () => NearleyToken | undefined;
-  save: () => any;
-  formatError: (token: never) => string;
-  has: (tokenType: string) => boolean;
-};
-
-interface NearleyRule {
-  name: string;
-  symbols: NearleySymbol[];
-  postprocess?: (d: any[], loc?: number, reject?: {}) => any;
-};
-
-type NearleySymbol = string | { literal: any } | { test: (token: any) => boolean };
-
-interface Grammar {
-  Lexer: NearleyLexer | undefined;
-  ParserRules: NearleyRule[];
-  ParserStart: string;
-};
-
-const grammar: Grammar = {
-  Lexer: temporal_lexer,
-  ParserRules: [
-    {"name": "temporalFilter", "symbols": ["temporalFilter", "conjunction", "temporalUnary"], "postprocess": ([left, cop, right]) => joinTemporal(left, cop[0].text, right)},
-    {"name": "temporalFilter", "symbols": ["temporalUnary"], "postprocess": (data) => data[0]},
-    {"name": "temporalUnary$ebnf$1", "symbols": [(temporal_lexer.has("NOT") ? {type: "NOT"} : NOT)], "postprocess": id},
-    {"name": "temporalUnary$ebnf$1", "symbols": [], "postprocess": () => null},
-    {"name": "temporalUnary", "symbols": ["temporalUnary$ebnf$1", "clause"], "postprocess": ([notToken, op]) => temporalNot(op, notToken)},
-    {"name": "duration", "symbols": ["number", "unit"], "postprocess": ([n, units]) => ({units, n})},
-    {"name": "number", "symbols": [(temporal_lexer.has("n") ? {type: "n"} : n)], "postprocess": ([numToken]) => numToken.text},
-    {"name": "number", "symbols": [(temporal_lexer.has("lityear") ? {type: "lityear"} : lityear)], "postprocess": ([yearToken]) => yearToken.text},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("SECOND") ? {type: "SECOND"} : SECOND)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("MINUTE") ? {type: "MINUTE"} : MINUTE)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("HOUR") ? {type: "HOUR"} : HOUR)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("DAY") ? {type: "DAY"} : DAY)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("WEEK") ? {type: "WEEK"} : WEEK)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("MONTH") ? {type: "MONTH"} : MONTH)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("QUARTER") ? {type: "QUARTER"} : QUARTER)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("YEAR") ? {type: "YEAR"} : YEAR)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("SECONDS") ? {type: "SECONDS"} : SECONDS)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("MINUTES") ? {type: "MINUTES"} : MINUTES)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("HOURS") ? {type: "HOURS"} : HOURS)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("DAYS") ? {type: "DAYS"} : DAYS)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("WEEKS") ? {type: "WEEKS"} : WEEKS)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("MONTHS") ? {type: "MONTHS"} : MONTHS)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("QUARTERS") ? {type: "QUARTERS"} : QUARTERS)]},
-    {"name": "unit$subexpression$1", "symbols": [(temporal_lexer.has("YEARS") ? {type: "YEARS"} : YEARS)]},
-    {"name": "unit", "symbols": ["unit$subexpression$1"], "postprocess": ([unitToken]) => mkUnits(unitToken[0].text)},
-    {"name": "clause", "symbols": [(temporal_lexer.has("NULL_KW") ? {type: "NULL_KW"} : NULL_KW)], "postprocess": () => ({operator: 'null' })},
-    {"name": "clause", "symbols": ["parens"], "postprocess": (data) => data[0]},
-    {"name": "clause", "symbols": ["duration"], "postprocess": ([duration]) => ({operator: 'in_last', ...duration})},
-    {"name": "clause", "symbols": [(temporal_lexer.has("BEFORE") ? {type: "BEFORE"} : BEFORE), "moment"], "postprocess": ([_, moment]) => ({operator: 'before', before: moment })},
-    {"name": "clause", "symbols": [(temporal_lexer.has("STARTING") ? {type: "STARTING"} : STARTING), "moment"], "postprocess": ([_, moment]) => ({operator: 'before', before: moment, not: true})},
-    {"name": "clause", "symbols": [(temporal_lexer.has("AFTER") ? {type: "AFTER"} : AFTER), "moment"], "postprocess": ([_, moment]) => ({operator: 'after', after: moment })},
-    {"name": "clause", "symbols": [(temporal_lexer.has("THROUGH") ? {type: "THROUGH"} : THROUGH), "moment"], "postprocess": ([_, moment]) => ({operator: 'after', after: moment, not: true})},
-    {"name": "clause", "symbols": ["moment", (temporal_lexer.has("TO") ? {type: "TO"} : TO), "moment"], "postprocess": ([fromMoment, _, toMoment]) => ({operator: 'to', fromMoment, toMoment})},
-    {"name": "clause", "symbols": ["moment", (temporal_lexer.has("FOR") ? {type: "FOR"} : FOR), "duration"], "postprocess": ([moment, _, duration]) => ({...duration, operator: 'for', begin: moment})},
-    {"name": "clause$subexpression$1", "symbols": [(temporal_lexer.has("LAST") ? {type: "LAST"} : LAST)]},
-    {"name": "clause$subexpression$1", "symbols": [(temporal_lexer.has("NEXT") ? {type: "NEXT"} : NEXT)]},
-    {"name": "clause", "symbols": ["clause$subexpression$1", "duration"], "postprocess": ([op, duration]) => ({operator: op[0].text, ...duration})},
-    {"name": "clause", "symbols": ["moment"], "postprocess": ([moment]) => ({operator: 'in', in: moment})},
-    {"name": "lastNextThis", "symbols": [(temporal_lexer.has("THIS") ? {type: "THIS"} : THIS)], "postprocess": ([token]) => token.text.toLowerCase()},
-    {"name": "lastNextThis", "symbols": [(temporal_lexer.has("NEXT") ? {type: "NEXT"} : NEXT)], "postprocess": ([token]) => token.text.toLowerCase()},
-    {"name": "lastNextThis", "symbols": [(temporal_lexer.has("LAST") ? {type: "LAST"} : LAST)], "postprocess": ([token]) => token.text.toLowerCase()},
-    {"name": "moment", "symbols": [(temporal_lexer.has("NOW") ? {type: "NOW"} : NOW)], "postprocess": () => ({moment: 'now'})},
-    {"name": "moment", "symbols": ["lastNextThis", "unit"], "postprocess": ([moment, units]) => ({moment, units})},
-    {"name": "moment", "symbols": [(temporal_lexer.has("TODAY") ? {type: "TODAY"} : TODAY)], "postprocess": () => ({moment: 'today'})},
-    {"name": "moment", "symbols": [(temporal_lexer.has("YESTERDAY") ? {type: "YESTERDAY"} : YESTERDAY)], "postprocess": () => ({moment: 'yesterday'})},
-    {"name": "moment", "symbols": [(temporal_lexer.has("TOMORROW") ? {type: "TOMORROW"} : TOMORROW)], "postprocess": () => ({moment: 'tomorrow'})},
-    {"name": "moment", "symbols": ["duration", (temporal_lexer.has("AGO") ? {type: "AGO"} : AGO)], "postprocess": ([duration, _]) => ({moment: 'ago', ...duration})},
-    {"name": "moment", "symbols": ["duration", (temporal_lexer.has("FROM") ? {type: "FROM"} : FROM), (temporal_lexer.has("NOW") ? {type: "NOW"} : NOW)], "postprocess": ([duration, _]) => ({moment: 'from_now', ...duration})},
-    {"name": "moment", "symbols": [(temporal_lexer.has("NEXT") ? {type: "NEXT"} : NEXT), "weekday"], "postprocess": ([_, dn]) => ({moment: dn.toLowerCase(), which: 'next'})},
-    {"name": "moment", "symbols": [(temporal_lexer.has("LAST") ? {type: "LAST"} : LAST), "weekday"], "postprocess": ([_, dn]) => ({moment: dn.toLowerCase(), which: 'last'})},
-    {"name": "moment", "symbols": ["weekday"], "postprocess": ([dn]) => ({moment: dn.toLowerCase(), which: 'last'})},
-    {"name": "moment", "symbols": ["timeLiteral"], "postprocess": d => d[0]},
-    {"name": "timeLiteral", "symbols": [(temporal_lexer.has("literal") ? {type: "literal"} : literal)], "postprocess": ([l]) => timeLiteral(l.text)},
-    {"name": "timeLiteral", "symbols": [(temporal_lexer.has("lit_day") ? {type: "lit_day"} : lit_day)], "postprocess": ([l]) => timeLiteral(l.text, 'day')},
-    {"name": "timeLiteral", "symbols": [(temporal_lexer.has("lit_min") ? {type: "lit_min"} : lit_min)], "postprocess": ([l]) => timeLiteral(l.text, 'minute')},
-    {"name": "timeLiteral", "symbols": [(temporal_lexer.has("lit_hour") ? {type: "lit_hour"} : lit_hour)], "postprocess": ([l]) => timeLiteral(l.text, 'hour')},
-    {"name": "timeLiteral", "symbols": [(temporal_lexer.has("lit_month") ? {type: "lit_month"} : lit_month)], "postprocess": ([l]) => timeLiteral(l.text, 'month')},
-    {"name": "timeLiteral", "symbols": [(temporal_lexer.has("lit_quarter") ? {type: "lit_quarter"} : lit_quarter)], "postprocess": ([l]) => timeLiteral(l.text, 'quarter')},
-    {"name": "timeLiteral", "symbols": [(temporal_lexer.has("lit_week") ? {type: "lit_week"} : lit_week)], "postprocess": ([l]) => timeLiteral(l.text, 'week')},
-    {"name": "timeLiteral", "symbols": [(temporal_lexer.has("lit_year") ? {type: "lit_year"} : lit_year)], "postprocess": ([l]) => timeLiteral(l.text, 'year')},
-    {"name": "weekday$subexpression$1", "symbols": [(temporal_lexer.has("MONDAY") ? {type: "MONDAY"} : MONDAY)]},
-    {"name": "weekday$subexpression$1", "symbols": [(temporal_lexer.has("TUESDAY") ? {type: "TUESDAY"} : TUESDAY)]},
-    {"name": "weekday$subexpression$1", "symbols": [(temporal_lexer.has("WEDNESDAY") ? {type: "WEDNESDAY"} : WEDNESDAY)]},
-    {"name": "weekday$subexpression$1", "symbols": [(temporal_lexer.has("THURSDAY") ? {type: "THURSDAY"} : THURSDAY)]},
-    {"name": "weekday$subexpression$1", "symbols": [(temporal_lexer.has("FRIDAY") ? {type: "FRIDAY"} : FRIDAY)]},
-    {"name": "weekday$subexpression$1", "symbols": [(temporal_lexer.has("SATURDAY") ? {type: "SATURDAY"} : SATURDAY)]},
-    {"name": "weekday$subexpression$1", "symbols": [(temporal_lexer.has("SUNDAY") ? {type: "SUNDAY"} : SUNDAY)]},
-    {"name": "weekday", "symbols": ["weekday$subexpression$1"], "postprocess": ([dayToken]) => dayToken[0].text},
-    {"name": "parens", "symbols": [(temporal_lexer.has("oparen") ? {type: "oparen"} : oparen), "temporalFilter", (temporal_lexer.has("cparen") ? {type: "cparen"} : cparen)], "postprocess": ([_1, subFilter, _3]) => ({operator: "()", expr: subFilter})},
-    {"name": "conjunction", "symbols": [(temporal_lexer.has("OR") ? {type: "OR"} : OR)]},
-    {"name": "conjunction", "symbols": [(temporal_lexer.has("AND") ? {type: "AND"} : AND)]}
-  ],
-  ParserStart: "temporalFilter",
-};
-
-export default grammar;