@sap/cds-compiler 2.12.0 → 2.13.6

package/lib/render/toCdl.js

@@ -9,12 +9,14 @@ const {
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const { renderFunc, beautifyExprArray, findElement } = require('./utils/common');
+const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
 const { csnRefs } = require('../model/csnRefs');
 const { forEachDefinition } = require('../model/csnUtils');
-const enrichUniversalCsn = require('../transform/universalCsnEnricher');
+const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
 const { isBetaEnabled } = require('../base/model');
+const { ModelError } = require('../base/error');
 
 /**
  * Render the CSN model 'model' to CDS source text. One source is created per
@@ -50,7 +52,7 @@ function toCdsSourceCsn(csn, options) {
 
   forEachDefinition(csn, (artifact, artifactName) => {
     const env = createEnv();
-    const sourceStr = renderArtifact(artifactName, artifact, env); // Must come first because it populates 'env.topLevelAliases'
+    const sourceStr = renderArtifact(artifactName, artifact, env);
     if (sourceStr !== '')
       cdlResult[main] += `${sourceStr}\n`;
   });
@@ -132,7 +134,7 @@ function toCdsSourceCsn(csn, options) {
   if (csn.extensions) {
     const env = createEnv();
     const sourceStr = renderUnappliedExtensions(csn.extensions, env);
-    cdlResult.unappliedExtensions = renderUsings('', env) + sourceStr;
+    cdlResult.unappliedExtensions = sourceStr;
   }
 
   timetrace.stop();
@@ -233,7 +235,6 @@ function toCdsSourceCsn(csn, options) {
 
     switch (art.kind) {
       case 'entity':
-      case 'view':
         if (art.query || art.projection)
           return renderView(artifactName, art, env);
 
@@ -242,8 +243,6 @@ function toCdsSourceCsn(csn, options) {
       case 'context':
       case 'service':
         return renderContext(artifactName, art, env);
-      case 'namespace':
-        return renderNamespace(artifactName, art, env);
       case 'type':
       case 'aspect':
       case 'annotation':
@@ -254,7 +253,7 @@ function toCdsSourceCsn(csn, options) {
       case 'event':
         return renderEventIfCDLMode(artifactName, art, env);
       default:
-        throw new Error(`Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`Unknown artifact kind: ${art.kind}`);
     }
   }
 
@@ -294,37 +293,6 @@ function toCdsSourceCsn(csn, options) {
     return result;
   }
 
-  /**
-   * Return a dictionary with the direct sub-artifacts of the artifact with name 'artifactName' in the csn
-   *
-   * @param {string} artifactName
-   * @return {object}
-   */
-  function getSubArtifacts(artifactName) {
-    const prefix = `${artifactName}.`;
-    const result = Object.create(null);
-    for (const name in csn.definitions) {
-      // We have a direct child if its name starts with prefix and contains no more dots
-      if (name.startsWith(prefix) && !name.substring(prefix.length).includes('.')) {
-        result[getLastPartOf(name)] = csn.definitions[name];
-      }
-      else if (name.startsWith(prefix)) {
-        const prefixPlusNextPart = name.substring(0, name.substring(prefix.length).indexOf('.') + prefix.length);
-        if (csn.definitions[prefixPlusNextPart]) {
-          const art = csn.definitions[prefixPlusNextPart];
-          if (![ 'service', 'context', 'namespace' ].includes(art.kind)) {
-            const nameWithoutPrefix = name.substring(prefix.length);
-            result[nameWithoutPrefix] = csn.definitions[name];
-          }
-        }
-        else {
-          result[name.substring(prefix.length)] = csn.definitions[name];
-        }
-      }
-    }
-    return result;
-  }
-
   /* FIXME: Not yet required
   // Returns the artifact or element that constitutes the final type of
   // construct 'node', i.e. the object in which we would find type properties for
@@ -385,37 +353,6 @@ function toCdsSourceCsn(csn, options) {
     return `${result} {};\n`;
   }
 
-  function updatePrefixForDottedName(env, name) {
-    let innerEnv = env;
-    if (name.indexOf('.') !== -1) {
-      const parts = name.split('.');
-      for (let i = 0; i < parts.length - 1; i++)
-        innerEnv = addNamePrefix(innerEnv, parts[i]);
-    }
-
-    return innerEnv;
-  }
-
-  /**
-   * Render a namespace. Return the resulting source string.
-   *
-   * @param {string} artifactName
-   * @param {CSN.Artifact} art
-   * @param {CdlRenderEnvironment} env
-   * @return {string}
-   */
-  function renderNamespace(artifactName, art, env) {
-    // We currently do not render anything for a namespace, we just append its id to
-    // the environment's current name prefix and descend into its children
-    let result = renderDocComment(art, env);
-    const childEnv = addNamePrefix(env, getLastPartOf(artifactName));
-    const subArtifacts = getSubArtifacts(artifactName);
-    for (const name in subArtifacts)
-      result += renderArtifact(`${artifactName}.${name}`, subArtifacts[name], updatePrefixForDottedName(childEnv, name));
-
-    return result;
-  }
-
   /**
    * Render a (non-projection, non-view) entity. Return the resulting source string.
    *
@@ -446,82 +383,8 @@ function toCdsSourceCsn(csn, options) {
     }
 
     result += `${env.indent}}`;
-    result += `${renderActionsAndFunctions(art, env) + renderTechnicalConfiguration(art.technicalConfig, env)};\n`;
-    return result;
-  }
-
-  // Render the 'technical configuration { ... }' section 'tc' of an entity.
-  // Return the resulting source string.
-  function renderTechnicalConfiguration(tc, env) {
-    let result = renderDocComment(tc, env);
-    const childEnv = increaseIndent(env);
-
-    if (!tc)
-      return result;
-
-
-    // FIXME: How to deal with non-HANA technical configurations? We should probably just iterate all entries
-    // in 'tc' that we find and render them all (is it syntactically allowed yet to have more than one?)
-    tc = tc.hana;
-    if (!tc)
-      throw new Error('Expecting a HANA technical configuration');
-
-    result += `\n${env.indent}technical ${tc.calculated ? '' : 'hana '}configuration {\n`;
-
-    // Store type (must be separate because SQL wants it between 'CREATE' and 'TABLE')
-    if (tc.storeType)
-      result += `${tc.storeType} store;\n`;
-
-    // Fixed parts belonging to the table (includes migration, unload prio, extended storage,
-    // auto merge, partitioning, ...)
-    if (tc.tableSuffix) {
-      // Unlike SQL, CDL and HANA CDS require a semicolon after each table-suffix part
-      // (e.g. `migration enabled; row store; ...`). In order to keep both
-      // the simplicity of "the whole bandwurm is just one expression that can be
-      // rendered to SQL without further knowledge" and at the same time telling
-      // CDS about the boundaries, the compactor has put each part into its own `xpr`
-      // object. Semantically equivalent because a "trivial" SQL renderer would just
-      // concatenate them.
-      for (const xpr of tc.tableSuffix)
-        result += `${childEnv.indent + renderExpr(xpr, childEnv)};\n`;
-    }
-
-    // Indices and full-text indices
-    for (const idxName in tc.indexes || {}) {
-      if (Array.isArray(tc.indexes[idxName][0])) {
-        // FIXME: Should we allow multiple indices with the same name at all?
-        for (const index of tc.indexes[idxName])
-          result += `${childEnv.indent + renderExpr(index, childEnv)};\n`;
-      }
-      else {
-        result += `${childEnv.indent + renderExpr(tc.indexes[idxName], childEnv)};\n`;
-      }
-    }
-    // Fuzzy search indices
-    for (const columnName in tc.fzindexes || {}) {
-      if (Array.isArray(tc.fzindexes[columnName][0])) {
-        // FIXME: Should we allow multiple fuzzy search indices on the same column at all?
-        // And if not, why do we wrap this into an array?
-        for (const index of tc.fzindexes[columnName])
-          result += `${childEnv.indent + renderExpr(fixFuzzyIndex(index, columnName), childEnv)};\n`;
-      }
-      else {
-        result += `${childEnv.indent + renderExpr(fixFuzzyIndex(tc.fzindexes[columnName], columnName), childEnv)};\n`;
-      }
-    }
-    result += `${env.indent}}`;
+    result += `${renderActionsAndFunctions(art, env)};\n`;
     return result;
-
-    // Fuzzy indices are stored in compact CSN as they would appear in SQL after the column name,
-    // i.e. the whole line in SQL looks somewhat like this:
-    //   s nvarchar(10) FUZZY SEARCH INDEX ON FUZZY SEARCH MODE 'ALPHANUM'
-    // But in CDL, we don't write fuzzy search indices together with the table column, so we need
-    // to insert the name of the column after 'ON' in CDS syntax, making it look like this:
-    //   fuzzy search mode on (s) search mode 'ALPHANUM'
-    // This function expects an array with the original expression and returns an array with the modified expression
-    function fixFuzzyIndex(fuzzyIndex, columnName) {
-      return fuzzyIndex.map(token => (token === 'on' ? { xpr: [ 'on', '(', { ref: columnName.split('.') }, ')' ] } : token));
-    }
   }
 
   /**
@@ -561,7 +424,7 @@ function toCdsSourceCsn(csn, options) {
 
     // Sanity checks
     if (!query.SET || !query.SET.args || !query.SET.args[0])
-      throw new Error(`Expecting set with args in query: ${JSON.stringify(query)}`);
+      throw new ModelError(`Expecting set with args in query: ${JSON.stringify(query)}`);
 
     return leadingQuerySelect(query.SET.args[0]);
   }
@@ -620,14 +483,14 @@ function toCdsSourceCsn(csn, options) {
         if (!name.startsWith('@'))
           continue;
 
-        const annotationValue = renderAnnotationValue(elem[name], childEnv);
+        const annotationValue = renderAnnotationAssignment(elem[name], name, childEnv);
         // Skip annotation if column has the same
         if (columnMap[elemName] && columnMap[elemName][name] &&
-            renderAnnotationValue(columnMap[elemName][name], childEnv) === annotationValue)
+          renderAnnotationAssignment(columnMap[elemName][name], name, childEnv) === annotationValue)
           continue;
 
         // Annotation names are never flattened
-        elemAnnotations += `${childEnv.indent}${`@${renderAbsoluteNameWithQuotes(name.substring(1))}`} : ${annotationValue}\n`;
+        elemAnnotations += annotationValue;
       }
       if (elemAnnotations !== '')
         result += `${elemAnnotations}${childEnv.indent}${quoteOrUppercaseId(elemName)};\n`;
@@ -703,7 +566,7 @@ function toCdsSourceCsn(csn, options) {
   function renderAbsolutePath(path, env) {
     // Sanity checks
     if (!path.ref)
-      throw new Error(`Expecting ref in path: ${JSON.stringify(path)}`);
+      throw new ModelError(`Expecting ref in path: ${JSON.stringify(path)}`);
 
 
     // Determine the absolute name of the first artifact on the path (before any associations or element traversals)
@@ -909,6 +772,7 @@ function toCdsSourceCsn(csn, options) {
    * @param {string} syntax The query syntax, either "projection", "entity" or "view"
    * @param {CdlRenderEnvironment} env
    * @param {CSN.Path} [path=[]]
+   * @param {object} [elements]
    */
   function renderQuery(query, isLeadingQuery, syntax, env, path = [], elements = query.elements || Object.create(null)) {
     let result = renderDocComment(query, env);
@@ -935,7 +799,7 @@ function toCdsSourceCsn(csn, options) {
     }
     // Otherwise must have a SELECT
     else if (!query.SELECT) {
-      throw new Error(`Unexpected query operation ${JSON.stringify(query)}`);
+      throw new ModelError(`Unexpected query operation ${JSON.stringify(query)}`);
     }
     const select = query.SELECT;
     const childEnv = increaseIndent(env);
@@ -945,7 +809,7 @@ function toCdsSourceCsn(csn, options) {
     else if (syntax === 'view' || syntax === 'entity')
       result += `select from ${renderViewSource(select.from, env)}`;
     else
-      throw new Error(`Unknown query syntax: ${syntax}`);
+      throw new ModelError(`Unknown query syntax: ${syntax}`);
 
     if (select.mixin) {
       let elems = '';
@@ -980,7 +844,7 @@ function toCdsSourceCsn(csn, options) {
       result += `${continueIndent(result, env)}where ${renderExpr(select.where, env, true, true)}`;
 
     if (select.groupBy)
-      result += `${continueIndent(result, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env)).join(', ')}`;
+      result += `${continueIndent(result, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env, true, false, true)).join(', ')}`;
 
     if (select.having)
       result += `${continueIndent(result, env)}having ${renderExpr(select.having, env, true, true)}`;
@@ -1037,7 +901,7 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderOrderByEntry(entry, env) {
-    let result = renderDocComment(entry, env) + renderExpr(entry, env);
+    let result = renderDocComment(entry, env) + renderExpr(entry, env, true, false, true);
     if (entry.sort)
       result += ` ${entry.sort}`;
 
@@ -1140,7 +1004,10 @@ function toCdsSourceCsn(csn, options) {
     }
     else {
       // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReference(art, env, false)};\n`;
+      result += ` : ${renderTypeReference(art, env, false)}`;
+      if (art.default)
+        result += ` default ${renderExpr(art.default, env)}`;
+      result += ';\n';
     }
     return result;
   }
@@ -1176,7 +1043,7 @@ function toCdsSourceCsn(csn, options) {
     // Anonymous structured type
     if (!elm.type) {
       if (!elm.elements)
-        throw new Error(`Missing type of: ${JSON.stringify(elm)}`);
+        throw new ModelError(`Missing type of: ${JSON.stringify(elm)}`);
 
       result += '{\n';
       const childEnv = increaseIndent(env);
@@ -1214,7 +1081,7 @@ function toCdsSourceCsn(csn, options) {
         result += `${env.indent}}`;
       }
       else {
-        throw new Error('Association/Composition is missing its target! Throwing exception to trigger recompilation.');
+        throw new ModelError('Association/Composition is missing its target! Throwing exception to trigger recompilation.');
       }
 
 
@@ -1346,14 +1213,16 @@ function toCdsSourceCsn(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @param {boolean} [inline=true]
    * @param {boolean} [inExpr=false] Whether the expression is already inside another expression
+   * @param {boolean} [alwaysRenderCast=false] Whether to _always_ render SQL-style casts, even if `inExpr === false`
+   *                                           Note: This is a hack for casts() inside groupBy.
    */
-  function renderExpr(x, env, inline = true, inExpr = false) {
+  function renderExpr(x, env, inline = true, inExpr = false, alwaysRenderCast = false) {
     // Compound expression
     if (Array.isArray(x))
       return beautifyExprArray(x.map(item => renderExpr(item, env, inline, inExpr)));
 
     if (typeof x === 'object' && x !== null) {
-      if (inExpr && x.cast && x.cast.type)
+      if ((inExpr || alwaysRenderCast) && x.cast && x.cast.type)
         return renderExplicitTypeCast(renderExprObject());
       return renderExprObject();
     }
@@ -1392,7 +1261,7 @@ function toCdsSourceCsn(csn, options) {
 
             // otherwise fall through to
           default:
-            throw new Error(`Unknown literal or type: ${JSON.stringify(x)}`);
+            throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
         }
       }
       // Enum symbol
@@ -1439,7 +1308,7 @@ function toCdsSourceCsn(csn, options) {
         return `${renderQuery(x, false, 'view', increaseIndent(env))}`;
       }
       else {
-        throw new Error(`Unknown expression: ${JSON.stringify(x)}`);
+        throw new ModelError(`Unknown expression: ${JSON.stringify(x)}`);
       }
     }
 
@@ -1476,7 +1345,7 @@ function toCdsSourceCsn(csn, options) {
       else if (typeof s === 'object') {
         // Sanity check
         if (!s.func && !s.id)
-          throw new Error(`Unknown path step object: ${JSON.stringify(s)}`);
+          throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
 
         // Not really a path step but an object-like function call
         if (s.func)
@@ -1496,7 +1365,7 @@ function toCdsSourceCsn(csn, options) {
         return result;
       }
 
-      throw new Error(`Unknown path step: ${JSON.stringify(s)}`);
+      throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
     }
   }
 
@@ -1513,14 +1382,14 @@ function toCdsSourceCsn(csn, options) {
     const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
-      return args.map(arg => renderExpr(arg, env)).join(', ');
+      return args.map(arg => renderExpr(arg, env, true, false, true)).join(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
-      return Object.keys(args).map(key => `${quoteOrUppercaseId(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      return Object.keys(args).map(key => `${quoteOrUppercaseId(key)} ${sep} ${renderExpr(args[key], env, true, false, true)}`).join(', ');
 
 
-    throw new Error(`Unknown args: ${JSON.stringify(args)}`);
+    throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
   }
 
   /**
@@ -1689,23 +1558,6 @@ function toCdsSourceCsn(csn, options) {
     return absName;
   }
 
-  /**
-   * Render appropriate USING directives for all artifacts used by artifact 'artifactName' in 'env'.
-   *
-   * @param {string} artifactName
-   * @param {CdlRenderEnvironment} env
-   * @return {string}
-   */
-  function renderUsings(artifactName, env) {
-    const distinct = {};
-    Object.keys(env.topLevelAliases)
-      .forEach((name) => {
-        distinct[`using ${env.topLevelAliases[name].quotedName} as ${env.topLevelAliases[name].quotedAlias};\n`] = '';
-      });
-
-    return Object.keys(distinct).join('');
-  }
-
   /**
    * Returns a newly created default environment (which keeps track of indentation, required USING
    * declarations and name prefixes.
@@ -1725,17 +1577,6 @@ function toCdsSourceCsn(csn, options) {
     };
   }
 
-  /**
-   * Returns a copy of 'env' with (quoted) name prefix 'id' and a dot appended to the current name prefix
-   *
-   * @param {CdlRenderEnvironment} env
-   * @param {string} id
-   * @returns {CdlRenderEnvironment}
-   */
-  function addNamePrefix(env, id) {
-    return Object.assign({}, env, { namePrefix: `${env.namePrefix + quoteIdIfRequired(id)}.` });
-  }
-
   /**
    * Returns a copy of 'env' with increased indentation (and resetted name prefix)
    *
@@ -1821,7 +1662,7 @@ function toCdsSourceCsn(csn, options) {
    * of another entity -> Service.E and Service.E.Sub
    *
    * To handle such cases for hdbcds in quoted/hdbcds, we:
-   * - Find the part of the name that is no longer prefix (context/service/namespace)
+   * - Find the part of the name that is no longer prefix (context/service)
    * - For Service.E -> E, for Service.E.Sub -> E.Sub
    * - Replace all dots in this "real name" with underscores
    * - Join with the env prefix
@@ -1848,14 +1689,14 @@ function toCdsSourceCsn(csn, options) {
   }
 
   /**
-   * Get the part that is really the name of this artifact and not just prefix caused by a context/service/namespace
+   * Get the part that is really the name of this artifact and not just prefix caused by a context/service
    *
    * @param {String} artifactName Artifact name to use
    * @returns {String} non-prefix part of the artifact name
    */
   function getRealName(artifactName) {
     const parts = artifactName.split('.');
-    // Lenght of 1 -> There can be no prefix
+    // Length of 1 -> There can be no prefix
     if (parts.length === 1)
       return artifactName;
 
@@ -1869,7 +1710,7 @@ function toCdsSourceCsn(csn, options) {
 
 
       const art = csn.definitions[seen];
-      if (!art || ![ 'service', 'context', 'namespace' ].includes(art.kind)) {
+      if (!art || (art.kind !== 'service' && art.kind !== 'context')) {
         // We found a case where the prefix ended
         // Return everything following
         return parts.slice(i).join('.');
@@ -1881,13 +1722,9 @@ function toCdsSourceCsn(csn, options) {
   }
 }
 
-const controlCharacters = /[\u{0000}-\u{0009}\u{000B}\u{001F}]/u;
-const highSurrogate = /[\u{D800}-\u{DBFF}]/u;
-const lowSurrogate = /[\u{DC00}-\u{DFFF}]/u;
-
 /**
  * Render the given string.  Uses back-tick strings.
- * env is used for indentation for three-back-tick strings.
+ * env is used for indentation of three-back-tick strings.
  *
  * @param str
  * @param env
@@ -1897,90 +1734,33 @@ function renderString(str, env) {
   if (isSimpleString(str))
     return `'${str.replace(/'/g, '\'\'')}'`;
 
-  const output = [];
-
   // We try to work similar to how JavaScript implements JSON.stringify.
-  // JSON.stringify, however, checks for unpaired unicode surrogates (see §25.5.2.2,
-  // <https://tc39.es/ecma262/#sec-quotejsonstring>), which we do not do here.
-
-  for (let i = 0; i < str.length; ++i) {
-    const char = str[i];
-
-    switch (char) {
-      case '$':
-        output.push('\\$');
-        break;
-      case '`':
-        output.push('\\`');
-        break;
-      case '\\':
-        output.push('\\\\');
-        break;
-        // Replace commonly known escape sequences for control characters
-        // See lib/language/multiLineStringParser.js
-      case '\f':
-        output.push('\\f');
-        break;
-      case '\v':
-        output.push('\\v');
-        break;
-      case '\t':
-        output.push('\\t');
-        break;
-      case '\b':
-        output.push('\\b');
-        break;
-      // If CR, LS, or PS appear, they have been encoded explicitly.  If we don't escape
-      // them, a recompilation may yield different results because of newline normalization.
-      case '\r':
-        output.push('\\r');
-        break;
-      case '\u{2028}':
-        output.push('\\u{2028}');
-        break;
-      case '\u{2029}':
-        output.push('\\u{2029}');
-        break;
-      default: {
-        // Control Characters: C0
-        // See <https://en.wikipedia.org/wiki/C0_and_C1_control_codes#Basic_ASCII_control_codes>
-        //
-        // JSON.stringify is not required to escape all control characters, but if used, files may
-        // be interpreted as binary.  Therefore, we replace them.
-        //
-        // We exclude LF from this list (\u000A). Characters with "nice" escapes have been replaced above.
-        if (controlCharacters.test(char)) {
-          const hex = char.codePointAt(0).toString(16);
-          output.push(`\\u{${hex}}`);
-          break;
-        }
+  // JSON.stringify() also checks for unpaired unicode surrogates (see §25.5.2.2,
+  // <https://tc39.es/ecma262/#sec-quotejsonstring>).
+  str = escapeString(str, {
+    $: '\\$',
+    '`': '\\`',
+    '\\': '\\\\',
+    // Replace commonly known escape sequences for control characters
+    // See lib/language/multiLineStringParser.js
+    '\f': '\\f',
+    '\v': '\\v',
+    '\t': '\\t',
+    '\b': '\\b',
+    // If CR, LS, or PS appear, they have been encoded explicitly.  If we don't escape
+    // them, a recompilation may yield different results because of newline normalization.
+    '\r': '\\r',
+    '\u{2028}': '\\u{2028}',
+    '\u{2029}': '\\u{2029}',
+    // Don't encode LF
+    '\n': '\n',
+    // JSON.stringify() is not required to escape all control characters, but if used, files may
+    // be interpreted as binary.  Therefore, we replace them.
+    // We exclude LF from this list (\n). Characters with "nice" escapes have been replaced above.
+    control: hexEscape,
+    unpairedSurrogate: hexEscape,
+  });
 
-        // Unicode Surrogates
-        // These characters appear in _pairs_.  A high surrogate must be followed by a low surrogate.
-        // If this is not the case, either needs to be encoded.  This is also done by JSON.
-        // See also <https://docs.microsoft.com/en-us/globalization/encoding/surrogate-pairs>
-        if (highSurrogate.test(char)) {
-          if (i + 1 >= str.length || !lowSurrogate.test(str[i + 1])) {
-            const hex = char.codePointAt(0).toString(16);
-            output.push(`\\u{${hex}}`);
-          }
-          else {
-            output.push(char);
-            ++i;
-            output.push(str[i]);
-          }
-        }
-        else if (lowSurrogate.test(char)) {
-          const hex = char.codePointAt(0).toString(16);
-          output.push(`\\u{${hex}}`);
-        }
-        else {
-          output.push(char);
-        }
-      }
-    }
-  }
-  str = output.join('');
   // Note: String is normalized, only \n is the line separator.
   const lines = str.split('\n');
   // We don't know whether a text block was used or not.  But if there
@@ -1994,6 +1774,12 @@ function renderString(str, env) {
   return `\`${str}\``;
 }
 
+/** @param {number} codePoint */
+function hexEscape(codePoint) {
+  const hex = codePoint.toString(16);
+  return `\\u{${hex}}`;
+}
+
 /**
  * Returns true if the given string can be represented by using single quotes.
  * @param {string} str
@@ -2001,14 +1787,13 @@ function renderString(str, env) {
 function isSimpleString(str) {
   // A single-line string allows everything except certain line separators/breaks.
   // See ANTLR grammar for specifics.
-  // Furthermore, if control characters \u{0000}-\u{001F} are used, we escape them,
+  // Furthermore, if control characters are used, we escape them,
   // as these are explicitly mentioned in the JSON spec (§9):
   // <https://www.ecma-international.org/wp-content/uploads/ECMA-404_2nd_edition_december_2017.pdf>
-  // On top, as (invalid) surrogate pairs need to be handled, we check for them as well.
+  // On top, because (invalid) surrogate pairs need to be handled, we check for them as well.
   // v3: Not a simple string if ' (\u0027) is in string.
   return str === '' || (/^[^\u{0000}-\u{001F}\u2028\u2029]+$/u.test(str) &&
-    !highSurrogate.test(str) &&
-    !lowSurrogate.test(str));
+    !hasUnpairedUnicodeSurrogate(str));
 }
 
 /**