@malloydata/malloy-filter 0.0.237-dev250222034547 → 0.0.237-dev250223010918

package/README.md

@@ -19,42 +19,52 @@ To use the parser, simply import `FilterParser` and go.
 Example:
 
 ```code
-    import { FilterParser } from './filter_parser'
-
-    let str = 'CAT,DOG';
-    let response = new FilterParser(str, 'string').parse();
-    console.log(str, '\n', ...response.clauses, '\n');
-
-    str = '-5.5, 10, 2.3e7';
-    response = new FilterParser(str, 'number').parse();
-    console.log(str, '\n', ...response.clauses, '\n');
-
-    str = 'null, false';
-    response = new FilterParser(str, 'boolean').parse();
-    console.log(str, '\n', ...response.clauses, '\n');
-
-    str = 'after 2025-10-05';
-    response = new FilterParser(str, 'date').parse();
-    console.log(str, '\n', ...response.clauses, '\n');
+import {BooleanParser} from './boolean_parser';
+import {StringParser} from './string_parser';
+import {NumberParser} from './number_parser';
+import {DateParser} from './date_parser';
+
+function aSimpleParser() {
+  let str = 'CAT,DOG';
+  const stringResponse = new StringParser(str).parse();
+  console.log(str, '\n', ...stringResponse.clauses, '\n');
+
+  str = '-5.5, 10, 2.3e7';
+  const numberResponse = new NumberParser(str).parse();
+  console.log(str, '\n', ...numberResponse.clauses, '\n');
+
+  str = 'null, false';
+  const booleanResponse = new BooleanParser(str).parse();
+  console.log(str, '\n', ...booleanResponse.clauses, '\n');
+
+  str = 'after 2025-10-05';
+  const dateResponse = new DateParser(str).parse();
+  console.log(str, '\n', ...dateResponse.clauses, '\n');
+}
+
+aSimpleParser();
 ```
 
 Output:
 
 ```code
-CAT,DOG 
+CAT,DOG
  { operator: '=', values: [ 'CAT', 'DOG' ] }
 
 -5.5, 10, 2.3e7
  { operator: '=', values: [ -5.5, 10, 23000000 ] }
 
 null, false
- { operator: 'NULL' } { operator: 'FALSE' }
+ { operator: 'NULL' } { operator: 'FALSEORNULL' }
 
 after 2025-10-05
- { operator: 'DATE', date: '2025-10-05', prefix: 'AFTER' }
+ {
+  operator: 'AFTER',
+  moment: { type: 'ABSOLUTE', date: '2025-10-05', unit: 'DAY' }
+ }
 ```
 
-Likewise, to use the serializer, simply import `FilterSerializer`.
+Likewise, to use the serializers, simply import the `*Serializer` classes.
 
 ## Parsers
 
@@ -78,4 +88,4 @@ The date and time parser `date_parser.ts` supports the operations highlighted on
 
 ## Serializers
 
-Each parser has a complementary serializer that converts the parser output (`Clause[]`) back to a string. See examples of the round trip from string to Clause to string on the [Serialization Samples](SERIALIZE_SAMPLES.md) page.
+Each parser has a complementary serializer that converts the parser output (`xxxClause[]`) back to a string. See examples of the round trip from string to Clause to string on the [Serialization Samples](SERIALIZE_SAMPLES.md) page.

package/SAMPLES.md

@@ -1,11 +1,11 @@
 # Parsers
 
-Each filter type is handled by a different parser (strings, numbers, dates and times, etc). Sample outputs from each parser follow...
+Each filter type is handled by a different parser (strings, numbers, dates and times, etc).
+Sample outputs from each parser follow...
 
+-------------------------------------------------------------------------
 ## Numbers
 
