fast-json-stringify 6.1.0 → 6.2.0

package/.github/workflows/ci.yml

@@ -14,6 +14,11 @@ on:
       - 'docs/**'
       - '*.md'
 
+# This allows a subsequently queued workflow run to interrupt previous runs
+concurrency:
+    group: "${{ github.workflow }}-${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
+    cancel-in-progress: true
+
 permissions:
   contents: read
 

package/README.md

@@ -7,7 +7,6 @@
 
 __fast-json-stringify__ is significantly faster than `JSON.stringify()` for small payloads.
 Its performance advantage shrinks as your payload grows.
-It pairs well with [__flatstr__](https://www.npmjs.com/package/flatstr), which triggers a V8 optimization that improves performance when eventually converting the string to a `Buffer`.
 
 
 ### How it works

package/benchmark/bench-cmp-lib.js

@@ -1,7 +1,15 @@
 'use strict'
 
-const benchmark = require('benchmark')
-const suite = new benchmark.Suite()
+const { Bench } = require('tinybench')
+const suite = new Bench({
+  name: 'Library Comparison Benchmarks',
+  setup: (_task, mode) => {
+    // Run the garbage collector before warmup at each cycle
+    if (mode === 'warmup' && typeof globalThis.gc === 'function') {
+      globalThis.gc()
+    }
+  }
+})
 
 const STR_LEN = 1e4
 const LARGE_ARRAY_SIZE = 2e4
@@ -300,10 +308,16 @@ suite.add('compile-json-stringify date format', function () {
   CJSStringifyDate(date)
 })
 
-suite.on('cycle', cycle)
+suite.run().then(() => {
+  for (const task of suite.tasks) {
+    const hz = task.result.hz // ops/sec
+    const rme = task.result.rme // relative margin of error (%)
+    const samples = task.result.samples.length
 
-suite.run()
+    const formattedHz = hz.toLocaleString('en-US', { maximumFractionDigits: 0 })
+    const formattedRme = rme.toFixed(2)
 
-function cycle (e) {
-  console.log(e.target.toString())
-}
+    const output = `${task.name} x ${formattedHz} ops/sec ±${formattedRme}% (${samples} runs sampled)`
+    console.log(output)
+  }
+}).catch(err => console.error(`Error: ${err.message}`))

package/benchmark/bench-thread.js

@@ -2,20 +2,32 @@
 
 const { workerData: benchmark, parentPort } = require('worker_threads')
 
-const Benchmark = require('benchmark')
-Benchmark.options.minSamples = 100
+const { Bench } = require('tinybench')
 
-const suite = Benchmark.Suite()
+const bench = new Bench({
+  name: benchmark.name,
+  setup: (_task, mode) => {
+    // Run the garbage collector before warmup at each cycle
+    if (mode === 'warmup' && typeof globalThis.gc === 'function') {
+      globalThis.gc()
+    }
+  }
+})
 
 const FJS = require('..')
 const stringify = FJS(benchmark.schema)
 
-suite
-  .add(benchmark.name, () => {
-    stringify(benchmark.input)
-  })
-  .on('cycle', (event) => {
-    parentPort.postMessage(String(event.target))
-  })
-  .on('complete', () => {})
-  .run()
+bench.add(benchmark.name, () => {
+  stringify(benchmark.input)
+}).run().then(() => {
+  const task = bench.tasks[0]
+  const hz = task.result.hz // ops/sec
+  const rme = task.result.rme // relative margin of error (%)
+  const samples = task.result.samples.length
+
+  const formattedHz = hz.toLocaleString('en-US', { maximumFractionDigits: 0 })
+  const formattedRme = rme.toFixed(2)
+
+  const output = `${task.name} x ${formattedHz} ops/sec ±${formattedRme}% (${samples} runs sampled)`
+  parentPort.postMessage(output)
+}).catch(err => parentPort.postMessage(`Error: ${err.message}`))

package/index.js

@@ -30,17 +30,17 @@ const asInteger = serializer.asInteger.bind(serializer)
 
 `
 
-const validRoundingMethods = [
+const validRoundingMethods = new Set([
   'floor',
   'ceil',
   'round',
   'trunc'
-]
+])
 
-const validLargeArrayMechanisms = [
+const validLargeArrayMechanisms = new Set([
   'default',
   'json-stringify'
-]
+])
 
 let schemaIdCounter = 0
 
@@ -94,6 +94,14 @@ function getSchemaId (schema, rootSchemaId) {
   return rootSchemaId
 }
 
+function getSafeSchemaRef (context, location) {
+  let schemaRef = location.getSchemaRef() || ''
+  if (schemaRef.startsWith(context.rootSchemaId)) {
+    schemaRef = schemaRef.replace(context.rootSchemaId, '') || '#'
+  }
+  return schemaRef
+}
+
 function build (schema, options) {
   isValidSchema(schema)
 
@@ -107,7 +115,11 @@ function build (schema, options) {
     refResolver: new RefResolver(),
     rootSchemaId: schema.$id || `__fjs_root_${schemaIdCounter++}`,
     validatorSchemasIds: new Set(),
-    mergedSchemasIds: new Map()
+    mergedSchemasIds: new Map(),
+    recursiveSchemas: new Set(),
+    recursivePaths: new Set(),
+    buildingSet: new Set(),
+    uid: 0
   }
 
   const schemaId = getSchemaId(schema, context.rootSchemaId)
@@ -127,13 +139,13 @@ function build (schema, options) {
   }
 
   if (options.rounding) {
-    if (!validRoundingMethods.includes(options.rounding)) {
+    if (!validRoundingMethods.has(options.rounding)) {
       throw new Error(`Unsupported integer rounding method ${options.rounding}`)
     }
   }
 
   if (options.largeArrayMechanism) {
-    if (validLargeArrayMechanisms.includes(options.largeArrayMechanism)) {
+    if (validLargeArrayMechanisms.has(options.largeArrayMechanism)) {
       largeArrayMechanism = options.largeArrayMechanism
     } else {
       throw new Error(`Unsupported large array mechanism ${options.largeArrayMechanism}`)
@@ -141,11 +153,14 @@ function build (schema, options) {
   }
 
   if (options.largeArraySize) {
-    if (typeof options.largeArraySize === 'string' && Number.isFinite(Number.parseInt(options.largeArraySize, 10))) {
-      largeArraySize = Number.parseInt(options.largeArraySize, 10)
-    } else if (typeof options.largeArraySize === 'number' && Number.isInteger(options.largeArraySize)) {
+    const largeArraySizeType = typeof options.largeArraySize
+    let parsedNumber
+
+    if (largeArraySizeType === 'string' && Number.isFinite((parsedNumber = Number.parseInt(options.largeArraySize, 10)))) {
+      largeArraySize = parsedNumber
+    } else if (largeArraySizeType === 'number' && Number.isInteger(options.largeArraySize)) {
       largeArraySize = options.largeArraySize
-    } else if (typeof options.largeArraySize === 'bigint') {
+    } else if (largeArraySizeType === 'bigint') {
       largeArraySize = Number(options.largeArraySize)
     } else {
       throw new Error(`Unsupported large array size. Expected integer-like, got ${typeof options.largeArraySize} with value ${options.largeArraySize}`)
@@ -153,6 +168,7 @@ function build (schema, options) {
   }
 
   const location = new Location(schema, context.rootSchemaId)
+  detectRecursiveSchemas(context, location)
   const code = buildValue(context, location, 'input')
 
   let contextFunctionCode = `
@@ -283,13 +299,13 @@ function inferTypeByKeyword (schema) {
   return schema.type
 }
 
-function buildExtraObjectPropertiesSerializer (context, location, addComma) {
+function buildExtraObjectPropertiesSerializer (context, location, addComma, objVar) {
   const schema = location.schema
   const propertiesKeys = Object.keys(schema.properties || {})
 
   let code = `
     const propertiesKeys = ${JSON.stringify(propertiesKeys)}
-    for (const [key, value] of Object.entries(obj)) {
+    for (const [key, value] of Object.entries(${objVar})) {
       if (
         propertiesKeys.includes(key) ||
         value === undefined ||
@@ -341,7 +357,7 @@ function buildExtraObjectPropertiesSerializer (context, location, addComma) {
   return code
 }
 
-function buildInnerObject (context, location) {
+function buildInnerObject (context, location, objVar) {
   const schema = location.schema
 
   const propertiesLocation = location.getPropertyLocation('properties')
@@ -355,23 +371,25 @@ function buildInnerObject (context, location) {
       return required1 === required2 ? 0 : required1 ? -1 : 1
     }
   )
-  const hasRequiredProperties = requiredProperties.includes(propertiesKeys[0])
 
-  let code = 'let value\n'
+  let code = ''
 
   for (const key of requiredProperties) {
     if (!propertiesKeys.includes(key)) {
       const sanitizedKey = JSON.stringify(key)
-      code += `if (obj[${sanitizedKey}] === undefined) throw new Error('${sanitizedKey.replace(/'/g, '\\\'')} is required!')\n`
+      code += `if (${objVar}[${sanitizedKey}] === undefined) throw new Error('${sanitizedKey.replace(/'/g, '\\\'')} is required!')\n`
     }
   }
 
