@dynatrace/strato-components 3.10.4 → 3.11.1

package/esm/filters/filter-field/parser/character-codes.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/filters/filter-field/parser/character-codes.ts"],
-  "sourcesContent": ["export const characterCodes = {\n  EOF: -1,\n  SPACE: 32,\n  BANG: 33,\n  DOUBLEQUOTE: 34,\n  DOLLAR: 36,\n  OPENING_BRACKET: 40,\n  CLOSING_BRACKET: 41,\n  ASTERISK: 42,\n  COMMA: 44,\n  DASH: 45,\n  DOT: 46,\n  EQUALS: 61,\n  SQUARE_OPENING_BRACKET: 91,\n  BACKSLASH: 92,\n  TILDE: 126,\n};\n\nexport const durationUnitChars = ['n', 's', 'm', 'h', 'd'];\n"],
-  "mappings": "AAAO,MAAM,iBAAiB;AAAA,EAC5B,KAAK;AAAA,EACL,OAAO;AAAA,EACP,MAAM;AAAA,EACN,aAAa;AAAA,EACb,QAAQ;AAAA,EACR,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM;AAAA,EACN,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,wBAAwB;AAAA,EACxB,WAAW;AAAA,EACX,OAAO;AACT;AAEO,MAAM,oBAAoB,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG;",
+  "sourcesContent": ["export const characterCodes = {\n  EOF: -1,\n  NEWLINE: 10,\n  SPACE: 32,\n  BANG: 33,\n  DOUBLEQUOTE: 34,\n  DOLLAR: 36,\n  OPENING_BRACKET: 40,\n  CLOSING_BRACKET: 41,\n  ASTERISK: 42,\n  COMMA: 44,\n  DASH: 45,\n  DOT: 46,\n  LESS_THAN: 60,\n  EQUALS: 61,\n  GREATER_THAN: 62,\n  SQUARE_OPENING_BRACKET: 91,\n  BACKSLASH: 92,\n  TILDE: 126,\n};\n\nexport const durationUnitChars = ['n', 's', 'm', 'h', 'd'];\n"],
+  "mappings": "AAAO,MAAM,iBAAiB;AAAA,EAC5B,KAAK;AAAA,EACL,SAAS;AAAA,EACT,OAAO;AAAA,EACP,MAAM;AAAA,EACN,aAAa;AAAA,EACb,QAAQ;AAAA,EACR,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM;AAAA,EACN,KAAK;AAAA,EACL,WAAW;AAAA,EACX,QAAQ;AAAA,EACR,cAAc;AAAA,EACd,wBAAwB;AAAA,EACxB,WAAW;AAAA,EACX,OAAO;AACT;AAEO,MAAM,oBAAoB,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG;",
   "names": []
 }

package/esm/filters/filter-field/parser/external-tokenizers/json-path-identifier-tokenizer.js

@@ -1,11 +1,14 @@
 import { ExternalTokenizer } from "@lezer/lr";
 import { characterCodes } from "../character-codes.js";
 import { JsonPathIdentifier } from "../parser.terms.js";