-The number parser `number_parser.ts` supports the "numeric" expressions shown below. `Input` is the input string and `Output` shows the output of `number_parser`:
-
 ```code
 Input:  5
 Output:  { operator: '=', values: [ 5 ] }
@@ -13,8 +13,8 @@ Output:  { operator: '=', values: [ 5 ] }
 Input:  !=5
 Output:  { operator: '!=', values: [ 5 ] }
 
-Input:  1, 3, null , 7
-Output:  { operator: '=', values: [ 1, 3, null, 7 ] }
+Input:  1, 3, 5, null
+Output:  { operator: '=', values: [ 1, 3, 5 ] } { operator: 'NULL' }
 
 Input:  <1, >=100
 Output:  { operator: '<', values: [ 1 ] } { operator: '>=', values: [ 100 ] }
@@ -26,10 +26,10 @@ Input:   <= 10
 Output:  { operator: '<=', values: [ 10 ] }
 
 Input:  NULL
-Output:  { operator: '=', values: [ null ] }
+Output:  { operator: 'NULL' }
 
 Input:   -NULL
-Output:  { operator: '!=', values: [ null ] }
+Output:  { operator: 'NOTNULL' }
 
 Input:  (1, 7)
 Output:  {
@@ -89,7 +89,7 @@ Output:  {
   startValue: 0,
   endOperator: '<=',
   endValue: 10
-} { operator: '=', values: [ 20, null ] } {
+} { operator: '=', values: [ 20 ] } { operator: 'NULL' } {
   operator: 'range',
   startOperator: '>',
   startValue: 72,
@@ -98,8 +98,7 @@ Output:  {
 }
 
 Input:  , notanumber,, "null", apple pear orange, nulle, nnull, >=,
-Errors:  { message: 'Invalid expression', startIndex: 2, endIndex: 12 } { message: 'Invalid expression', startIndex: 15, endIndex: 21 } { message: 'Invalid expression', startIndex: 23, endIndex: 28 } { message: 'Invalid expression', startIndex: 29, endIndex: 33 } { message: 'Invalid expression', startIndex: 34, endIndex: 40 } { message: 'Invalid expression', startIndex: 42, endIndex: 47 } { message:
- 'Invalid expression', startIndex: 49, endIndex: 54 } { message: 'Invalid expression', startIndex: 56, endIndex: 58 }
+Errors:  { message: 'Invalid expression', startIndex: 2, endIndex: 12 } { message: 'Invalid expression', startIndex: 15, endIndex: 21 } { message: 'Invalid expression', startIndex: 23, endIndex: 28 } { message: 'Invalid expression', startIndex: 29, endIndex: 33 } { message: 'Invalid expression', startIndex: 34, endIndex: 40 } { message: 'Invalid expression', startIndex: 42, endIndex: 47 } { message: 'Invalid expression', startIndex: 49, endIndex: 54 } { message: 'Invalid expression', startIndex: 56, endIndex: 58 }
 
 Input:  [cat, 100], <cat
 Errors:  { message: 'Invalid number', startIndex: 1, endIndex: 4 } { message: 'Invalid expression', startIndex: 12, endIndex: 13 } { message: 'Invalid expression', startIndex: 13, endIndex: 16 }
@@ -107,12 +106,12 @@ Errors:  { message: 'Invalid number', startIndex: 1, endIndex: 4 } { message: 'I
 Input:  -5.5 to 10
 Output:  { operator: '=', values: [ -5.5, 10 ] }
 Errors:  { message: 'Invalid expression', startIndex: 5, endIndex: 7 }
+
 ```
 
+-------------------------------------------------------------------------
 ## Strings
 