-  code += 'let json = JSON_STR_BEGIN_OBJECT\n'
+  code += 'json += JSON_STR_BEGIN_OBJECT\n'
 
+  const localUid = context.uid++
   let addComma = ''
-  if (!hasRequiredProperties) {
-    code += 'let addComma = false\n'
-    addComma = '!addComma && (addComma = true) || (json += JSON_STR_COMMA)'
+  const needsRuntimeComma = propertiesKeys.length > 1 || schema.patternProperties || (schema.additionalProperties !== undefined && schema.additionalProperties !== false)
+
+  if (needsRuntimeComma) {
+    code += `let addComma_${localUid} = false\n`
+    addComma = `!addComma_${localUid} && (addComma_${localUid} = true) || (json += JSON_STR_COMMA)`
   }
 
   for (const key of propertiesKeys) {
@@ -381,15 +399,16 @@ function buildInnerObject (context, location) {
     }
 
     const sanitizedKey = JSON.stringify(key)
+    const value = `value_${key.replace(/[^a-zA-Z0-9]/g, '_')}_${context.uid++}`
     const defaultValue = propertyLocation.schema.default
     const isRequired = requiredProperties.includes(key)
 
     code += `
-      value = obj[${sanitizedKey}]
-      if (value !== undefined) {
+      const ${value} = ${objVar}[${sanitizedKey}]
+      if (${value} !== undefined) {
         ${addComma}
         json += ${JSON.stringify(sanitizedKey + ':')}
-        ${buildValue(context, propertyLocation, 'value')}
+        ${buildValue(context, propertyLocation, `${value}`)}
       }`
 
     if (defaultValue !== undefined) {
@@ -406,24 +425,20 @@ function buildInnerObject (context, location) {
     } else {
       code += '\n'
     }
-
-    if (hasRequiredProperties) {
-      addComma = 'json += \',\''
-    }
   }
 
   if (schema.patternProperties || schema.additionalProperties) {
-    code += buildExtraObjectPropertiesSerializer(context, location, addComma)
+    code += buildExtraObjectPropertiesSerializer(context, location, addComma, objVar)
   }
 
   code += `
-    return json + JSON_STR_END_OBJECT
+    json += JSON_STR_END_OBJECT
   `
   return code
 }
 
 function mergeLocations (context, mergedSchemaId, mergedLocations) {
-  for (let i = 0; i < mergedLocations.length; i++) {
+  for (let i = 0, mergedLocationsLength = mergedLocations.length; i < mergedLocationsLength; i++) {
     const location = mergedLocations[i]
     const schema = location.schema
     if (schema.$ref) {
@@ -485,40 +500,57 @@ function toJSON (variableName) {
   `
 }
 
-function buildObject (context, location) {
+function buildObject (context, location, input) {
   const schema = location.schema
 
   if (context.functionsNamesBySchema.has(schema)) {
-    return context.functionsNamesBySchema.get(schema)
+    const funcName = context.functionsNamesBySchema.get(schema)
+    return `json += ${funcName}(${input})`
   }
 
-  const functionName = generateFuncName(context)
-  context.functionsNamesBySchema.set(schema, functionName)
+  const nullable = schema.nullable === true
 
-  let schemaRef = location.getSchemaRef()
-  if (schemaRef.startsWith(context.rootSchemaId)) {
-    schemaRef = schemaRef.replace(context.rootSchemaId, '')
-  }
+  const schemaId = location.schemaId || ''
+  const jsonPointer = location.jsonPointer || ''
+  const fullPath = `${schemaId}#${jsonPointer}`
 
-  let functionCode = `
-  `
+  if (context.recursivePaths.has(fullPath) || context.buildingSet.has(schema)) {
+    const functionName = generateFuncName(context)
+    context.functionsNamesBySchema.set(schema, functionName)
 
-  const nullable = schema.nullable === true
-  functionCode += `
-    // ${schemaRef}
-    function ${functionName} (input) {
-      const obj = ${toJSON('input')}
-      ${!nullable ? 'if (obj === null) return JSON_STR_EMPTY_OBJECT' : ''}
+    const schemaRef = getSafeSchemaRef(context, location)
 
-      ${buildInnerObject(context, location)}
+    const functionCode = `
+      // ${schemaRef}
+      function ${functionName} (input) {
+        const obj = ${toJSON('input')}
+        if (obj === null) return ${nullable ? 'JSON_STR_NULL' : 'JSON_STR_EMPTY_OBJECT'}
+        let json = ''
+
+        ${buildInnerObject(context, location, 'obj')}
+        return json
+      }
+    `
+
+    context.functions.push(functionCode)
+    return `json += ${functionName}(${input})`
+  }
+
+  context.buildingSet.add(schema)
+  const objVar = `obj_${context.uid++}`
+  const code = `
+    const ${objVar} = ${toJSON(input)}
+    if (${objVar} === null) {
+      json += ${nullable ? 'JSON_STR_NULL' : 'JSON_STR_EMPTY_OBJECT'}
+    } else {
+      ${buildInnerObject(context, location, objVar)}
     }
   `
-
-  context.functions.push(functionCode)
-  return functionName
+  context.buildingSet.delete(schema)
+  return code
 }
 
-function buildArray (context, location) {
+function buildArray (context, location, input) {
   const schema = location.schema
 
   let itemsLocation = location.getPropertyLocation('items')
@@ -531,61 +563,143 @@ function buildArray (context, location) {
   const itemsSchema = itemsLocation.schema
 
   if (context.functionsNamesBySchema.has(schema)) {
-    return context.functionsNamesBySchema.get(schema)
+    const funcName = context.functionsNamesBySchema.get(schema)
+    return `json += ${funcName}(${input})`
   }
 
-  const functionName = generateFuncName(context)
-  context.functionsNamesBySchema.set(schema, functionName)
+  const nullable = schema.nullable === true
 
-  let schemaRef = location.getSchemaRef()
-  if (schemaRef.startsWith(context.rootSchemaId)) {
-    schemaRef = schemaRef.replace(context.rootSchemaId, '')
-  }
+  const schemaId = location.schemaId || ''
+  const jsonPointer = location.jsonPointer || ''
+  const fullPath = `${schemaId}#${jsonPointer}`
+
+  if (context.recursivePaths.has(fullPath) || context.buildingSet.has(schema)) {
+    const functionName = generateFuncName(context)
+    context.functionsNamesBySchema.set(schema, functionName)
 
-  let functionCode = `
+    const schemaRef = getSafeSchemaRef(context, location)
+
+    let functionCode = `
     function ${functionName} (obj) {
       // ${schemaRef}
+      let json = ''
   `
 
-  const nullable = schema.nullable === true
-  functionCode += `
-    ${!nullable ? 'if (obj === null) return JSON_STR_EMPTY_ARRAY' : ''}
+    functionCode += `
+    if (obj === null) return ${nullable ? 'JSON_STR_NULL' : 'JSON_STR_EMPTY_ARRAY'}
     if (!Array.isArray(obj)) {
       throw new TypeError(\`The value of '${schemaRef}' does not match schema definition.\`)
     }
     const arrayLength = obj.length
   `
 
-  if (!schema.additionalItems && Array.isArray(itemsSchema)) {
-    functionCode += `
+    if (!schema.additionalItems && Array.isArray(itemsSchema)) {
+      functionCode += `
       if (arrayLength > ${itemsSchema.length}) {
         throw new Error(\`Item at ${itemsSchema.length} does not match schema definition.\`)
       }
     `
+    }
+
+    if (largeArrayMechanism === 'json-stringify') {
+      functionCode += `if (arrayLength >= ${largeArraySize}) return JSON.stringify(obj)\n`
+    }
+
+    functionCode += `
+    json += JSON_STR_BEGIN_ARRAY
+  `
+
+    if (Array.isArray(itemsSchema)) {
+      for (let i = 0, itemsSchemaLength = itemsSchema.length; i < itemsSchemaLength; i++) {
+        const item = itemsSchema[i]
+        const value = `value_${i}`
+        functionCode += `const ${value} = obj[${i}]`
+        const tmpRes = buildValue(context, itemsLocation.getPropertyLocation(i), value)
+        functionCode += `
+        if (${i} < arrayLength) {
+          if (${buildArrayTypeCondition(item.type, value)}) {
+            if (${i}) {
+              json += JSON_STR_COMMA
+            }
+            ${tmpRes}
+          } else {
+            throw new Error(\`Item at ${i} does not match schema definition.\`)
+          }
+        }
+        `
+      }
+
+      if (schema.additionalItems) {
+        functionCode += `
+        for (let i = ${itemsSchema.length}; i < arrayLength; i++) {
+          if (i) {
+            json += JSON_STR_COMMA
+          }
+          json += JSON.stringify(obj[i])
+        }`
+      }
+    } else {
+      const code = buildValue(context, itemsLocation, 'value')
+      functionCode += `
+      for (let i = 0; i < arrayLength; i++) {
+        if (i) {
+          json += JSON_STR_COMMA
+        }
+        const value = obj[i]
+        ${code}
+      }`
+    }
+
+    functionCode += `
+      return json + JSON_STR_END_ARRAY
+    }`
+
+    context.functions.push(functionCode)
+    return `json += ${functionName}(${input})`
+  }
+
+  context.buildingSet.add(schema)
+  const safeSchemaRef = getSafeSchemaRef(context, location)
+  const objVar = `obj_${context.uid++}`
+  let inlinedCode = `
+    const ${objVar} = ${input}
+    if (${objVar} === null) {
+      json += ${nullable ? 'JSON_STR_NULL' : 'JSON_STR_EMPTY_ARRAY'}
+    } else if (!Array.isArray(${objVar})) {
+      throw new TypeError(\`The value of '${safeSchemaRef}' does not match schema definition.\`)
+    } else {
+      const arrayLength_${objVar} = ${objVar}.length
+  `
+
+  if (!schema.additionalItems && Array.isArray(itemsSchema)) {
+    inlinedCode += `
+      if (arrayLength_${objVar} > ${itemsSchema.length}) {
+        throw new Error(\`Item at ${itemsSchema.length} does not match schema definition.\`)
+      }
+    `
   }
 
   if (largeArrayMechanism === 'json-stringify') {
-    functionCode += `if (arrayLength >= ${largeArraySize}) return JSON.stringify(obj)\n`
+    inlinedCode += `if (arrayLength_${objVar} >= ${largeArraySize}) json += JSON.stringify(${objVar})\n else {`
   }
 
-  functionCode += `
-    const arrayEnd = arrayLength - 1
-    let value
-    let json = ''
+  inlinedCode += `
+    json += JSON_STR_BEGIN_ARRAY
   `
 
   if (Array.isArray(itemsSchema)) {
-    for (let i = 0; i < itemsSchema.length; i++) {
+    const localUid = context.uid++
+    inlinedCode += `let addComma_${localUid} = false\n`
+    for (let i = 0, itemsSchemaLength = itemsSchema.length; i < itemsSchemaLength; i++) {
       const item = itemsSchema[i]
-      functionCode += `value = obj[${i}]`
-      const tmpRes = buildValue(context, itemsLocation.getPropertyLocation(i), 'value')
-      functionCode += `
-        if (${i} < arrayLength) {
-          if (${buildArrayTypeCondition(item.type, 'value')}) {
+      const value = `value_${i}_${context.uid++}`
+      inlinedCode += `const ${value} = ${objVar}[${i}]`
+      const tmpRes = buildValue(context, itemsLocation.getPropertyLocation(i), value)
+      inlinedCode += `
+        if (${i} < arrayLength_${objVar}) {
+          if (${buildArrayTypeCondition(item.type, value)}) {
+            !addComma_${localUid} && (addComma_${localUid} = true) || (json += JSON_STR_COMMA)
             ${tmpRes}
-            if (${i} < arrayEnd) {
-              json += JSON_STR_COMMA
-            }
           } else {
             throw new Error(\`Item at ${i} does not match schema definition.\`)
           }
@@ -594,66 +708,68 @@ function buildArray (context, location) {
     }
 
     if (schema.additionalItems) {
-      functionCode += `
-        for (let i = ${itemsSchema.length}; i < arrayLength; i++) {
-          value = obj[i]
-          json += JSON.stringify(value)
-          if (i < arrayEnd) {
-            json += JSON_STR_COMMA
-          }
+      inlinedCode += `
+        for (let i = ${itemsSchema.length}; i < arrayLength_${objVar}; i++) {
+          !addComma_${localUid} && (addComma_${localUid} = true) || (json += JSON_STR_COMMA)
+          json += JSON.stringify(${objVar}[i])
         }`
     }
   } else {
     const code = buildValue(context, itemsLocation, 'value')
-    functionCode += `
-      for (let i = 0; i < arrayLength; i++) {
-        value = obj[i]
-        ${code}
-        if (i < arrayEnd) {
+    inlinedCode += `
+      for (let i = 0; i < arrayLength_${objVar}; i++) {
+        if (i) {
           json += JSON_STR_COMMA
         }
+        const value = ${objVar}[i]
+        ${code}
       }`
   }
 
-  functionCode += `
-    return JSON_STR_BEGIN_ARRAY + json + JSON_STR_END_ARRAY
-  }`
+  inlinedCode += `
+    json += JSON_STR_END_ARRAY
+  `
 
-  context.functions.push(functionCode)
-  return functionName
+  if (largeArrayMechanism === 'json-stringify') {
+    inlinedCode += '}'
+  }
+
+  inlinedCode += '}'
+  context.buildingSet.delete(schema)
+  return inlinedCode
 }
 
 function buildArrayTypeCondition (type, accessor) {
   let condition
   switch (type) {
     case 'null':
-      condition = 'value === null'
+      condition = `${accessor} === null`
       break
     case 'string':
-      condition = `typeof value === 'string' ||
-      value === null ||
-      value instanceof Date ||
-      value instanceof RegExp ||
+      condition = `typeof ${accessor} === 'string' ||
+      ${accessor} === null ||
+      ${accessor} instanceof Date ||
+      ${accessor} instanceof RegExp ||
       (
-        typeof value === "object" &&
-        typeof value.toString === "function" &&
-        value.toString !== Object.prototype.toString
+        typeof ${accessor} === "object" &&
+        typeof ${accessor}.toString === "function" &&
+        ${accessor}.toString !== Object.prototype.toString
       )`
       break
     case 'integer':
-      condition = 'Number.isInteger(value)'
+      condition = `Number.isInteger(${accessor})`
       break
     case 'number':
-      condition = 'Number.isFinite(value)'
+      condition = `Number.isFinite(${accessor})`
       break
     case 'boolean':
-      condition = 'typeof value === \'boolean\''
+      condition = `typeof ${accessor} === 'boolean'`
       break
     case 'object':
-      condition = 'value && typeof value === \'object\' && value.constructor === Object'
+      condition = `${accessor} && typeof ${accessor} === 'object' && ${accessor}.constructor === Object`
       break
     case 'array':
-      condition = 'Array.isArray(value)'
+      condition = `Array.isArray(${accessor})`
       break
     default:
       if (Array.isArray(type)) {
@@ -684,8 +800,9 @@ function buildMultiTypeSerializer (context, location, input) {
     switch (type) {
       case 'null':
         code += `
-          ${statement} (${input} === null)
+          ${statement} (${input} === null) {
             ${nestedResult}
+          }
           `
         break
       case 'string': {
@@ -700,40 +817,40 @@ function buildMultiTypeSerializer (context, location, input) {
               typeof ${input}.toString === "function" &&
               ${input}.toString !== Object.prototype.toString
             )
-          )
+          ) {
             ${nestedResult}
+          }
         `
         break
       }
       case 'array': {
         code += `
-          ${statement}(Array.isArray(${input}))
+          ${statement}(Array.isArray(${input})) {
             ${nestedResult}
+          }
         `
         break
       }
       case 'integer': {
         code += `
-          ${statement}(Number.isInteger(${input}) || ${input} === null)
+          ${statement}(Number.isInteger(${input}) || ${input} === null) {
             ${nestedResult}
+          }
         `
         break
       }
       default: {
         code += `
-          ${statement}(typeof ${input} === "${type}" || ${input} === null)
+          ${statement}(typeof ${input} === "${type}" || ${input} === null) {
             ${nestedResult}
+          }
         `
         break
       }
     }
   })
-  let schemaRef = location.getSchemaRef()
-  if (schemaRef.startsWith(context.rootSchemaId)) {
-    schemaRef = schemaRef.replace(context.rootSchemaId, '')
-  }
   code += `
-    else throw new TypeError(\`The value of '${schemaRef}' does not match schema definition.\`)
+    else throw new TypeError(\`The value of '${getSafeSchemaRef(context, location)}' does not match schema definition.\`)
   `
 
   return code
@@ -779,12 +896,10 @@ function buildSingleTypeSerializer (context, location, input) {
     case 'boolean':
       return `json += asBoolean(${input})`
     case 'object': {
-      const funcName = buildObject(context, location)
-      return `json += ${funcName}(${input})`
+      return buildObject(context, location, input)
     }
     case 'array': {
-      const funcName = buildArray(context, location)
-      return `json += ${funcName}(${input})`
+      return buildArray(context, location, input)
     }
     case undefined:
       return `json += JSON.stringify(${input})`
@@ -793,6 +908,92 @@ function buildSingleTypeSerializer (context, location, input) {
   }
 }
 
+function detectRecursiveSchemas (context, location) {
+  const pathStack = new Set()
+  function traverse (location) {
+    const schema = location.schema
+    if (typeof schema !== 'object' || schema === null) return
+
+    const schemaId = location.schemaId || ''
+    const jsonPointer = location.jsonPointer || ''
+    const fullPath = `${schemaId}#${jsonPointer}`
+
+    if (pathStack.has(fullPath)) {
+      // Mark all nodes in the current path that are part of the cycle
+      let inCycle = false
+      for (const p of pathStack) {
+        if (p === fullPath) inCycle = true
+        if (inCycle) context.recursivePaths.add(p)
+      }
+      context.recursivePaths.add(fullPath)
+      return
+    }
+    pathStack.add(fullPath)
+
+    if (schema.$ref) {
+      try {
+        const res = resolveRef(context, location)
+        traverse(res)
+      } catch (err) {
+        // Validation will handle missing refs later
+      }
+    }
+
+    if (schema.properties) {
+      const propertiesLocation = location.getPropertyLocation('properties')
+      for (const key in schema.properties) {
+        traverse(propertiesLocation.getPropertyLocation(key))
+      }
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+      traverse(location.getPropertyLocation('additionalProperties'))
+    }
+    if (schema.patternProperties) {
+      const patternPropertiesLocation = location.getPropertyLocation('patternProperties')
+      for (const key in schema.patternProperties) {
+        traverse(patternPropertiesLocation.getPropertyLocation(key))
+      }
+    }
+    if (schema.items) {
+      const itemsLocation = location.getPropertyLocation('items')
+      if (Array.isArray(schema.items)) {
+        for (let i = 0; i < schema.items.length; i++) {
+          traverse(itemsLocation.getPropertyLocation(i))
+        }
+      } else {
+        traverse(itemsLocation)
+      }
+    }
+    if (schema.additionalItems && typeof schema.additionalItems === 'object') {
+      traverse(location.getPropertyLocation('additionalItems'))
+    }
+
+    if (schema.oneOf) {
+      const oneOfLocation = location.getPropertyLocation('oneOf')
+      for (let i = 0; i < schema.oneOf.length; i++) {
+        traverse(oneOfLocation.getPropertyLocation(i))
+      }
+    }
+    if (schema.anyOf) {
+      const anyOfLocation = location.getPropertyLocation('anyOf')
+      for (let i = 0; i < schema.anyOf.length; i++) {
+        traverse(anyOfLocation.getPropertyLocation(i))
+      }
+    }
+    if (schema.allOf) {
+      const allOfLocation = location.getPropertyLocation('allOf')
+      for (let i = 0; i < schema.allOf.length; i++) {
+        traverse(allOfLocation.getPropertyLocation(i))
+      }
+    }
+    if (schema.then) traverse(location.getPropertyLocation('then'))
+    if (schema.else) traverse(location.getPropertyLocation('else'))
+
+    pathStack.delete(fullPath)
+  }
+  traverse(location)
+}
+
 function buildConstSerializer (location, input) {
   const schema = location.schema
   const type = schema.type
@@ -842,7 +1043,7 @@ function buildAllOf (context, location, input) {
   ]
 
   const allOfsLocation = location.getPropertyLocation('allOf')
-  for (let i = 0; i < allOf.length; i++) {
+  for (let i = 0, allOfLength = allOf.length; i < allOfLength; i++) {
     locations.push(allOfsLocation.getPropertyLocation(i))
   }
 
@@ -867,7 +1068,7 @@ function buildOneOf (context, location, input) {
 
   let code = ''
 
-  for (let index = 0; index < oneOfs.length; index++) {
+  for (let index = 0, oneOfsLength = oneOfs.length; index < oneOfsLength; index++) {
     const optionLocation = oneOfsLocation.getPropertyLocation(index)
     const optionSchema = optionLocation.schema
 
@@ -887,19 +1088,16 @@ function buildOneOf (context, location, input) {
 
     const nestedResult = buildValue(context, mergedLocation, input)
     const schemaRef = optionLocation.getSchemaRef()
+
     code += `
-      ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input}))
+      ${index === 0 ? 'if' : 'else if'}(validator.validate("${schemaRef}", ${input})) {
         ${nestedResult}
+      }
     `
   }
 
-  let schemaRef = location.getSchemaRef()
-  if (schemaRef.startsWith(context.rootSchemaId)) {
-    schemaRef = schemaRef.replace(context.rootSchemaId, '')
-  }
-
   code += `
-    else throw new TypeError(\`The value of '${schemaRef}' does not match schema definition.\`)
+    else throw new TypeError(\`The value of '${getSafeSchemaRef(context, location)}' does not match schema definition.\`)
   `
 
   return code

package/lib/serializer.js

@@ -1,5 +1,8 @@
 'use strict'
 
+// eslint-disable-next-line
+const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/
+
 module.exports = class Serializer {
   constructor (options) {
     switch (options && options.rounding) {
@@ -116,7 +119,7 @@ module.exports = class Serializer {
         }
       }
       return (last === -1 && ('"' + str + '"')) || ('"' + result + str.slice(last) + '"')
-    } else if (len < 5000 && str.isWellFormed()) {
+    } else if (len < 5000 && STR_ESCAPE.test(str) === false) {
       // Only use the regular expression for shorter input. The overhead is otherwise too much.
       return '"' + str + '"'
     } else {

package/lib/validator.js

@@ -21,8 +21,8 @@ class Validator {
       keyword: 'fjs_type',
       type: 'object',
       errors: false,
-      validate: (_type, date) => {
-        return date instanceof Date
+      validate: (_type, data) => {
+        return data && typeof data.toJSON === 'function'
       }
     })
 
@@ -51,8 +51,10 @@ class Validator {
     return this.ajv.validate(schemaRef, data)
   }
 
-  // Ajv does not support js date format. In order to properly validate objects containing a date,
-  // it needs to replace all occurrences of the string date format with a custom keyword fjs_type.
+  // Ajv does not natively support JavaScript objects like Date or other types
+  // that rely on a custom .toJSON() representation. To properly validate schemas
+  // that may contain such objects (e.g. Date, ObjectId, etc.), we replace all
+  // occurrences of the string type with a custom keyword fjs_type
   // (see https://github.com/fastify/fast-json-stringify/pull/441)
   convertSchemaToAjvFormat (schema) {
     if (schema === null) return

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "fast-json-stringify",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
-    "bench": "node ./benchmark/bench.js",
+    "bench": "node --expose-gc ./benchmark/bench.js",
     "bench:cmp": "node ./benchmark/bench-cmp-branch.js",
     "bench:cmp:ci": "node ./benchmark/bench-cmp-branch.js --ci",
-    "benchmark": "node ./benchmark/bench-cmp-lib.js",
+    "benchmark": "node --expose-gc ./benchmark/bench-cmp-lib.js",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test:typescript": "tsd",
@@ -63,7 +63,6 @@
   ],
   "devDependencies": {
     "@sinclair/typebox": "^0.34.3",
-    "benchmark": "^2.1.4",
     "c8": "^10.1.2",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
@@ -73,6 +72,7 @@
     "json-accelerator": "^0.0.2",
     "neostandard": "^0.12.0",
     "simple-git": "^3.23.0",
+    "tinybench": "^5.0.1",
     "tsd": "^0.32.0",
     "webpack": "^5.90.3"
   },

package/test/issue-793.test.js

@@ -0,0 +1,107 @@
+'use strict'
+
+const { test } = require('node:test')
+
+const build = require('..')
+
+test('serialize string with newlines - issue #793', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      message: {
+        type: 'string'
+      }
+    }
+  }
+
+  const input = {
+    message: `This is a string
+with multiple
+newlines in it
+Foo`
+  }
+
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  // The output should be valid JSON
+  t.assert.doesNotThrow(() => {
+    JSON.parse(output)
+  }, 'JSON output should be parseable')
+
+  // The parsed output should match the input
+  const parsed = JSON.parse(output)
+  t.assert.equal(parsed.message, input.message)
+})
+
+test('serialize string with various newline characters - issue #793', (t) => {
+  t.plan(4)
+
+  const schema = {
+    type: 'string'
+  }
+
+  const stringify = build(schema)
+
+  // Test \n (line feed)
+  const inputLF = 'line1\nline2'
+  const outputLF = stringify(inputLF)
+  t.assert.equal(JSON.parse(outputLF), inputLF)
+
+  // Test \r (carriage return)
+  const inputCR = 'line1\rline2'
+  const outputCR = stringify(inputCR)
+  t.assert.equal(JSON.parse(outputCR), inputCR)
+
+  // Test \r\n (CRLF)
+  const inputCRLF = 'line1\r\nline2'
+  const outputCRLF = stringify(inputCRLF)
+  t.assert.equal(JSON.parse(outputCRLF), inputCRLF)
+
+  // Test mixed newlines
+  const inputMixed = 'line1\nline2\rline3\r\nline4'
+  const outputMixed = stringify(inputMixed)
+  t.assert.equal(JSON.parse(outputMixed), inputMixed)
+})
+
+test('serialize object with newlines in multiple properties - issue #793', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      message: {
+        type: 'string'
+      },
+      description: {
+        type: 'string'
+      },
+      timestamp: {
+        type: 'string'
+      }
+    }
+  }
+
+  const input = {
+    message: `This is a string
+with multiple
+newlines in it
+Foo`,
+    description: 'This JSON response contains a field with newline characters',
+    timestamp: new Date().toISOString()
+  }
+
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  // The output should be valid JSON
+  t.assert.doesNotThrow(() => {
+    JSON.parse(output)
+  }, 'JSON output should be parseable')
+
+  // The parsed output should match the input
+  const parsed = JSON.parse(output)
+  t.assert.deepEqual(parsed, input)
+})

package/test/issue-794.test.js

@@ -0,0 +1,177 @@
+'use strict'
+
+const { test } = require('node:test')
+
+const build = require('..')
+
+test('serialize string with quotes - issue #794', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      message: {
+        type: 'string'
+      }
+    }
+  }
+
+  const input = {
+    message: 'Error: Property "name" is required'
+  }
+
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  // The output should be valid JSON
+  t.assert.doesNotThrow(() => {
+    JSON.parse(output)
+  }, 'JSON output should be parseable')
+
+  // The parsed output should match the input
+  const parsed = JSON.parse(output)
+  t.assert.equal(parsed.message, input.message)
+})
+
+test('serialize string with various quote types - issue #794', (t) => {
+  t.plan(6)
+
+  const schema = {
+    type: 'string'
+  }
+
+  const stringify = build(schema)
+
+  // Test double quotes
+  const inputDoubleQuotes = 'Property "name" is required'
+  const outputDoubleQuotes = stringify(inputDoubleQuotes)
+  t.assert.doesNotThrow(() => JSON.parse(outputDoubleQuotes))
+  t.assert.equal(JSON.parse(outputDoubleQuotes), inputDoubleQuotes)
+
+  // Test single quotes (should be fine but test for completeness)
+  const inputSingleQuotes = "Property 'name' is required"
+  const outputSingleQuotes = stringify(inputSingleQuotes)
+  t.assert.doesNotThrow(() => JSON.parse(outputSingleQuotes))
+  t.assert.equal(JSON.parse(outputSingleQuotes), inputSingleQuotes)
+
+  // Test mixed quotes
+  const inputMixedQuotes = 'Error: "Property \'name\' is required"'
+  const outputMixedQuotes = stringify(inputMixedQuotes)
+  t.assert.doesNotThrow(() => JSON.parse(outputMixedQuotes))
+  t.assert.equal(JSON.parse(outputMixedQuotes), inputMixedQuotes)
+})
+
+test('serialize error-like object with quotes in message - issue #794', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      error: {
+        type: 'object',
+        properties: {
+          message: {
+            type: 'string'
+          },
+          code: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+
+  const input = {
+    error: {
+      message: 'Validation failed: Property "email" must be a valid email address',
+      code: 'VALIDATION_ERROR'
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  // The output should be valid JSON
+  t.assert.doesNotThrow(() => {
+    JSON.parse(output)
+  }, 'JSON output should be parseable')
+
+  // The parsed output should match the input
+  const parsed = JSON.parse(output)
+  t.assert.deepEqual(parsed, input)
+})
+
+test('serialize validation errors array with quotes - issue #794', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      errors: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            message: {
+              type: 'string'
+            },
+            field: {
+              type: 'string'
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const input = {
+    errors: [
+      {
+        message: 'Property "name" is required',
+        field: 'name'
+      },
+      {
+        message: 'Property "email" must be a valid email address',
+        field: 'email'
+      },
+      {
+        message: 'Value must be between "1" and "100"',
+        field: 'age'
+      }
+    ]
+  }
+
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  // The output should be valid JSON
+  t.assert.doesNotThrow(() => {
+    JSON.parse(output)
+  }, 'JSON output should be parseable')
+
+  // The parsed output should match the input
+  const parsed = JSON.parse(output)
+  t.assert.deepEqual(parsed, input)
+})
+
+test('serialize string with backslashes and quotes - issue #794', (t) => {
+  t.plan(4)
+
+  const schema = {
+    type: 'string'
+  }
+
+  const stringify = build(schema)
+
+  // Test backslashes
+  const inputBackslash = 'Path: C:\\Users\\test\\file.json'
+  const outputBackslash = stringify(inputBackslash)
+  t.assert.doesNotThrow(() => JSON.parse(outputBackslash))
+  t.assert.equal(JSON.parse(outputBackslash), inputBackslash)
+
+  // Test combination of backslashes and quotes
+  const inputMixed = 'Error: Could not find file "C:\\Users\\test\\config.json"'
+  const outputMixed = stringify(inputMixed)
+  t.assert.doesNotThrow(() => JSON.parse(outputMixed))
+  t.assert.equal(JSON.parse(outputMixed), inputMixed)
+})

package/test/json-add-comma.test.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('additionalProperties: false', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: false
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a"}')
+})
+
+test('additionalProperties: {}', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {}
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
+})
+
+test('additionalProperties: {type: string}', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {
+      type: 'string'
+    }
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
+})