Merge branch 'bugfix/LF-3522/LF-3533/incorrect-string-normalization-and-unicode-escape-parsing' into 'master'

Fix incorrect string normalization and Unicode escape parsing

See merge request lfor/fhirpath.js!60

Author: yuriy-sedinkin

AGENTS.md

@@ -19,6 +19,7 @@
 
 ## Testing workflow (project-specific)
 - Spec-style unit tests are YAML-driven: `test/fhirpath.test.js` loads `test/cases/*.yaml` and generates Jest tests dynamically.
+- `test/cases/fhir-r4.yaml` and `test/cases/fhir-r5.yaml` are generated from `converter/dataset`; refresh them with `node converter/bin/index.js -s` (skip download, use local dataset files).
 - Additional Jest suites in `test/*.test.js` cover APIs and behaviors outside YAML cases (e.g. `test/async-functions.test.js`, `test/user-invocation-table.test.js`, `test/bin_fhirpath.test.js`).
 - Many tests run in both math modes automatically (`preciseMath` true/false) unless a case sets `preciseMath` explicitly.
 - `npm run test:unit` runs Jest three times across time zones (`default`, `America/New_York`, `Europe/Paris`) to catch datetime regressions.
@@ -32,6 +33,7 @@
 - Lint: `npm run lint` (targets `src/parser/index.js`, `src/*.js`, `converter/`).
 - Unit tests: `npm run test:unit`; debugger mode: `npm run test:unit:debug`.
 - Type tests: `npm run test:tsd`.
+- Demo build: `npm run build:demo` (`npm run build` + `demo` webpack build).
 - E2E tests: `npm run test:e2e` (builds demo + runs Cypress).
 - Full CI-like local run: `npm test` (lint + tsd + unit + e2e).
 - Parser regeneration: `npm run generateParser` (uses `src/parser/FHIRPath.g4`, `antlr-4.9.3-complete.jar`, then `scripts/fix-parser-imports.js`).
@@ -55,3 +57,4 @@
 - For async server calls, thread options via `terminologyUrl`, `fhirServerUrl`, `httpHeaders`, and optional `signal` (see `docs/auth.md`, `docs/abort.md`).
 - If public API signatures or exports change, update `src/fhirpath.d.ts` and validate with `npm run test:tsd` (`test/typescript/fhirpath.test-d.ts`).
 - Keep behavior standards-compliant with FHIRPath and aligned with the selected FHIR model version when model-aware behavior is involved.
+- Contributors **MUST NOT** hand-edit `test/cases/fhir-r4.yaml` or `test/cases/fhir-r5.yaml` (these files are generated).

CHANGELOG.md

@@ -3,12 +3,20 @@
 This log documents significant changes for each release.  This project follows
 [Semantic Versioning](http://semver.org/).
 
-## [4.9.3] - 2026-03-27
+## [4.9.3] - 2026-03-31
 ### Changed
+- Updated package repository metadata in `package.json` to an explicit git
+  repository object.
 - `npm run compare-performance` can now use a local git ref as the baseline,
   keeps benchmark labels explicit about previous/current results, and includes a
   dedicated FHIR quantity context benchmark.
 ### Fixed
+- String equivalence and non-equivalence normalization now collapses repeated
+  whitespace globally, so expressions like `'ab   c   d' ~ 'Ab C D'` evaluate as
+  equivalent.
+- Unicode escape parsing in literals now accepts full hex digits for `\uXXXX`
+  (for example, `\u00e9` and `\u00E9`) in both single-quoted strings and
+  backtick-delimited identifiers.
 - FHIR `Quantity` duration values sourced from resources now preserve their
   original UCUM code in string output and quantity math while treated as
   corresponding calendar durations in date/time arithmetic.

demo/package-lock.json

@@ -72,6 +72,9 @@
     "scripts",
     "src"
   ],
-  "repository": "github:HL7/fhirpath.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HL7/fhirpath.js.git"
+  },
   "license": "SEE LICENSE in LICENSE.md"
 }

package-lock.json