-The string parser `string_parser.ts` supports the "string expressions" shown below. `Input` is the input string and `Output` shows the output of `string_parser`. Note that **several examples below are illogical**, and are intended to stress-test the parser.
-
 ```code
 Input:  CAT, DOG,mouse
 Output:  { operator: '=', values: [ 'CAT', 'DOG', 'mouse' ] }
@@ -121,13 +120,14 @@ Input:  -CAT,-DOG , -mouse
 Output:  { operator: '!=', values: [ 'CAT', 'DOG', 'mouse' ] }
 
 Input:   CAT,-"DOG",m o u s e
-Output:  { operator: '=', values: [ 'CAT' ] } { operator: '!=', values: [ '"DOG"' ] } { operator: '=', values: [ 'm o u s e' ] }      
+Output:  { operator: '=', values: [ 'CAT' ] } { operator: '!=', values: [ '"DOG"' ] } { operator: '=', values: [ 'm o u s e' ] }
+Quotes:  DOUBLE
 
 Input:  -CAT,-DOG,mouse, bird, zebra, -horse, -goat
 Output:  { operator: '!=', values: [ 'CAT', 'DOG' ] } { operator: '=', values: [ 'mouse', 'bird', 'zebra' ] } { operator: '!=', values: [ 'horse', 'goat' ] }
 
 Input:  Missing ,NULL
-Output:  { operator: '=', values: [ 'Missing', null ] }
+Output:  { operator: '=', values: [ 'Missing' ] } { operator: 'NULL' }
 
 Input:  CAT%, D%OG, %ous%, %ira_f%, %_oat,
 Output:  { operator: 'starts', values: [ 'CAT' ] } { operator: '~', values: [ 'D%OG' ] } { operator: 'contains', values: [ 'ous' ] } { operator: '~', values: [ '%ira_f%', '%_oat' ] }
@@ -155,28 +155,30 @@ Input:  \_CAT,D\%G,\mouse
 Output:  { operator: '=', values: [ '_CAT', 'D%G', 'mouse' ] }
 
 Input:  CAT,-NULL
-Output:  { operator: '=', values: [ 'CAT' ] } { operator: '!=', values: [ null ] }
+Output:  { operator: '=', values: [ 'CAT' ] } { operator: 'NOTNULL' }
 
 Input:  CAT,-"NULL"
 Output:  { operator: '=', values: [ 'CAT' ] } { operator: '!=', values: [ '"NULL"' ] }
+Quotes:  DOUBLE
 
 Input:  CAT,NULL
-Output:  { operator: '=', values: [ 'CAT', null ] }
+Output:  { operator: '=', values: [ 'CAT' ] } { operator: 'NULL' }
 
 Input:  EMPTY
-Output:  { operator: 'EMPTY', values: [ null ] }
+Output:  { operator: 'EMPTY' }
 
 Input:  -EMPTY
-Output:  { operator: 'NOTEMPTY', values: [ null ] }
+Output:  { operator: 'NOTEMPTY' }
 
 Input:  CAT,-EMPTY
-Output:  { operator: '=', values: [ 'CAT' ] } { operator: 'NOTEMPTY', values: [ null ] }
+Output:  { operator: '=', values: [ 'CAT' ] } { operator: 'NOTEMPTY' }
 
 Input:  "CAT,DOG',mo`use,zeb'''ra,g"""t,g\"ir\`af\'e
 Output:  {
   operator: '=',
   values: [ '"CAT', "DOG'", 'mo`use', "zeb'''ra", 'g"""t', 'g"ir`af\'e' ]
 }
+Quotes:  DOUBLE SINGLE BACKTICK TRIPLESINGLE TRIPLEDOUBLE ESCAPEDDOUBLE ESCAPEDBACKTICK ESCAPEDSINGLE
 
 Input:  CAT\,DOG
 Output:  { operator: '=', values: [ 'CAT,DOG' ] }
@@ -211,22 +213,26 @@ Output:  {
   operator: '=',
   values: [ 'hello world', 'foo="bar baz"', 'qux=quux' ]
 }
+Quotes:  DOUBLE
 
 Input:  one ,Null ,  Empty,E M P T Y Y,EEmpty,        emptIEs