-const { BACKSLASH } = characterCodes;
-const disallowedJsonPathIdentifierChars = new RegExp(/[,()!<>="$:[\]~ .]/);
+const { BACKSLASH, DOUBLEQUOTE } = characterCodes;
+const disallowedJsonPathIdentifierChars = new RegExp(/[,()!<>=:[\]~ .]/);
 const jsonPathIdentifierTokenizer = new ExternalTokenizer(
-  (inputStream, stack) => {
-    if (stack.context.lastToken !== "JsonPathBase" || inputStream.next === -1) {
+  (inputStream) => {
+    if (inputStream.next === -1) {
+      return;
+    }
+    if (inputStream.next === DOUBLEQUOTE) {
       return;
     }
     const start = inputStream.pos;

package/esm/filters/filter-field/parser/external-tokenizers/json-path-identifier-tokenizer.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/filters/filter-field/parser/external-tokenizers/json-path-identifier-tokenizer.ts"],
-  "sourcesContent": ["import { ExternalTokenizer } from '@lezer/lr';\n\nimport { characterCodes } from '../character-codes.js';\nimport { JsonPathIdentifier } from '../parser.terms.js';\n\nconst { BACKSLASH } = characterCodes;\n\nconst disallowedJsonPathIdentifierChars = new RegExp(/[,()!<>=\"$:[\\]~ .]/);\n\n/** @internal */\nexport const jsonPathIdentifierTokenizer = new ExternalTokenizer(\n  (inputStream, stack) => {\n    if (stack.context.lastToken !== 'JsonPathBase' || inputStream.next === -1) {\n      return;\n    }\n\n    const start = inputStream.pos;\n\n    while (\n      !disallowedJsonPathIdentifierChars.test(\n        String.fromCharCode(inputStream.next),\n      ) &&\n      inputStream.next !== -1\n    ) {\n      // If the current character is a backslash (escape character), advance once\n      // more to skip the escaped character.\n      if (inputStream.next === BACKSLASH) {\n        inputStream.advance();\n      }\n\n      // Move on to the next character.\n      inputStream.advance();\n    }\n\n    if (inputStream.pos > start) {\n      inputStream.acceptToken(JsonPathIdentifier);\n    }\n  },\n);\n"],
-  "mappings": "AAAA,SAAS,yBAAyB;AAElC,SAAS,sBAAsB;AAC/B,SAAS,0BAA0B;AAEnC,MAAM,EAAE,UAAU,IAAI;AAEtB,MAAM,oCAAoC,IAAI,OAAO,oBAAoB;AAGlE,MAAM,8BAA8B,IAAI;AAAA,EAC7C,CAAC,aAAa,UAAU;AACtB,QAAI,MAAM,QAAQ,cAAc,kBAAkB,YAAY,SAAS,IAAI;AACzE;AAAA,IACF;AAEA,UAAM,QAAQ,YAAY;AAE1B,WACE,CAAC,kCAAkC;AAAA,MACjC,OAAO,aAAa,YAAY,IAAI;AAAA,IACtC,KACA,YAAY,SAAS,IACrB;AAGA,UAAI,YAAY,SAAS,WAAW;AAClC,oBAAY,QAAQ;AAAA,MACtB;AAGA,kBAAY,QAAQ;AAAA,IACtB;AAEA,QAAI,YAAY,MAAM,OAAO;AAC3B,kBAAY,YAAY,kBAAkB;AAAA,IAC5C;AAAA,EACF;AACF;",
+  "sourcesContent": ["import { ExternalTokenizer } from '@lezer/lr';\n\nimport { characterCodes } from '../character-codes.js';\nimport { JsonPathIdentifier } from '../parser.terms.js';\n\nconst { BACKSLASH, DOUBLEQUOTE } = characterCodes;\n\n// `$`, `*` and `\"` (single quote) are consumed as literal identifier content \u2014 they are flagged as errors\n// later during tree conversion so the whole key stays a single JsonPath token.\nconst disallowedJsonPathIdentifierChars = new RegExp(/[,()!<>=:[\\]~ .]/);\n\n/** @internal */\nexport const jsonPathIdentifierTokenizer = new ExternalTokenizer(\n  (inputStream) => {\n    if (inputStream.next === -1) {\n      return;\n    }\n\n    // Do not start a JsonPathIdentifier on a `\"` \u2014 let the String tokenizer handle it so\n    // `[\"a\"]` continues to parse as a string. A `\"` encountered mid-identifier is instead\n    // consumed as literal content (see the loop below).\n    if (inputStream.next === DOUBLEQUOTE) {\n      return;\n    }\n\n    const start = inputStream.pos;\n\n    while (\n      !disallowedJsonPathIdentifierChars.test(\n        String.fromCharCode(inputStream.next),\n      ) &&\n      inputStream.next !== -1\n    ) {\n      // If the current character is a backslash (escape character), advance once\n      // more to skip the escaped character.\n      if (inputStream.next === BACKSLASH) {\n        inputStream.advance();\n      }\n\n      // Move on to the next character.\n      inputStream.advance();\n    }\n\n    if (inputStream.pos > start) {\n      inputStream.acceptToken(JsonPathIdentifier);\n    }\n  },\n);\n"],
+  "mappings": "AAAA,SAAS,yBAAyB;AAElC,SAAS,sBAAsB;AAC/B,SAAS,0BAA0B;AAEnC,MAAM,EAAE,WAAW,YAAY,IAAI;AAInC,MAAM,oCAAoC,IAAI,OAAO,kBAAkB;AAGhE,MAAM,8BAA8B,IAAI;AAAA,EAC7C,CAAC,gBAAgB;AACf,QAAI,YAAY,SAAS,IAAI;AAC3B;AAAA,IACF;AAKA,QAAI,YAAY,SAAS,aAAa;AACpC;AAAA,IACF;AAEA,UAAM,QAAQ,YAAY;AAE1B,WACE,CAAC,kCAAkC;AAAA,MACjC,OAAO,aAAa,YAAY,IAAI;AAAA,IACtC,KACA,YAAY,SAAS,IACrB;AAGA,UAAI,YAAY,SAAS,WAAW;AAClC,oBAAY,QAAQ;AAAA,MACtB;AAGA,kBAAY,QAAQ;AAAA,IACtB;AAEA,QAAI,YAAY,MAAM,OAAO;AAC3B,kBAAY,YAAY,kBAAkB;AAAA,IAC5C;AAAA,EACF;AACF;",
   "names": []
 }

package/esm/filters/filter-field/parser/external-tokenizers/key-identifier-tokenizer.js

@@ -0,0 +1,17 @@
+import { ExternalTokenizer } from "@lezer/lr";
+import { KeyIdentifier } from "../parser.terms.js";
+import { scanIdentifier } from "../utils/scan-identifier.js";
+const keyIdentifierTokenizer = new ExternalTokenizer((inputStream) => {
+  const offset = scanIdentifier(inputStream, {
+    allowComma: true,
+    stopAtJsonPathBoundary: true
+  });
+  if (offset === 0) {
+    return;
+  }
+  inputStream.acceptToken(KeyIdentifier, offset);
+});
+export {
+  keyIdentifierTokenizer
+};
+//# sourceMappingURL=key-identifier-tokenizer.js.map

package/esm/filters/filter-field/parser/external-tokenizers/key-identifier-tokenizer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/filters/filter-field/parser/external-tokenizers/key-identifier-tokenizer.ts"],
+  "sourcesContent": ["import { ExternalTokenizer } from '@lezer/lr';\n\nimport { KeyIdentifier } from '../parser.terms.js';\nimport { scanIdentifier } from '../utils/scan-identifier.js';\n\n/**\n * Tokenizes the filter key as an identifier that allows a non-leading dollar sign as a literal\n * character (e.g. `json$key = 123`). A leading dollar sign returns `0` to defer to the grammar's\n * `Variable` token. The scanned run stops at a JSONPath boundary (`$.` or `$[`) \u2014 a trailing `$`\n * that begins a JSONPath is left for the grammar's `JsonPathBase` rule to consume. See\n * dev-decisions.md.\n * @internal\n */\nexport const keyIdentifierTokenizer = new ExternalTokenizer((inputStream) => {\n  const offset = scanIdentifier(inputStream, {\n    allowComma: true,\n    stopAtJsonPathBoundary: true,\n  });\n\n  if (offset === 0) {\n    return;\n  }\n\n  inputStream.acceptToken(KeyIdentifier, offset);\n});\n"],
+  "mappings": "AAAA,SAAS,yBAAyB;AAElC,SAAS,qBAAqB;AAC9B,SAAS,sBAAsB;AAUxB,MAAM,yBAAyB,IAAI,kBAAkB,CAAC,gBAAgB;AAC3E,QAAM,SAAS,eAAe,aAAa;AAAA,IACzC,YAAY;AAAA,IACZ,wBAAwB;AAAA,EAC1B,CAAC;AAED,MAAI,WAAW,GAAG;AAChB;AAAA,EACF;AAEA,cAAY,YAAY,eAAe,MAAM;AAC/C,CAAC;",
+  "names": []
+}

package/esm/filters/filter-field/parser/external-tokenizers/list-identifier-tokenizer.js

@@ -0,0 +1,22 @@
+import { ExternalTokenizer } from "@lezer/lr";
+import { ListBoolean, ListIdentifier } from "../parser.terms.js";
+import { getTextFromStream } from "../utils/get-text-from-stream.js";
+import { scanIdentifier } from "../utils/scan-identifier.js";
+const listIdentifierTokenizer = new ExternalTokenizer((inputStream) => {
+  const offset = scanIdentifier(inputStream, {
+    allowComma: false,
+    stopAtJsonPathBoundary: false
+  });
+  if (offset === 0) {
+    return;
+  }
+  const text = getTextFromStream(inputStream, offset);
+  inputStream.acceptToken(
+    text === "true" || text === "false" ? ListBoolean : ListIdentifier,
+    offset
+  );
+});
+export {
+  listIdentifierTokenizer
+};
+//# sourceMappingURL=list-identifier-tokenizer.js.map

package/esm/filters/filter-field/parser/external-tokenizers/list-identifier-tokenizer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/filters/filter-field/parser/external-tokenizers/list-identifier-tokenizer.ts"],
+  "sourcesContent": ["import { ExternalTokenizer } from '@lezer/lr';\n\nimport { ListBoolean, ListIdentifier } from '../parser.terms.js';\nimport { getTextFromStream } from '../utils/get-text-from-stream.js';\nimport { scanIdentifier } from '../utils/scan-identifier.js';\n\n/**\n * Tokenizes the identifier-like text of a `ListValue`, allowing a non-leading dollar sign as a\n * literal character (unlike the grammar's `Identifier`, which treats it as reserved everywhere).\n * Comma stays a terminator here, since it is still the list separator. See dev-decisions.md.\n * @internal\n */\nexport const listIdentifierTokenizer = new ExternalTokenizer((inputStream) => {\n  const offset = scanIdentifier(inputStream, {\n    allowComma: false,\n    stopAtJsonPathBoundary: false,\n  });\n\n  if (offset === 0) {\n    return;\n  }\n\n  const text = getTextFromStream(inputStream, offset);\n\n  inputStream.acceptToken(\n    text === 'true' || text === 'false' ? ListBoolean : ListIdentifier,\n    offset,\n  );\n});\n"],
+  "mappings": "AAAA,SAAS,yBAAyB;AAElC,SAAS,aAAa,sBAAsB;AAC5C,SAAS,yBAAyB;AAClC,SAAS,sBAAsB;AAQxB,MAAM,0BAA0B,IAAI,kBAAkB,CAAC,gBAAgB;AAC5E,QAAM,SAAS,eAAe,aAAa;AAAA,IACzC,YAAY;AAAA,IACZ,wBAAwB;AAAA,EAC1B,CAAC;AAED,MAAI,WAAW,GAAG;AAChB;AAAA,EACF;AAEA,QAAM,OAAO,kBAAkB,aAAa,MAAM;AAElD,cAAY;AAAA,IACV,SAAS,UAAU,SAAS,UAAU,cAAc;AAAA,IACpD;AAAA,EACF;AACF,CAAC;",
+  "names": []
+}

package/esm/filters/filter-field/parser/external-tokenizers/text-tokenizer.js

@@ -21,7 +21,7 @@ const {
   SPACE
 } = characterCodes;
 const matchDefaultCharacter = new RegExp(
-  `(?:[^${RESERVED_CHARACTERS}aoin]|\\s)+`,
+  `(?:[^${RESERVED_CHARACTERS}$aoin]|\\s)+`,
   "i"
 );
 const lastTokenizationEndIndexCache = /* @__PURE__ */ new WeakMap();

package/esm/filters/filter-field/parser/external-tokenizers/text-tokenizer.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/filters/filter-field/parser/external-tokenizers/text-tokenizer.ts"],
-  "sourcesContent": ["import { ExternalTokenizer, type Stack } from '@lezer/lr';\n\nimport { RESERVED_CHARACTERS } from '../../utils/escape-suggestion.js';\nimport { characterCodes } from '../character-codes.js';\nimport { filterFieldKeywords } from '../keywords.js';\nimport {\n  FreeText,\n  InvalidIdentifier,\n  String as StringToken,\n} from '../parser.terms.js';\nimport { tokenizeString } from './string-tokenizer.js';\nimport { advanceAndAcceptFreeText } from '../utils/accept-free-text.js';\nimport { getTextFromStream } from '../utils/get-text-from-stream.js';\nimport { matchCharacterSequence } from '../utils/match-character-sequence.js';\n\nconst {\n  BACKSLASH,\n  CLOSING_BRACKET,\n  DOLLAR,\n  DOUBLEQUOTE,\n  EOF,\n  OPENING_BRACKET,\n  SPACE,\n} = characterCodes;\n\nconst matchDefaultCharacter = new RegExp(\n  `(?:[^${RESERVED_CHARACTERS}aoin]|\\\\s)+`,\n  'i',\n);\n\nconst lastTokenizationEndIndexCache = new WeakMap<Stack, number>();\nconst endFreeText = [OPENING_BRACKET, CLOSING_BRACKET];\n\n/** @internal */\nexport const textTokenizer = new ExternalTokenizer((inputStream, stack) => {\n  const lastTokenizationEndIndex =\n    lastTokenizationEndIndexCache.get(stack) ?? 0;\n\n  // Reset the last tokenized index when reaching the end of the input stream and return;\n  if (inputStream.next === -1) {\n    lastTokenizationEndIndexCache.set(stack, 0);\n    return;\n  }\n\n  // We already checked all characters until the last end index and can return if the stream is not there yet.\n  if (stack.pos < lastTokenizationEndIndex) {\n    return;\n  }\n\n  if (\n    stack.context.lastToken === 'ComparisonOperator' &&\n    inputStream.next === DOLLAR\n  ) {\n    let nextChar = inputStream.peek(1);\n\n    if (\n      nextChar === EOF ||\n      nextChar === SPACE ||\n      nextChar === OPENING_BRACKET\n    ) {\n      if (nextChar === SPACE) {\n        let nextOffset = 2;\n        nextChar = inputStream.peek(nextOffset);\n        while (nextChar !== EOF && nextChar === SPACE) {\n          nextOffset += 1;\n          nextChar = inputStream.peek(nextOffset);\n        }\n\n        if (nextChar === EOF) {\n          inputStream.acceptToken(FreeText, nextOffset);\n          return;\n        }\n      }\n\n      inputStream.acceptToken(InvalidIdentifier, 1);\n      return;\n    }\n  }\n\n  // A free text token may overlap with a string token. In order to accept the correct token,\n  // we need to store whether we started tokenizing a string already.\n  let startedStringTokenization = false;\n  // Variable for tracking how far we looked ahead already.\n  let offset = 0;\n\n  // Token starts with doublequotes, may be a string.\n  if (inputStream.next === DOUBLEQUOTE) {\n    const { token, offset: stringOffset } = tokenizeString(\n      inputStream,\n      stack,\n      lastTokenizationEndIndexCache,\n    );\n    offset = stringOffset;\n\n    if (token === 'string') {\n      return;\n    } else if (token === 'indeterminate') {\n      startedStringTokenization = true;\n    }\n  }\n\n  // If we already started detecting a JSONPath, a free text can't be valid at this point.\n  if (stack.context.lastToken === 'JsonPathBase') {\n    return;\n  }\n\n  // If we already started detecting a string, but the next character is a doublequote again, we\n  // can accept everything until this point as free text. Tokenization will continue at the next character\n  // again (the currently evaluated doublequote).\n  // E.g.:\n  // \"\"\"a\" = b\n  // --> \u203A\"\"\u2039\u203A\"a\" = b\u2039\n  if (\n    startedStringTokenization &&\n    (inputStream.peek(offset) === DOUBLEQUOTE ||\n      inputStream.peek(offset) === -1)\n  ) {\n    inputStream.acceptToken(FreeText, offset);\n    return;\n  }\n\n  // Free text is only valid if there is no token yet or the previous\n  // expression is complete and we're starting a new expression.\n  // Else, we can hand back over to the parser.\n  if (\n    !(\n      stack.context.lastToken === null ||\n      stack.context.lastToken === 'expression' ||\n      stack.context.validExpression === true\n    )\n  ) {\n    return;\n  }\n\n  // Current numeric representation of the code unit we are checking.\n  let currentCharCode = inputStream.peek(offset);\n  // String representation of the code unit we are checking.\n  let currentCharacter = String.fromCharCode(currentCharCode);\n\n  let excludePreviousToken = false;\n\n  // A leading space should only be inlcuded in the free text if there is no token yet to avoid\n  // highlighting the automatically added edit-mode space as an incomplete statement.\n  if (\n    currentCharCode === SPACE &&\n    stack.context.lastToken !== null &&\n    !startedStringTokenization\n  ) {\n    return;\n  }\n\n  // Whether a keyword has been matched. If so, we can advance the stream until after the keyword\n  // so we don't start with matching the keyword when the tokenizer is invoked the next time.\n  let matchedKeyword = false;\n\n  // Increase the offset as long as a free text may still be valid.\n  while (currentCharCode > -1) {\n    // Include escaped character.\n    if (currentCharCode === BACKSLASH) {\n      // The offset can be increased an additional time to include both the escape character\n      // and the escaped character.\n      offset += 1;\n      peekNext();\n      continue;\n    }\n\n    // End free text tokenization if the current character is included in the\n    // list of characters terminating a free text.\n    if (endFreeText.includes(currentCharCode)) {\n      break;\n    }\n\n    // If the current code unit matches a doublequote, we can abort the free text tokenization since it\n    // should be handled in a subsequent tokenization as a potential string token.\n    if (currentCharCode === DOUBLEQUOTE) {\n      const { token, offset: stringOffset } = tokenizeString(\n        inputStream,\n        stack,\n        lastTokenizationEndIndexCache,\n        offset,\n      );\n\n      if (token === 'json') {\n        inputStream.acceptTokenTo(FreeText, offset);\n        break;\n      } else if (token === 'string') {\n        const textBeforeString = getTextFromStream(inputStream, offset);\n\n        // Ignore preceding spaces to avoid splitting up a filter starting with a space\n        // into multiple statements.\n        // E.g. \u203A \"foo\" = bar\u2039 the leading space should be ignored.\n        if (textBeforeString.length > 0 && textBeforeString.trim() === '') {\n          // If there's only spaces before, advance the stream to start the next\n          // tokenization only after the spaces.\n          inputStream.advance(offset);\n          return;\n        }\n\n        lastTokenizationEndIndexCache.set(stack, stringOffset);\n        inputStream.acceptTokenTo(StringToken, stringOffset);\n        break;\n      } else {\n        offset = stringOffset;\n        peekNext();\n      }\n    }\n\n    // If the current character matches any normal character, include it in the free text token and move on.\n    if (matchDefaultCharacter.test(currentCharacter)) {\n      peekNext();\n      continue;\n    }\n\n    // If any other character is encountered (special character, starting character of keywords), we only\n    // continue a free text token under certain conditions...\n    const {\n      keyword: matchString,\n      needsFilterKey,\n      leading,\n      trailing,\n    } = filterFieldKeywords[currentCharacter.toLowerCase()] ?? {};\n\n    // If the current character starts a keyword, check if a keyword actually matches.\n    // If yes, stop matching free text.\n    if (\n      matchString !== undefined &&\n      matchCharacterSequence({\n        inputStream,\n        offset,\n        characterSequence: matchString,\n        leading,\n        trailing,\n      })\n    ) {\n      matchedKeyword = true;\n      excludePreviousToken = !!needsFilterKey;\n\n      // If there are no characters prior to the matched keyword, we include the character in the free text\n      // even though a filter key is not present.\n      // E.g.:\n      // =a --> = would need a key. We are still at 0 offset. So we include it in the free text after all.\n      if (needsFilterKey && offset === 0) {\n        excludePreviousToken = false;\n        peekNext();\n        continue;\n      }\n\n      // If a keyword matched, abort matching free text.\n      break;\n    }\n\n    // We did check for a keyword and special characters, but no matches were found -> we can include\n    // the current character in the free text and continue to the next.\n    peekNext();\n  }\n\n  if (offset > 0 || startedStringTokenization) {\n    lastTokenizationEndIndexCache.set(\n      stack,\n      lastTokenizationEndIndex + offset + (matchedKeyword ? 1 : 0),\n    );\n    advanceAndAcceptFreeText(\n      inputStream,\n      stack,\n      offset,\n      startedStringTokenization,\n      lastTokenizationEndIndexCache,\n      excludePreviousToken,\n    );\n  }\n\n  /** Set all variables needed to determine whether we should continue checking for a FreeText node. */\n  function peekNext() {\n    offset += 1;\n    currentCharCode = inputStream.peek(offset);\n    currentCharacter = String.fromCharCode(currentCharCode);\n  }\n});\n"],
+  "sourcesContent": ["import { ExternalTokenizer, type Stack } from '@lezer/lr';\n\nimport { RESERVED_CHARACTERS } from '../../utils/escape-suggestion.js';\nimport { characterCodes } from '../character-codes.js';\nimport { filterFieldKeywords } from '../keywords.js';\nimport {\n  FreeText,\n  InvalidIdentifier,\n  String as StringToken,\n} from '../parser.terms.js';\nimport { tokenizeString } from './string-tokenizer.js';\nimport { advanceAndAcceptFreeText } from '../utils/accept-free-text.js';\nimport { getTextFromStream } from '../utils/get-text-from-stream.js';\nimport { matchCharacterSequence } from '../utils/match-character-sequence.js';\n\nconst {\n  BACKSLASH,\n  CLOSING_BRACKET,\n  DOLLAR,\n  DOUBLEQUOTE,\n  EOF,\n  OPENING_BRACKET,\n  SPACE,\n} = characterCodes;\n\nconst matchDefaultCharacter = new RegExp(\n  `(?:[^${RESERVED_CHARACTERS}$aoin]|\\\\s)+`,\n  'i',\n);\n\nconst lastTokenizationEndIndexCache = new WeakMap<Stack, number>();\nconst endFreeText = [OPENING_BRACKET, CLOSING_BRACKET];\n\n/** @internal */\nexport const textTokenizer = new ExternalTokenizer((inputStream, stack) => {\n  const lastTokenizationEndIndex =\n    lastTokenizationEndIndexCache.get(stack) ?? 0;\n\n  // Reset the last tokenized index when reaching the end of the input stream and return;\n  if (inputStream.next === -1) {\n    lastTokenizationEndIndexCache.set(stack, 0);\n    return;\n  }\n\n  // We already checked all characters until the last end index and can return if the stream is not there yet.\n  if (stack.pos < lastTokenizationEndIndex) {\n    return;\n  }\n\n  if (\n    stack.context.lastToken === 'ComparisonOperator' &&\n    inputStream.next === DOLLAR\n  ) {\n    let nextChar = inputStream.peek(1);\n\n    if (\n      nextChar === EOF ||\n      nextChar === SPACE ||\n      nextChar === OPENING_BRACKET\n    ) {\n      if (nextChar === SPACE) {\n        let nextOffset = 2;\n        nextChar = inputStream.peek(nextOffset);\n        while (nextChar !== EOF && nextChar === SPACE) {\n          nextOffset += 1;\n          nextChar = inputStream.peek(nextOffset);\n        }\n\n        if (nextChar === EOF) {\n          inputStream.acceptToken(FreeText, nextOffset);\n          return;\n        }\n      }\n\n      inputStream.acceptToken(InvalidIdentifier, 1);\n      return;\n    }\n  }\n\n  // A free text token may overlap with a string token. In order to accept the correct token,\n  // we need to store whether we started tokenizing a string already.\n  let startedStringTokenization = false;\n  // Variable for tracking how far we looked ahead already.\n  let offset = 0;\n\n  // Token starts with doublequotes, may be a string.\n  if (inputStream.next === DOUBLEQUOTE) {\n    const { token, offset: stringOffset } = tokenizeString(\n      inputStream,\n      stack,\n      lastTokenizationEndIndexCache,\n    );\n    offset = stringOffset;\n\n    if (token === 'string') {\n      return;\n    } else if (token === 'indeterminate') {\n      startedStringTokenization = true;\n    }\n  }\n\n  // If we already started detecting a JSONPath, a free text can't be valid at this point.\n  if (stack.context.lastToken === 'JsonPathBase') {\n    return;\n  }\n\n  // If we already started detecting a string, but the next character is a doublequote again, we\n  // can accept everything until this point as free text. Tokenization will continue at the next character\n  // again (the currently evaluated doublequote).\n  // E.g.:\n  // \"\"\"a\" = b\n  // --> \u203A\"\"\u2039\u203A\"a\" = b\u2039\n  if (\n    startedStringTokenization &&\n    (inputStream.peek(offset) === DOUBLEQUOTE ||\n      inputStream.peek(offset) === -1)\n  ) {\n    inputStream.acceptToken(FreeText, offset);\n    return;\n  }\n\n  // Free text is only valid if there is no token yet or the previous\n  // expression is complete and we're starting a new expression.\n  // Else, we can hand back over to the parser.\n  if (\n    !(\n      stack.context.lastToken === null ||\n      stack.context.lastToken === 'expression' ||\n      stack.context.validExpression === true\n    )\n  ) {\n    return;\n  }\n\n  // Current numeric representation of the code unit we are checking.\n  let currentCharCode = inputStream.peek(offset);\n  // String representation of the code unit we are checking.\n  let currentCharacter = String.fromCharCode(currentCharCode);\n\n  let excludePreviousToken = false;\n\n  // A leading space should only be inlcuded in the free text if there is no token yet to avoid\n  // highlighting the automatically added edit-mode space as an incomplete statement.\n  if (\n    currentCharCode === SPACE &&\n    stack.context.lastToken !== null &&\n    !startedStringTokenization\n  ) {\n    return;\n  }\n\n  // Whether a keyword has been matched. If so, we can advance the stream until after the keyword\n  // so we don't start with matching the keyword when the tokenizer is invoked the next time.\n  let matchedKeyword = false;\n\n  // Increase the offset as long as a free text may still be valid.\n  while (currentCharCode > -1) {\n    // Include escaped character.\n    if (currentCharCode === BACKSLASH) {\n      // The offset can be increased an additional time to include both the escape character\n      // and the escaped character.\n      offset += 1;\n      peekNext();\n      continue;\n    }\n\n    // End free text tokenization if the current character is included in the\n    // list of characters terminating a free text.\n    if (endFreeText.includes(currentCharCode)) {\n      break;\n    }\n\n    // If the current code unit matches a doublequote, we can abort the free text tokenization since it\n    // should be handled in a subsequent tokenization as a potential string token.\n    if (currentCharCode === DOUBLEQUOTE) {\n      const { token, offset: stringOffset } = tokenizeString(\n        inputStream,\n        stack,\n        lastTokenizationEndIndexCache,\n        offset,\n      );\n\n      if (token === 'json') {\n        inputStream.acceptTokenTo(FreeText, offset);\n        break;\n      } else if (token === 'string') {\n        const textBeforeString = getTextFromStream(inputStream, offset);\n\n        // Ignore preceding spaces to avoid splitting up a filter starting with a space\n        // into multiple statements.\n        // E.g. \u203A \"foo\" = bar\u2039 the leading space should be ignored.\n        if (textBeforeString.length > 0 && textBeforeString.trim() === '') {\n          // If there's only spaces before, advance the stream to start the next\n          // tokenization only after the spaces.\n          inputStream.advance(offset);\n          return;\n        }\n\n        lastTokenizationEndIndexCache.set(stack, stringOffset);\n        inputStream.acceptTokenTo(StringToken, stringOffset);\n        break;\n      } else {\n        offset = stringOffset;\n        peekNext();\n      }\n    }\n\n    // If the current character matches any normal character, include it in the free text token and move on.\n    if (matchDefaultCharacter.test(currentCharacter)) {\n      peekNext();\n      continue;\n    }\n\n    // If any other character is encountered (special character, starting character of keywords), we only\n    // continue a free text token under certain conditions...\n    const {\n      keyword: matchString,\n      needsFilterKey,\n      leading,\n      trailing,\n    } = filterFieldKeywords[currentCharacter.toLowerCase()] ?? {};\n\n    // If the current character starts a keyword, check if a keyword actually matches.\n    // If yes, stop matching free text.\n    if (\n      matchString !== undefined &&\n      matchCharacterSequence({\n        inputStream,\n        offset,\n        characterSequence: matchString,\n        leading,\n        trailing,\n      })\n    ) {\n      matchedKeyword = true;\n      excludePreviousToken = !!needsFilterKey;\n\n      // If there are no characters prior to the matched keyword, we include the character in the free text\n      // even though a filter key is not present.\n      // E.g.:\n      // =a --> = would need a key. We are still at 0 offset. So we include it in the free text after all.\n      if (needsFilterKey && offset === 0) {\n        excludePreviousToken = false;\n        peekNext();\n        continue;\n      }\n\n      // If a keyword matched, abort matching free text.\n      break;\n    }\n\n    // We did check for a keyword and special characters, but no matches were found -> we can include\n    // the current character in the free text and continue to the next.\n    peekNext();\n  }\n\n  if (offset > 0 || startedStringTokenization) {\n    lastTokenizationEndIndexCache.set(\n      stack,\n      lastTokenizationEndIndex + offset + (matchedKeyword ? 1 : 0),\n    );\n    advanceAndAcceptFreeText(\n      inputStream,\n      stack,\n      offset,\n      startedStringTokenization,\n      lastTokenizationEndIndexCache,\n      excludePreviousToken,\n    );\n  }\n\n  /** Set all variables needed to determine whether we should continue checking for a FreeText node. */\n  function peekNext() {\n    offset += 1;\n    currentCharCode = inputStream.peek(offset);\n    currentCharacter = String.fromCharCode(currentCharCode);\n  }\n});\n"],
   "mappings": "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",
   "names": []
 }

package/esm/filters/filter-field/parser/external-tokenizers/value-identifier-tokenizer.js

@@ -0,0 +1,22 @@
+import { ExternalTokenizer } from "@lezer/lr";
+import { ValueBoolean, ValueIdentifier } from "../parser.terms.js";
+import { getTextFromStream } from "../utils/get-text-from-stream.js";
+import { scanIdentifier } from "../utils/scan-identifier.js";
+const valueIdentifierTokenizer = new ExternalTokenizer((inputStream) => {
+  const offset = scanIdentifier(inputStream, {
+    allowComma: true,
+    stopAtJsonPathBoundary: false
+  });
+  if (offset === 0) {
+    return;
+  }
+  const text = getTextFromStream(inputStream, offset);
+  inputStream.acceptToken(
+    text === "true" || text === "false" ? ValueBoolean : ValueIdentifier,
+    offset
+  );
+});
+export {
+  valueIdentifierTokenizer
+};
+//# sourceMappingURL=value-identifier-tokenizer.js.map

package/esm/filters/filter-field/parser/external-tokenizers/value-identifier-tokenizer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/filters/filter-field/parser/external-tokenizers/value-identifier-tokenizer.ts"],
+  "sourcesContent": ["import { ExternalTokenizer } from '@lezer/lr';\n\nimport { ValueBoolean, ValueIdentifier } from '../parser.terms.js';\nimport { getTextFromStream } from '../utils/get-text-from-stream.js';\nimport { scanIdentifier } from '../utils/scan-identifier.js';\n\n/**\n * Tokenizes the leading identifier-like text of a `FilterSimpleValue`, allowing an unescaped\n * comma and a non-leading dollar sign as literal characters (unlike the grammar's `Identifier`,\n * which is also used for `ListValue`/`FilterKey` and treats both as reserved everywhere). See\n * dev-decisions.md.\n * @internal\n */\nexport const valueIdentifierTokenizer = new ExternalTokenizer((inputStream) => {\n  const offset = scanIdentifier(inputStream, {\n    allowComma: true,\n    stopAtJsonPathBoundary: false,\n  });\n\n  if (offset === 0) {\n    return;\n  }\n\n  const text = getTextFromStream(inputStream, offset);\n\n  inputStream.acceptToken(\n    text === 'true' || text === 'false' ? ValueBoolean : ValueIdentifier,\n    offset,\n  );\n});\n"],
+  "mappings": "AAAA,SAAS,yBAAyB;AAElC,SAAS,cAAc,uBAAuB;AAC9C,SAAS,yBAAyB;AAClC,SAAS,sBAAsB;AASxB,MAAM,2BAA2B,IAAI,kBAAkB,CAAC,gBAAgB;AAC7E,QAAM,SAAS,eAAe,aAAa;AAAA,IACzC,YAAY;AAAA,IACZ,wBAAwB;AAAA,EAC1B,CAAC;AAED,MAAI,WAAW,GAAG;AAChB;AAAA,EACF;AAEA,QAAM,OAAO,kBAAkB,aAAa,MAAM;AAElD,cAAY;AAAA,IACV,SAAS,UAAU,SAAS,UAAU,eAAe;AAAA,IACrD;AAAA,EACF;AACF,CAAC;",
+  "names": []
+}

package/esm/filters/filter-field/parser/external-tokenizers/value-tokenizer.js

@@ -1,11 +1,15 @@
 import { ExternalTokenizer } from "@lezer/lr";
 import { characterCodes, durationUnitChars } from "../character-codes.js";
-import { Duration, Number as NumberToken } from "../parser.terms.js";
+import {
+  Duration,
+  ListBoolean,
+  Number as NumberToken
+} from "../parser.terms.js";
 const { EOF, DASH, SPACE, DOT, COMMA, CLOSING_BRACKET } = characterCodes;
 function isNumber(charCode) {
   return charCode >= 48 && charCode <= 57;
 }
-const valueTokenizer = new ExternalTokenizer((inputStream) => {
+const valueTokenizer = new ExternalTokenizer((inputStream, stack) => {
   const currCharCode = inputStream.peek(0);
   if (!isNumber(currCharCode) && currCharCode !== DASH) {
     return;
@@ -17,22 +21,17 @@ const valueTokenizer = new ExternalTokenizer((inputStream) => {
   let potentialDuration = String.fromCharCode(currCharCode);
   let isPotentialDuration = true;
   let isPotentialNumber = true;
-  while (isNumber(peekCharCode) || peekCharCode === DOT || durationUnitChars.includes(peekChar)) {
+  while (isNumber(peekCharCode) || peekCharCode === DOT || durationUnitChars.includes(peekChar) || peekCharCode === COMMA && isPotentialNumber && !stack.canShift(ListBoolean)) {
+    const isCommaDecimalSeparator = peekCharCode === COMMA;
     if (isNumber(peekCharCode)) {
       potentialNumberChars.push("d");
       potentialDuration += peekChar;
+    } else if (peekCharCode === DOT || isCommaDecimalSeparator) {
+      isPotentialDuration = false;
+      potentialNumberChars.push(isCommaDecimalSeparator ? "," : ".");
     } else if (durationUnitChars.includes(peekChar)) {
       isPotentialNumber = false;
-      if (peekCharCode !== COMMA) {
-        potentialDuration += peekChar;
-      } else {
-        break;
-      }
-    } else if (peekCharCode === DOT) {
-      isPotentialDuration = false;
-      potentialNumberChars.push(peekCharCode === DOT ? "." : ",");
-    } else {
-      console.log("Invalid peek character in value tokenizer.");
+      potentialDuration += peekChar;
     }
     peekPosition += 1;
     peekCharCode = inputStream.peek(peekPosition);
@@ -52,7 +51,7 @@ const valueTokenizer = new ExternalTokenizer((inputStream) => {
     return;
   }
   const potentialNumber = potentialNumberChars.join("");
-  const numberMatch = (/^(d+((\.?)d+)?)$/.exec(potentialNumber) || [])[0];
+  const numberMatch = (/^(d+(\.d+|,d*)?)$/.exec(potentialNumber) || [])[0];
   if (numberMatch?.length !== peekPosition) {
     return;
   }

package/esm/filters/filter-field/parser/external-tokenizers/value-tokenizer.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/filters/filter-field/parser/external-tokenizers/value-tokenizer.ts"],
-  "sourcesContent": ["import { ExternalTokenizer } from '@lezer/lr';\n\nimport { characterCodes, durationUnitChars } from '../character-codes.js';\nimport { Duration, Number as NumberToken } from '../parser.terms.js';\n\nconst { EOF, DASH, SPACE, DOT, COMMA, CLOSING_BRACKET } = characterCodes;\n\nfunction isNumber(charCode: number): boolean {\n  // Numpad key codes are already handled by codemirror.\n  return charCode >= 48 && charCode <= 57;\n}\n\n/** @internal */\nexport const valueTokenizer = new ExternalTokenizer((inputStream) => {\n  const currCharCode = inputStream.peek(0);\n\n  // Character is not a number and not '-' -> definitely not a number / duration.\n  if (!isNumber(currCharCode) && currCharCode !== DASH) {\n    return;\n  }\n\n  // Array of digits and separators (.|,) so we can check if the potential\n  // number actually is a number with the regex at the end.\n  // We already checked the character at the current position, so we can already\n  // add a digit here ('-' doesn't make a difference for the regex).\n  const potentialNumberChars = ['d'];\n\n  let peekPosition = 1;\n  let peekCharCode = inputStream.peek(peekPosition);\n  let peekChar = String.fromCharCode(peekCharCode);\n\n  let potentialDuration = String.fromCharCode(currCharCode);\n  let isPotentialDuration = true;\n  let isPotentialNumber = true;\n\n  // As long as the character is either a digit, '.', or ',', we keep pushing\n  // the characters to the array.\n  while (\n    isNumber(peekCharCode) ||\n    peekCharCode === DOT ||\n    durationUnitChars.includes(peekChar)\n  ) {\n    // With the current character being a number, the token could be either a Duration or Number.\n    if (isNumber(peekCharCode)) {\n      potentialNumberChars.push('d');\n      potentialDuration += peekChar;\n    } else if (durationUnitChars.includes(peekChar)) {\n      // With the current character being included in the duration units,\n      // the only valid token may be a duration. Number can already be ruled out.\n      isPotentialNumber = false;\n      if (peekCharCode !== COMMA) {\n        potentialDuration += peekChar;\n      } else {\n        break;\n      }\n    } else if (peekCharCode === DOT) {\n      // With the current character being a '.', the only valid token may\n      // be a number. Duration can already be ruled out.\n      isPotentialDuration = false;\n\n      potentialNumberChars.push(peekCharCode === DOT ? '.' : ',');\n    } else {\n      // This should never happen.\n      // eslint-disable-next-line no-console\n      console.log('Invalid peek character in value tokenizer.');\n    }\n\n    peekPosition += 1;\n    peekCharCode = inputStream.peek(peekPosition);\n    peekChar = String.fromCharCode(peekCharCode);\n  }\n\n  // Only if the character right after the potential token is either the end of\n  // the input, a space or a closing bracket, the value may be a Number or Duration.\n  // If not, we just return.\n  const charAfterPotentialToken = inputStream.peek(peekPosition);\n  if (\n    peekPosition === 0 ||\n    !(\n      charAfterPotentialToken === EOF ||\n      charAfterPotentialToken === SPACE ||\n      charAfterPotentialToken === CLOSING_BRACKET ||\n      charAfterPotentialToken === COMMA\n    )\n  ) {\n    return;\n  }\n\n  // Duration should have a higher precedence than a number -> check for possibly\n  if (isPotentialDuration) {\n    // check if it matches the regex (one or more digits followed by one of the accepted units)\n    const durationMatch = (/^\\d+(ns|ms|s|m|h|d)$/.exec(potentialDuration) ||\n      [])[0];\n\n    if (durationMatch?.length === peekPosition) {\n      inputStream.acceptToken(Duration, peekPosition);\n    }\n  }\n\n  // If it's not a duration and also not a number, just return and let the grammar take over again.\n  if (!isPotentialNumber) {\n    return;\n  }\n\n  // Simple regex magic to check if the input is a valid number or not.\n  // The regex matches everything with an arbitrary number of digits at the start (at least 1)\n  // followed by optional decimal separator ('.') and 1 to n decimals.\n  // https://regex101.com/r/rfsfrv/2\n\n  const potentialNumber = potentialNumberChars.join('');\n  const numberMatch = (/^(d+((\\.?)d+)?)$/.exec(potentialNumber) || [])[0];\n\n  if (numberMatch?.length !== peekPosition) {\n    return;\n  }\n\n  inputStream.acceptToken(NumberToken, peekPosition);\n});\n"],
-  "mappings": "AAAA,SAAS,yBAAyB;AAElC,SAAS,gBAAgB,yBAAyB;AAClD,SAAS,UAAU,UAAU,mBAAmB;AAEhD,MAAM,EAAE,KAAK,MAAM,OAAO,KAAK,OAAO,gBAAgB,IAAI;AAE1D,SAAS,SAAS,UAA2B;AAE3C,SAAO,YAAY,MAAM,YAAY;AACvC;AAGO,MAAM,iBAAiB,IAAI,kBAAkB,CAAC,gBAAgB;AACnE,QAAM,eAAe,YAAY,KAAK,CAAC;AAGvC,MAAI,CAAC,SAAS,YAAY,KAAK,iBAAiB,MAAM;AACpD;AAAA,EACF;AAMA,QAAM,uBAAuB,CAAC,GAAG;AAEjC,MAAI,eAAe;AACnB,MAAI,eAAe,YAAY,KAAK,YAAY;AAChD,MAAI,WAAW,OAAO,aAAa,YAAY;AAE/C,MAAI,oBAAoB,OAAO,aAAa,YAAY;AACxD,MAAI,sBAAsB;AAC1B,MAAI,oBAAoB;AAIxB,SACE,SAAS,YAAY,KACrB,iBAAiB,OACjB,kBAAkB,SAAS,QAAQ,GACnC;AAEA,QAAI,SAAS,YAAY,GAAG;AAC1B,2BAAqB,KAAK,GAAG;AAC7B,2BAAqB;AAAA,IACvB,WAAW,kBAAkB,SAAS,QAAQ,GAAG;AAG/C,0BAAoB;AACpB,UAAI,iBAAiB,OAAO;AAC1B,6BAAqB;AAAA,MACvB,OAAO;AACL;AAAA,MACF;AAAA,IACF,WAAW,iBAAiB,KAAK;AAG/B,4BAAsB;AAEtB,2BAAqB,KAAK,iBAAiB,MAAM,MAAM,GAAG;AAAA,IAC5D,OAAO;AAGL,cAAQ,IAAI,4CAA4C;AAAA,IAC1D;AAEA,oBAAgB;AAChB,mBAAe,YAAY,KAAK,YAAY;AAC5C,eAAW,OAAO,aAAa,YAAY;AAAA,EAC7C;AAKA,QAAM,0BAA0B,YAAY,KAAK,YAAY;AAC7D,MACE,iBAAiB,KACjB,EACE,4BAA4B,OAC5B,4BAA4B,SAC5B,4BAA4B,mBAC5B,4BAA4B,QAE9B;AACA;AAAA,EACF;AAGA,MAAI,qBAAqB;AAEvB,UAAM,iBAAiB,uBAAuB,KAAK,iBAAiB,KAClE,CAAC,GAAG,CAAC;AAEP,QAAI,eAAe,WAAW,cAAc;AAC1C,kBAAY,YAAY,UAAU,YAAY;AAAA,IAChD;AAAA,EACF;AAGA,MAAI,CAAC,mBAAmB;AACtB;AAAA,EACF;AAOA,QAAM,kBAAkB,qBAAqB,KAAK,EAAE;AACpD,QAAM,eAAe,mBAAmB,KAAK,eAAe,KAAK,CAAC,GAAG,CAAC;AAEtE,MAAI,aAAa,WAAW,cAAc;AACxC;AAAA,EACF;AAEA,cAAY,YAAY,aAAa,YAAY;AACnD,CAAC;",
+  "sourcesContent": ["import { ExternalTokenizer } from '@lezer/lr';\n\nimport { characterCodes, durationUnitChars } from '../character-codes.js';\nimport {\n  Duration,\n  ListBoolean,\n  Number as NumberToken,\n} from '../parser.terms.js';\n\nconst { EOF, DASH, SPACE, DOT, COMMA, CLOSING_BRACKET } = characterCodes;\n\nfunction isNumber(charCode: number): boolean {\n  // Numpad key codes are already handled by codemirror.\n  return charCode >= 48 && charCode <= 57;\n}\n\n/** @internal */\nexport const valueTokenizer = new ExternalTokenizer((inputStream, stack) => {\n  const currCharCode = inputStream.peek(0);\n\n  // Character is not a number and not '-' -> definitely not a number / duration.\n  if (!isNumber(currCharCode) && currCharCode !== DASH) {\n    return;\n  }\n\n  // Array of digits and separators (.|,) so we can check if the potential\n  // number actually is a number with the regex at the end.\n  // We already checked the character at the current position, so we can already\n  // add a digit here ('-' doesn't make a difference for the regex).\n  const potentialNumberChars = ['d'];\n\n  let peekPosition = 1;\n  let peekCharCode = inputStream.peek(peekPosition);\n  let peekChar = String.fromCharCode(peekCharCode);\n\n  let potentialDuration = String.fromCharCode(currCharCode);\n  let isPotentialDuration = true;\n  let isPotentialNumber = true;\n\n  // Consume digits, '.', duration unit chars, and \u2014 outside list context \u2014 commas\n  while (\n    isNumber(peekCharCode) ||\n    peekCharCode === DOT ||\n    durationUnitChars.includes(peekChar) ||\n    (peekCharCode === COMMA &&\n      isPotentialNumber &&\n      !stack.canShift(ListBoolean)) // Only allow commas as decimal separators outside list context.\n  ) {\n    const isCommaDecimalSeparator = peekCharCode === COMMA;\n    // With the current character being a number, the token could be either a Duration or Number.\n    if (isNumber(peekCharCode)) {\n      potentialNumberChars.push('d');\n      potentialDuration += peekChar;\n    } else if (peekCharCode === DOT || isCommaDecimalSeparator) {\n      // Duration cannot have dot or comma as decimal separator\n      isPotentialDuration = false;\n      potentialNumberChars.push(isCommaDecimalSeparator ? ',' : '.');\n    } else if (durationUnitChars.includes(peekChar)) {\n      // With the current character being included in the duration units,\n      // the only valid token may be a duration. Number can already be ruled out.\n      isPotentialNumber = false;\n      potentialDuration += peekChar;\n    }\n\n    peekPosition += 1;\n    peekCharCode = inputStream.peek(peekPosition);\n    peekChar = String.fromCharCode(peekCharCode);\n  }\n\n  // Only if the character right after the potential token is either the end of\n  // the input, a space, a closing bracket or a comma (for list separation), the value may be a Number or Duration.\n  // If not, we just return.\n  const charAfterPotentialToken = inputStream.peek(peekPosition);\n  if (\n    peekPosition === 0 ||\n    !(\n      charAfterPotentialToken === EOF ||\n      charAfterPotentialToken === SPACE ||\n      charAfterPotentialToken === CLOSING_BRACKET ||\n      charAfterPotentialToken === COMMA\n    )\n  ) {\n    return;\n  }\n\n  // Duration should have a higher precedence than a number -> check for possibly\n  if (isPotentialDuration) {\n    // check if it matches the regex (one or more digits followed by one of the accepted units)\n    const durationMatch = (/^\\d+(ns|ms|s|m|h|d)$/.exec(potentialDuration) ||\n      [])[0];\n\n    if (durationMatch?.length === peekPosition) {\n      inputStream.acceptToken(Duration, peekPosition);\n    }\n  }\n\n  // If it's not a duration and also not a number, just return and let the grammar take over again.\n  if (!isPotentialNumber) {\n    return;\n  }\n\n  // Simple regex magic to check if the input is a valid number or not.\n  // The regex matches everything with an arbitrary number of digits at the start (at least 1)\n  // followed by optional decimal separator ('.') and 1 to n decimals.\n  // https://regex101.com/r/rfsfrv/2\n\n  const potentialNumber = potentialNumberChars.join('');\n  const numberMatch = (/^(d+(\\.d+|,d*)?)$/.exec(potentialNumber) || [])[0];\n\n  if (numberMatch?.length !== peekPosition) {\n    return;\n  }\n\n  inputStream.acceptToken(NumberToken, peekPosition);\n});\n"],
+  "mappings": "AAAA,SAAS,yBAAyB;AAElC,SAAS,gBAAgB,yBAAyB;AAClD;AAAA,EACE;AAAA,EACA;AAAA,EACA,UAAU;AAAA,OACL;AAEP,MAAM,EAAE,KAAK,MAAM,OAAO,KAAK,OAAO,gBAAgB,IAAI;AAE1D,SAAS,SAAS,UAA2B;AAE3C,SAAO,YAAY,MAAM,YAAY;AACvC;AAGO,MAAM,iBAAiB,IAAI,kBAAkB,CAAC,aAAa,UAAU;AAC1E,QAAM,eAAe,YAAY,KAAK,CAAC;AAGvC,MAAI,CAAC,SAAS,YAAY,KAAK,iBAAiB,MAAM;AACpD;AAAA,EACF;AAMA,QAAM,uBAAuB,CAAC,GAAG;AAEjC,MAAI,eAAe;AACnB,MAAI,eAAe,YAAY,KAAK,YAAY;AAChD,MAAI,WAAW,OAAO,aAAa,YAAY;AAE/C,MAAI,oBAAoB,OAAO,aAAa,YAAY;AACxD,MAAI,sBAAsB;AAC1B,MAAI,oBAAoB;AAGxB,SACE,SAAS,YAAY,KACrB,iBAAiB,OACjB,kBAAkB,SAAS,QAAQ,KAClC,iBAAiB,SAChB,qBACA,CAAC,MAAM,SAAS,WAAW,GAC7B;AACA,UAAM,0BAA0B,iBAAiB;AAEjD,QAAI,SAAS,YAAY,GAAG;AAC1B,2BAAqB,KAAK,GAAG;AAC7B,2BAAqB;AAAA,IACvB,WAAW,iBAAiB,OAAO,yBAAyB;AAE1D,4BAAsB;AACtB,2BAAqB,KAAK,0BAA0B,MAAM,GAAG;AAAA,IAC/D,WAAW,kBAAkB,SAAS,QAAQ,GAAG;AAG/C,0BAAoB;AACpB,2BAAqB;AAAA,IACvB;AAEA,oBAAgB;AAChB,mBAAe,YAAY,KAAK,YAAY;AAC5C,eAAW,OAAO,aAAa,YAAY;AAAA,EAC7C;AAKA,QAAM,0BAA0B,YAAY,KAAK,YAAY;AAC7D,MACE,iBAAiB,KACjB,EACE,4BAA4B,OAC5B,4BAA4B,SAC5B,4BAA4B,mBAC5B,4BAA4B,QAE9B;AACA;AAAA,EACF;AAGA,MAAI,qBAAqB;AAEvB,UAAM,iBAAiB,uBAAuB,KAAK,iBAAiB,KAClE,CAAC,GAAG,CAAC;AAEP,QAAI,eAAe,WAAW,cAAc;AAC1C,kBAAY,YAAY,UAAU,YAAY;AAAA,IAChD;AAAA,EACF;AAGA,MAAI,CAAC,mBAAmB;AACtB;AAAA,EACF;AAOA,QAAM,kBAAkB,qBAAqB,KAAK,EAAE;AACpD,QAAM,eAAe,oBAAoB,KAAK,eAAe,KAAK,CAAC,GAAG,CAAC;AAEvE,MAAI,aAAa,WAAW,cAAc;AACxC;AAAA,EACF;AAEA,cAAY,YAAY,aAAa,YAAY;AACnD,CAAC;",
   "names": []
 }

package/esm/filters/filter-field/parser/parser-context.js

@@ -16,6 +16,7 @@ const trackTokens = [
   "InclusionOperator",
   "SearchOperator",
   "Identifier",
+  "KeyIdentifier",
   "JsonPathBase",
   "PositionOperator",
   "ClosingBracket",

package/esm/filters/filter-field/parser/parser-context.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/filters/filter-field/parser/parser-context.ts"],
-  "sourcesContent": ["import { ContextTracker, type Stack } from '@lezer/lr';\n\nclass LastAcceptedStatement {\n  lastToken: string | null;\n  pos: number | null;\n  validExpression: boolean | undefined;\n\n  constructor(\n    lastToken: string | null,\n    pos: number | null,\n    validExpression?: boolean,\n  ) {\n    this.lastToken = lastToken;\n    this.pos = pos;\n    this.validExpression = validExpression;\n  }\n}\n\nconst trackTokens = [\n  'expression',\n  'comparison',\n  'ComparisonOperator',\n  'InclusionOperator',\n  'SearchOperator',\n  'Identifier',\n  'JsonPathBase',\n  'PositionOperator',\n  'ClosingBracket',\n  '\",\"',\n];\n\nexport const trackLastToken = new ContextTracker({\n  start: new LastAcceptedStatement(null, null),\n  reduce(context: LastAcceptedStatement, term: number, stack: Stack) {\n    const termName = stack.parser.getName(term);\n\n    if (trackTokens.includes(termName)) {\n      return new LastAcceptedStatement(termName, stack.pos);\n    }\n\n    return context;\n  },\n  shift(context: LastAcceptedStatement, term: number, stack: Stack) {\n    const termName = stack.parser.getName(term);\n\n    // In case an Identifier is being shifted and we already encountered a comparison operator before,\n    // we can assume that we have a valid expression even though it may not yet be reduced.\n    // E.g.:\n    // b =c\"*\"\n    // When at the first doublequote, the previous expression is not yet reduced, but we still want to\n    // accept free text for \"*\". For that to work in combination with trailing position operators, we\n    // store the information that it may be a valid expression separately.\n    if (\n      context.lastToken === 'ComparisonOperator' &&\n      termName === 'Identifier'\n    ) {\n      return new LastAcceptedStatement(context.lastToken, context.pos, true);\n    }\n\n    // Covering an edge-case where a string directly follows a string value.\n    // The second string should be accepted as free text, but the first string is not yet reduced in this case.\n    // E.g.:\n    // a = \"b\"\"c\"\n    if (context.lastToken === 'ComparisonOperator' && termName === 'String') {\n      return new LastAcceptedStatement(termName, stack.pos);\n    }\n\n    if (trackTokens.includes(termName)) {\n      return new LastAcceptedStatement(termName, stack.pos);\n    }\n\n    return context;\n  },\n  strict: false,\n});\n"],
-  "mappings": "AAAA,SAAS,sBAAkC;AAE3C,MAAM,sBAAsB;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YACE,WACA,KACA,iBACA;AACA,SAAK,YAAY;AACjB,SAAK,MAAM;AACX,SAAK,kBAAkB;AAAA,EACzB;AACF;AAEA,MAAM,cAAc;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,MAAM,iBAAiB,IAAI,eAAe;AAAA,EAC/C,OAAO,IAAI,sBAAsB,MAAM,IAAI;AAAA,EAC3C,OAAO,SAAgC,MAAc,OAAc;AACjE,UAAM,WAAW,MAAM,OAAO,QAAQ,IAAI;AAE1C,QAAI,YAAY,SAAS,QAAQ,GAAG;AAClC,aAAO,IAAI,sBAAsB,UAAU,MAAM,GAAG;AAAA,IACtD;AAEA,WAAO;AAAA,EACT;AAAA,EACA,MAAM,SAAgC,MAAc,OAAc;AAChE,UAAM,WAAW,MAAM,OAAO,QAAQ,IAAI;AAS1C,QACE,QAAQ,cAAc,wBACtB,aAAa,cACb;AACA,aAAO,IAAI,sBAAsB,QAAQ,WAAW,QAAQ,KAAK,IAAI;AAAA,IACvE;AAMA,QAAI,QAAQ,cAAc,wBAAwB,aAAa,UAAU;AACvE,aAAO,IAAI,sBAAsB,UAAU,MAAM,GAAG;AAAA,IACtD;AAEA,QAAI,YAAY,SAAS,QAAQ,GAAG;AAClC,aAAO,IAAI,sBAAsB,UAAU,MAAM,GAAG;AAAA,IACtD;AAEA,WAAO;AAAA,EACT;AAAA,EACA,QAAQ;AACV,CAAC;",
+  "sourcesContent": ["import { ContextTracker, type Stack } from '@lezer/lr';\n\nclass LastAcceptedStatement {\n  lastToken: string | null;\n  pos: number | null;\n  validExpression: boolean | undefined;\n\n  constructor(\n    lastToken: string | null,\n    pos: number | null,\n    validExpression?: boolean,\n  ) {\n    this.lastToken = lastToken;\n    this.pos = pos;\n    this.validExpression = validExpression;\n  }\n}\n\nconst trackTokens = [\n  'expression',\n  'comparison',\n  'ComparisonOperator',\n  'InclusionOperator',\n  'SearchOperator',\n  'Identifier',\n  'KeyIdentifier',\n  'JsonPathBase',\n  'PositionOperator',\n  'ClosingBracket',\n  '\",\"',\n];\n\nexport const trackLastToken = new ContextTracker({\n  start: new LastAcceptedStatement(null, null),\n  reduce(context: LastAcceptedStatement, term: number, stack: Stack) {\n    const termName = stack.parser.getName(term);\n\n    if (trackTokens.includes(termName)) {\n      return new LastAcceptedStatement(termName, stack.pos);\n    }\n\n    return context;\n  },\n  shift(context: LastAcceptedStatement, term: number, stack: Stack) {\n    const termName = stack.parser.getName(term);\n\n    // In case an Identifier is being shifted and we already encountered a comparison operator before,\n    // we can assume that we have a valid expression even though it may not yet be reduced.\n    // E.g.:\n    // b =c\"*\"\n    // When at the first doublequote, the previous expression is not yet reduced, but we still want to\n    // accept free text for \"*\". For that to work in combination with trailing position operators, we\n    // store the information that it may be a valid expression separately.\n    if (\n      context.lastToken === 'ComparisonOperator' &&\n      termName === 'Identifier'\n    ) {\n      return new LastAcceptedStatement(context.lastToken, context.pos, true);\n    }\n\n    // Covering an edge-case where a string directly follows a string value.\n    // The second string should be accepted as free text, but the first string is not yet reduced in this case.\n    // E.g.:\n    // a = \"b\"\"c\"\n    if (context.lastToken === 'ComparisonOperator' && termName === 'String') {\n      return new LastAcceptedStatement(termName, stack.pos);\n    }\n\n    if (trackTokens.includes(termName)) {\n      return new LastAcceptedStatement(termName, stack.pos);\n    }\n\n    return context;\n  },\n  strict: false,\n});\n"],
+  "mappings": "AAAA,SAAS,sBAAkC;AAE3C,MAAM,sBAAsB;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YACE,WACA,KACA,iBACA;AACA,SAAK,YAAY;AACjB,SAAK,MAAM;AACX,SAAK,kBAAkB;AAAA,EACzB;AACF;AAEA,MAAM,cAAc;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,MAAM,iBAAiB,IAAI,eAAe;AAAA,EAC/C,OAAO,IAAI,sBAAsB,MAAM,IAAI;AAAA,EAC3C,OAAO,SAAgC,MAAc,OAAc;AACjE,UAAM,WAAW,MAAM,OAAO,QAAQ,IAAI;AAE1C,QAAI,YAAY,SAAS,QAAQ,GAAG;AAClC,aAAO,IAAI,sBAAsB,UAAU,MAAM,GAAG;AAAA,IACtD;AAEA,WAAO;AAAA,EACT;AAAA,EACA,MAAM,SAAgC,MAAc,OAAc;AAChE,UAAM,WAAW,MAAM,OAAO,QAAQ,IAAI;AAS1C,QACE,QAAQ,cAAc,wBACtB,aAAa,cACb;AACA,aAAO,IAAI,sBAAsB,QAAQ,WAAW,QAAQ,KAAK,IAAI;AAAA,IACvE;AAMA,QAAI,QAAQ,cAAc,wBAAwB,aAAa,UAAU;AACvE,aAAO,IAAI,sBAAsB,UAAU,MAAM,GAAG;AAAA,IACtD;AAEA,QAAI,YAAY,SAAS,QAAQ,GAAG;AAClC,aAAO,IAAI,sBAAsB,UAAU,MAAM,GAAG;AAAA,IACtD;AAEA,WAAO;AAAA,EACT;AAAA,EACA,QAAQ;AACV,CAAC;",
   "names": []
 }