@@ -20,12 +20,12 @@ const isArguments = function (object) {
 
 /**
  * Normalizes a string for equivalence comparison by converting to uppercase
- * and collapsing whitespace sequences to a single space.
+ * and replacing every whitespace character with a regular ASCII space.
  * @param {string} x - the string to normalize.
  * @returns {string} the normalized string.
  */
 function normalizeStr(x) {
-  return x.toUpperCase().replace(/\s+/, ' ');
+  return x.toUpperCase().replace(/\p{White_Space}/ug, ' ');
 }
 
 
@@ -61,10 +61,10 @@ function deepEqual(ctx, v1, v2, opts) {
   const typeOfExpected = typeof expected;
 
   if (opts.fuzzy) {
-    if(typeOfActual === 'string' && typeOfExpected === 'string') {
+    if (typeOfActual === 'string' && typeOfExpected === 'string') {
       return normalizeStr(actual) === normalizeStr(expected);
     }
-    if(typeOfActual === 'number' && typeOfExpected === 'number') {
+    if (typeOfActual === 'number' && typeOfExpected === 'number') {
       return numbers.isEquivalent(actual, expected);
     }
   }
@@ -81,6 +81,7 @@ function deepEqual(ctx, v1, v2, opts) {
         //           deepEqual(ctx, v1._data, v2._data, opts) : true);
         // If this ever becomes possible, the above code should be used instead
         // of the code below.
+        // noinspection EqualityComparisonWithCoercionJS
         return actual == expected;
       } else if (typeOfExpected === 'number') {
         // Note: currently, a resource node with a direct number value is not
@@ -104,6 +105,7 @@ function deepEqual(ctx, v1, v2, opts) {
       //           deepEqual(ctx, v1._data, v2._data, opts) : true);
       // If this ever becomes possible, the above code should be used instead
       // of the code below.
+      // noinspection EqualityComparisonWithCoercionJS
       return actual == expected;
     }
   }
@@ -190,7 +192,7 @@ function objEquiv(ctx, a, b, opts) {
   if (a.prototype !== b.prototype) return false;
   //~~~I've managed to break Object.keys through screwy arguments passing.
   //   Converting to array solves the problem.
-  if(isArguments(a) || isArguments(b)) {
+  if (isArguments(a) || isArguments(b)) {
     a = isArguments(a) ? pSlice.call(a) : a;
     b = isArguments(b) ? pSlice.call(b) : b;
     return deepEqual(ctx, a, b, opts);

package.json

@@ -450,7 +450,7 @@ function getIdentifierVal(str) {
  * @return {string}
  */
 function handleStringEscapes(str) {
-  return str.replace(/\\(u\d{4}|.)/g, function(match, submatch) {
+  return str.replace(/\\(u[0-9a-fA-F]{4}|.)/g, function(match, submatch) {
     switch (match) {
       case '\\r':
         return '\r';
@@ -462,7 +462,7 @@ function handleStringEscapes(str) {
         return '\f';
       default:
         if (submatch.length > 1) {
-          return String.fromCharCode('0x' + submatch.slice(1));
+          return String.fromCharCode(parseInt(submatch.slice(1), 16));
         }
         return submatch;
     }

src/deep-equal.js

@@ -28,6 +28,7 @@ const availableTests = [
   'addition',
   'gln-validation-expression',
   'comparison',
+  'equivalence',
   'contains',
   'descendants',
   'distinct',

src/fhirpath.js

@@ -1,30 +1,28 @@
-const _ = require('lodash');
-
 module.exports = ({
                     options
                   }) => {
 
-  const expression = "1 < 2";
+  const simpleExpression = "1 < 2";
 
   return [
     ...(options.compileOnly
       ? []
       : [{
         name: `Do simple comparison 1 < 2 using evaluate()`,
         filename: 'comparison-evaluate',
-        expression,
+        expression: simpleExpression,
         cases: [{
           name: '',
           testFunction: (fhirpath, model) => {
-            return () => fhirpath.evaluate({}, expression, {}, model);
+            return () => fhirpath.evaluate({}, simpleExpression, {}, model);
           }
         }
         ]
       }]),
     {
       name: `Do simple comparison 1 < 2 using compile()`,
       filename: 'comparison-compile',
-      expression,
+      expression: simpleExpression,
       cases: [
         {
           name: '',

test/benchmark.js

@@ -0,0 +1,34 @@
+module.exports = ({
+                    options
+                  }) => {
+
+  const whitespaceEquivalenceExpression = "'ab\tc\td' ~ 'Ab C D'";
+
+  return [
+    ...(options.compileOnly
+      ? []
+      : [{
+        name: 'Equivalence with repeated whitespace using evaluate()',
+        filename: 'equivalence-evaluate',
+        expression: whitespaceEquivalenceExpression,
+        cases: [{
+          name: '',
+          testFunction: (fhirpath, model) => {
+            return () => fhirpath.evaluate({}, whitespaceEquivalenceExpression, {}, model);
+          }
+        }]
+      }]),
+    {
+      name: 'Equivalence with repeated whitespace using compile()',
+      filename: 'equivalence-compile',
+      expression: whitespaceEquivalenceExpression,
+      cases: [{
+        name: '',
+        testFunction: (fhirpath, model, compiledFn) => {
+          return () => compiledFn({}, {});
+        }
+      }]
+    }];
+
+}
+