-Output:  { operator: '=', values: [ 'one', null ] } { operator: 'EMPTY', values: [ null ] } { operator: '=', values: [ 'E M P T Y Y', 'EEmpty', 'emptIEs' ] }
+Output:  { operator: '=', values: [ 'one' ] } { operator: 'NULL' } { operator: 'EMPTY' } { operator: '=', values: [ 'E M P T Y Y', 'EEmpty', 'emptIEs' ] }
 
 Input:
+
 ```
 
+-------------------------------------------------------------------------
 ## Booleans
 
-The boolean parser `boolean_parser.ts` supports the "truthy" expressions shown below. `Input` is the input string and `Output` shows the output of `boolean_parser`:
-
 ```code
 Input:  true
 Output:  { operator: 'TRUE' }
 
 Input:  FALSE
+Output:  { operator: 'FALSEORNULL' }
+
+Input:  =false
 Output:  { operator: 'FALSE' }
 
 Input:  null
@@ -235,8 +241,8 @@ Output:  { operator: 'NULL' }
 Input:  -NULL
 Output:  { operator: 'NOTNULL' }
 
-Input:   True , faLSE,NULl,-null
-Output:  { operator: 'TRUE' } { operator: 'FALSE' } { operator: 'NULL' } { operator: 'NOTNULL' }
+Input:   True , faLSE,=false,NULl,-null
+Output:  { operator: 'TRUE' } { operator: 'FALSEORNULL' } { operator: 'FALSE' } { operator: 'NULL' } { operator: 'NOTNULL' }
 
 Input:  -'null'
 Errors:  { message: "Invalid token -'null'", startIndex: 0, endIndex: 7 }
@@ -249,119 +255,181 @@ Errors:  { message: 'Invalid token nnull', startIndex: 0, endIndex: 5 }
 
 Input:   truee
 Errors:  { message: 'Invalid token truee', startIndex: 1, endIndex: 6 }
+
 ```
 
+-------------------------------------------------------------------------
 ## Dates and Times
 
-The date and time parser `date_parser.ts` supports the date and time expressions shown below. `Input` is the input string and `Output` shows the output of `date_parser`. Note that, like with strings above, we include several invalid examples to highlight error responses:
-
 ```code
 Input:  this month
-Output:  { operator: 'THIS', unit: 'MONTH' }
+Output:  {
+  operator: 'ON',
+  moment: { type: 'INTERVAL', kind: 'THIS', unit: 'MONTH' }
+}
 
 Input:  3 days
-Output:  { operator: 'TIMEBLOCK', value: '3', unit: 'DAYS' }
+Output:  { operator: 'DURATION', duration: { amount: 3, unit: 'DAYS' } }
 
 Input:  3 days ago
-Output:  { operator: 'AGO', value: '3', unit: 'DAYS' }
-
-Input:  3 months ago for 2 days
 Output:  {
-  start: { operator: 'AGO', value: '3', unit: 'MONTHS' },
-  operator: 'FOR',
-  end: { operator: 'TIMEBLOCK', value: '2', unit: 'DAYS' }
+  operator: 'ON',
+  moment: {
+    type: 'OFFSET_FROM_NOW',
+    direction: 'AGO',
+    amount: 3,
+    unit: 'DAYS'
+  }
 }
 
-Input:  after 2025 seconds
+Input:  3 months ago for 2 days
 Output:  {
-  operator: 'TIMEBLOCK',
-  value: '2025',
-  unit: 'SECONDS',
-  prefix: 'AFTER'
+  operator: 'FOR_RANGE',
+  from: {
+    type: 'OFFSET_FROM_NOW',
+    direction: 'AGO',
+    amount: 3,
+    unit: 'MONTHS'
+  },
+  duration: { amount: 2, unit: 'DAYS' }
 }
 
 Input:  2025 weeks ago
-Output:  { operator: 'AGO', value: '2025', unit: 'WEEKS' }
+Output:  {
+  operator: 'ON',
+  moment: {
+    type: 'OFFSET_FROM_NOW',
+    direction: 'AGO',
+    amount: 2025,
+    unit: 'WEEKS'
+  }
+}
 
 Input:  before 3 days ago
-Output:  { operator: 'AGO', value: '3', unit: 'DAYS', prefix: 'BEFORE' }
+Output:  {
+  operator: 'BEFORE',
+  moment: {
+    type: 'OFFSET_FROM_NOW',
+    direction: 'AGO',
+    amount: 3,
+    unit: 'DAYS'
+  }
+}
 
 Input:  before 2025-08-30 08:30:20
 Output:  {
-  operator: 'DATETIME',
-  date: '2025-08-30',
-  time: '08:30:20',
-  prefix: 'BEFORE'
+  operator: 'BEFORE',
+  moment: { type: 'ABSOLUTE', date: '2025-08-30 08:30:20', unit: 'SECOND' }
 }
 
 Input:  after 2025-10-05
-Output:  { operator: 'DATE', date: '2025-10-05', prefix: 'AFTER' }
+Output:  {
+  operator: 'AFTER',
+  moment: { type: 'ABSOLUTE', date: '2025-10-05', unit: 'DAY' }
+}
 
-Input:  2025-08-30 12:00:00 to 2025-09-18 14:00:00
+Input:  2025-08-30 12:00 to 2025-09-18 14:30
 Output:  {
-  start: { operator: 'DATETIME', date: '2025-08-30', time: '12:00:00' },
-  operator: 'TO',
-  end: { operator: 'DATETIME', date: '2025-09-18', time: '14:00:00' }
+  operator: 'TO_RANGE',
+  from: { type: 'ABSOLUTE', date: '2025-08-30 12:00', unit: 'MINUTE' },
+  to: { type: 'ABSOLUTE', date: '2025-09-18 14:30', unit: 'MINUTE' }
 }
 
 Input:  this year
-Output:  { operator: 'THIS', unit: 'YEAR' }
+Output:  {
+  operator: 'ON',
+  moment: { type: 'INTERVAL', kind: 'THIS', unit: 'YEAR' }
+}
 
 Input:  next tuesday
-Output:  { operator: 'NEXT', unit: 'TUESDAY' }
+Output:  {
+  operator: 'ON',
+  moment: { type: 'INTERVAL', kind: 'NEXT', unit: 'TUESDAY' }
+}
 
 Input:  7 years from now
-Output:  { operator: 'FROMNOW', value: '7', unit: 'YEARS' }
+Output:  {
+  operator: 'ON',
+  moment: {
+    type: 'OFFSET_FROM_NOW',
+    direction: 'FROMNOW',
+    amount: 7,
+    unit: 'YEARS'
+  }
+}
 
 Input:  2025-01-01 12:00:00 for 3 days
 Output:  {
-  start: { operator: 'DATETIME', date: '2025-01-01', time: '12:00:00' },
-  operator: 'FOR',
-  end: { operator: 'TIMEBLOCK', value: '3', unit: 'DAYS' }
+  operator: 'FOR_RANGE',
+  from: { type: 'ABSOLUTE', date: '2025-01-01 12:00:00', unit: 'SECOND' },
+  duration: { amount: 3, unit: 'DAYS' }
 }
 
 Input:  2020-08-12
-Output:  { operator: 'DATE', date: '2020-08-12' }
+Output:  {
+  operator: 'ON',
+  moment: { type: 'ABSOLUTE', date: '2020-08-12', unit: 'DAY' }
+}
 
 Input:  2020-08
-Output:  { operator: 'DATE', date: '2020-08' }
+Output:  {
+  operator: 'ON',
+  moment: { type: 'ABSOLUTE', date: '2020-08', unit: 'MONTH' }
+}
 
 Input:  today
-Output:  { operator: 'TODAY' }
+Output:  { operator: 'ON', moment: { type: 'NAMED', name: 'TODAY' } }
 
 Input:  yesterday
-Output:  { operator: 'YESTERDAY' }
+Output:  { operator: 'ON', moment: { type: 'NAMED', name: 'YESTERDAY' } }
 
 Input:  tomorrow
-Output:  { operator: 'TOMORROW' }
+Output:  { operator: 'ON', moment: { type: 'NAMED', name: 'TOMORROW' } }
 
 Input:  TODay,Yesterday, TOMORROW , ,TODay ,,
-Output:  { operator: 'TODAY' } { operator: 'YESTERDAY' } { operator: 'TOMORROW' } { operator: 'TODAY' }
+Output:  { operator: 'ON', moment: { type: 'NAMED', name: 'TODAY' } } { operator: 'ON', moment: { type: 'NAMED', name: 'YESTERDAY' } } { operator: 'ON', moment: { type: 'NAMED', name: 'TOMORROW' } } { operator: 'ON', moment: { type: 'NAMED', name: 'TODAY' } }
 
 Input:  2010 to 2011, 2015 to 2016 , 2018, 2020
 Output:  {
-  start: { operator: 'DATE', date: '2010' },
-  operator: 'TO',
-  end: { operator: 'DATE', date: '2011' }
+  operator: 'TO_RANGE',
+  from: { type: 'ABSOLUTE', date: '2010', unit: 'YEAR' },
+  to: { type: 'ABSOLUTE', date: '2011', unit: 'YEAR' }
+} {
+  operator: 'TO_RANGE',
+  from: { type: 'ABSOLUTE', date: '2015', unit: 'YEAR' },
+  to: { type: 'ABSOLUTE', date: '2016', unit: 'YEAR' }
 } {
-  start: { operator: 'DATE', date: '2015' },
-  operator: 'TO',
-  end: { operator: 'DATE', date: '2016' }
-} { operator: 'DATE', date: '2018' } { operator: 'DATE', date: '2020' }
+  operator: 'ON',
+  moment: { type: 'ABSOLUTE', date: '2018', unit: 'YEAR' }
+} {
+  operator: 'ON',
+  moment: { type: 'ABSOLUTE', date: '2020', unit: 'YEAR' }
+}
 
 Input:  next week
-Output:  { operator: 'NEXT', unit: 'WEEK' }
+Output:  {
+  operator: 'ON',
+  moment: { type: 'INTERVAL', kind: 'NEXT', unit: 'WEEK' }
+}
 
 Input:  now
-Output:  { operator: 'NOW' }
+Output:  { operator: 'ON', moment: { type: 'NAMED', name: 'NOW' } }
 
 Input:  now to next month
 Output:  {
-  start: { operator: 'NOW' },
-  operator: 'TO',
-  end: { operator: 'NEXT', unit: 'MONTH' }
+  operator: 'TO_RANGE',
+  from: { type: 'NAMED', name: 'NOW' },
+  to: { type: 'INTERVAL', kind: 'NEXT', unit: 'MONTH' }
 }
 
+Input:  null
+Output:  { operator: 'NULL' }
+Errors:  { message: 'Invalid token NULL', startIndex: 0, endIndex: 4 }
+
+Input:  -null,
+Output:  { operator: 'NOTNULL' }
+Errors:  { message: 'Invalid token -NULL', startIndex: 0, endIndex: 5 }
+
 Input:   yyesterday
 Errors:  { message: 'Invalid token yyesterday', startIndex: 1, endIndex: 11 }
 
@@ -374,8 +442,19 @@ Input:  7
 Errors:  { message: 'Invalid token 7', startIndex: 0, endIndex: 1 }
 
 Input:  from now
-Output:  { operator: 'NOW' }
+Output:  { operator: 'ON', moment: { type: 'NAMED', name: 'NOW' } }
 Errors:  { message: 'Invalid token FROM', startIndex: 0, endIndex: 4 }
 
+Input:  2025-12-25 12:32:
+Output:  {
+  operator: 'ON',
+  moment: { type: 'ABSOLUTE', date: '2025-12-25', unit: 'DAY' }
+}
+Errors:  { message: 'Invalid token 12:32:', startIndex: 11, endIndex: 17 }
+
+Input:  after 2025 seconds
+Errors:  { message: 'Invalid token ', startIndex: 6, endIndex: 18 }
+
 Input:
+
 ```

package/SERIALIZE_SAMPLES.md

@@ -1,16 +1,15 @@
 # Serializers
 
-Each parser has a complementary serializer that converts the structured clause list back to string format.  Below are round-trip samples: `string` to `Clause[]` back to `string`.
-
-Round-trip Examples: 
+Each parser has a complementary serializer that converts the structured clause list back
+to string format.  Below are round-trip samples: `string` to `Clause[]` back to `string`.
+Round-trip Examples:
 
 ```code
     Input  >  parse  >  Clause[]  >  serialize  >  Output
     string                                         string
 ```
 
----
-
+-------------------------------------------------------------------------
 ## Number Serializer
 
 ```code
@@ -20,8 +19,8 @@ Output: 5
 Input:  !=5
 Output: !=5
 
-Input:  1, 3, null , 7
-Output: 1, 3, NULL, 7
+Input:  1, 3, 5, null
+Output: 1, 3, 5, NULL
 
 Input:  <1, >=100
 Output: <1, >=100
@@ -57,8 +56,7 @@ Input:  [0,10], 20, NULL, ( 72, 82 ]
 Output: [0, 10], 20, NULL, (72, 82]
 
 Input:  , notanumber,, "null", apple pear orange, nulle, nnull, >=,
-Errors:  { message: 'Invalid expression', startIndex: 2, endIndex: 12 } { message: 'Invalid expression', startIndex: 15, endIndex: 21 } { message: 'Invalid expression', startIndex: 23, endIndex: 28 } { message: 'Invalid expression', startIndex: 29, endIndex: 33 } { message: 'Invalid expression', startIndex: 34, endIndex: 40 } { message: 'Invalid expression', startIndex: 42, endIndex: 47 } { message:
- 'Invalid expression', startIndex: 49, endIndex: 54 } { message: 'Invalid expression', startIndex: 56, endIndex: 58 }
+Errors:  { message: 'Invalid expression', startIndex: 2, endIndex: 12 } { message: 'Invalid expression', startIndex: 15, endIndex: 21 } { message: 'Invalid expression', startIndex: 23, endIndex: 28 } { message: 'Invalid expression', startIndex: 29, endIndex: 33 } { message: 'Invalid expression', startIndex: 34, endIndex: 40 } { message: 'Invalid expression', startIndex: 42, endIndex: 47 } { message: 'Invalid expression', startIndex: 49, endIndex: 54 } { message: 'Invalid expression', startIndex: 56, endIndex: 58 }
 
 Input:  [cat, 100], <cat
 Errors:  { message: 'Invalid number', startIndex: 1, endIndex: 4 } { message: 'Invalid expression', startIndex: 12, endIndex: 13 } { message: 'Invalid expression', startIndex: 13, endIndex: 16 }
@@ -68,8 +66,7 @@ Output: -5.5, 10
 Errors:  { message: 'Invalid expression', startIndex: 5, endIndex: 7 }
 ```
 
----
-
+-------------------------------------------------------------------------
 ## String Serializer
 
 ```code
@@ -169,10 +166,10 @@ Input:  one ,Null ,  Empty,E M P T Y Y,EEmpty,        emptIEs
 Output: one, NULL, EMPTY, E M P T Y Y, EEmpty, emptIEs
 
 Input:
-```
 
----
+```
 
+-------------------------------------------------------------------------
 ## Boolean Serializer
 
 ```code
@@ -182,14 +179,17 @@ Output: TRUE
 Input:  FALSE
 Output: FALSE
 
+Input:  =false
+Output: =FALSE
+
 Input:  null
 Output: NULL
 
 Input:  -NULL
 Output: -NULL
 
-Input:   True , faLSE,NULl,-null
-Output: TRUE, FALSE, NULL, -NULL
+Input:   True , faLSE,=false,NULl,-null
+Output: TRUE, FALSE, =FALSE, NULL, -NULL
 
 Input:  -'null'
 Errors:  { message: "Invalid token -'null'", startIndex: 0, endIndex: 7 }
@@ -202,11 +202,11 @@ Errors:  { message: 'Invalid token nnull', startIndex: 0, endIndex: 5 }
 
 Input:   truee
 Errors:  { message: 'Invalid token truee', startIndex: 1, endIndex: 6 }
-```
 
----
+```
 
-## Date and Time Serializer
+-------------------------------------------------------------------------
+## Date Serializer
 
 ```code
 Input:  this month
@@ -221,9 +221,6 @@ Output: 3 DAYS AGO
 Input:  3 months ago for 2 days
 Output: 3 MONTHS AGO FOR 2 DAYS
 
-Input:  after 2025 seconds
-Output: AFTER 2025 SECONDS
-
 Input:  2025 weeks ago
 Output: 2025 WEEKS AGO
 
@@ -236,8 +233,8 @@ Output: BEFORE 2025-08-30 08:30:20
 Input:  after 2025-10-05
 Output: AFTER 2025-10-05
 
-Input:  2025-08-30 12:00:00 to 2025-09-18 14:00:00
-Output: 2025-08-30 12:00:00 TO 2025-09-18 14:00:00
+Input:  2025-08-30 12:00 to 2025-09-18 14:30
+Output: 2025-08-30 12:00 TO 2025-09-18 14:30
 
 Input:  this year
 Output: THIS YEAR
@@ -281,6 +278,14 @@ Output: NOW
 Input:  now to next month
 Output: NOW TO NEXT MONTH
 
+Input:  null
+Output: NULL
+Errors:  { message: 'Invalid token NULL', startIndex: 0, endIndex: 4 }
+
+Input:  -null,
+Output: -NULL
+Errors:  { message: 'Invalid token -NULL', startIndex: 0, endIndex: 5 }
+
 Input:   yyesterday
 Errors:  { message: 'Invalid token yyesterday', startIndex: 1, endIndex: 11 }
 
@@ -296,5 +301,13 @@ Input:  from now
 Output: NOW
 Errors:  { message: 'Invalid token FROM', startIndex: 0, endIndex: 4 }
 
+Input:  2025-12-25 12:32:
+Output: 2025-12-25
+Errors:  { message: 'Invalid token 12:32:', startIndex: 11, endIndex: 17 }
+
+Input:  after 2025 seconds
+Errors:  { message: 'Invalid token ', startIndex: 6, endIndex: 18 }
+
 Input:
-```
+
+```

package/dist/boolean_parser.js

@@ -13,7 +13,8 @@ class BooleanParser extends base_parser_1.BaseParser {
             { type: 'NULL', value: 'null', ignoreCase: true },
             { type: 'NOTNULL', value: '-null', ignoreCase: true },
             { type: 'TRUE', value: 'true', ignoreCase: true },
-            { type: 'FALSE', value: 'false', ignoreCase: true },
+            { type: 'FALSE', value: '=false', ignoreCase: true },
+            { type: 'FALSEORNULL', value: 'false', ignoreCase: true },
         ];
         const params = {
             trimWordWhitespace: true,
@@ -38,6 +39,7 @@ class BooleanParser extends base_parser_1.BaseParser {
             else if (token.type === 'NULL' ||
                 token.type === 'TRUE' ||
                 token.type === 'FALSE' ||
+                token.type === 'FALSEORNULL' ||
                 token.type === 'NOTNULL') {
                 const clause = { operator: token.type };
                 clauses.push(clause);