fast-json-stringify 2.7.11 → 3.0.1

package/.github/dependabot.yml

@@ -2,6 +2,10 @@ version: 2
 updates:
   - package-ecosystem: github-actions
     directory: '/'
+    ignore:
+      - dependency-name: "actions/*"
+        update-types:
+            ["version-update:semver-minor", "version-update:semver-patch"]
     schedule:
       interval: daily
     open-pull-requests-limit: 10

package/.github/workflows/ci.yml

@@ -15,14 +15,14 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        node-version: [10, 12, 13, 14, 16]
+        node-version: [14, 16, 17]
         os: [macos-latest, ubuntu-latest, windows-latest]
 
     steps:
-      - uses: actions/checkout@v2.3.4
+      - uses: actions/checkout@v2
 
       - name: Use Node.js
-        uses: actions/setup-node@v2.4.0
+        uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node-version }}
 
@@ -37,7 +37,11 @@ jobs:
   automerge:
     needs: test
     runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+      contents: write
     steps:
-      - uses: fastify/github-action-merge-dependabot@v2.5.0
+      - uses: fastify/github-action-merge-dependabot@v3
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
+          target: minor

package/README.md

@@ -7,7 +7,14 @@
 [![NPM downloads](https://img.shields.io/npm/dm/fast-json-stringify.svg?style=flat)](https://www.npmjs.com/package/fast-json-stringify)
 
 
-__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`.
+__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
+
+fast-json-stringify requires a [JSON Schema Draft 7](https://json-schema.org/specification-links.html#draft-7) input to generate a fast `stringify` function.
 
 ##### Benchmarks
 
@@ -15,22 +22,28 @@ __fast-json-stringify__ is significantly faster than `JSON.stringify()` for smal
 - Node.js `v16.9.1`
 
 ```
-FJS creation x 6,040 ops/sec ±1.17% (91 runs sampled)
-
-JSON.stringify array x 5,519 ops/sec ±0.08% (99 runs sampled)
-fast-json-stringify array x 7,143 ops/sec ±0.14% (97 runs sampled)
-
-JSON.stringify long string x 16,438 ops/sec ±0.32% (98 runs sampled)
-fast-json-stringify long string x 16,457 ops/sec ±0.09% (97 runs sampled)
-
-JSON.stringify short string x 12,061,258 ops/sec ±0.32% (97 runs sampled)
-fast-json-stringify short string x 35,531,071 ops/sec ±0.17% (94 runs sampled)
-
-JSON.stringify obj x 3,079,746 ops/sec ±0.09% (95 runs sampled)
-fast-json-stringify obj x 7,721,569 ops/sec ±0.12% (98 runs sampled)
-
-JSON stringify date x 1,149,786 ops/sec ±0.10% (99 runs sampled)
-fast-json-stringify date format x 1,674,498 ops/sec ±0.12% (99 runs sampled)
+FJS creation x 8,443 ops/sec ±1.01% (90 runs sampled)
+CJS creation x 183,219 ops/sec ±0.13% (96 runs sampled)
+AJV Serialize creation x 83,541,848 ops/sec ±0.24% (98 runs sampled)
+JSON.stringify array x 5,363 ops/sec ±0.11% (100 runs sampled)
+fast-json-stringify array x 6,747 ops/sec ±0.13% (98 runs sampled)
+compile-json-stringify array x 7,121 ops/sec ±0.42% (98 runs sampled)
+AJV Serialize array x 7,533 ops/sec ±0.13% (98 runs sampled)
+JSON.stringify long string x 16,461 ops/sec ±0.12% (98 runs sampled)
+fast-json-stringify long string x 16,443 ops/sec ±0.37% (99 runs sampled)
+compile-json-stringify long string x 16,458 ops/sec ±0.09% (98 runs sampled)
+AJV Serialize long string x 21,433 ops/sec ±0.08% (95 runs sampled)
+JSON.stringify short string x 12,035,664 ops/sec ±0.62% (96 runs sampled)
+fast-json-stringify short string x 38,281,060 ops/sec ±0.24% (98 runs sampled)
+compile-json-stringify short string x 32,388,037 ops/sec ±0.27% (97 runs sampled)
+AJV Serialize short string x 32,288,612 ops/sec ±0.32% (95 runs sampled)
+JSON.stringify obj x 3,068,185 ops/sec ±0.16% (98 runs sampled)
+fast-json-stringify obj x 10,082,694 ops/sec ±0.10% (97 runs sampled)
+compile-json-stringify obj x 17,037,963 ops/sec ±1.17% (97 runs sampled)
+AJV Serialize obj x 9,660,041 ops/sec ±0.11% (97 runs sampled)
+JSON stringify date x 1,084,008 ops/sec ±0.16% (98 runs sampled)
+fast-json-stringify date format x 1,781,044 ops/sec ±0.48% (99 runs sampled)
+compile-json-stringify date format x 1,086,187 ops/sec ±0.16% (99 runs sampled)
 ```
 
 #### Table of contents:
@@ -43,7 +56,7 @@ fast-json-stringify date format x 1,674,498 ops/sec ±0.12% (99 runs sampled)
  - <a href="#missingFields">`Missing fields`</a>
  - <a href="#patternProperties">`Pattern Properties`</a>
  - <a href="#additionalProperties">`Additional Properties`</a>
- - <a href="#anyof">`AnyOf`</a>
+ - <a href="#anyof">`AnyOf` and `OneOf`</a>
  - <a href="#ref">`Reuse - $ref`</a>
  - <a href="#long">`Long integers`</a>
  - <a href="#integer">`Integers`</a>
@@ -102,7 +115,7 @@ const stringify = fastJson(mySchema, {
 ```
 
 - `schema`: external schemas references by $ref property. [More details](#ref)
-- `ajv`: ajv instance's settings for those properties that require `ajv`. [More details](#anyof)
+- `ajv`: [ajv v8 instance's settings](https://ajv.js.org/options.html) for those properties that require `ajv`. [More details](#anyof)
 - `rounding`: setup how the `integer` types will be rounded when not integers. [More details](#integer)
 
 
@@ -111,7 +124,7 @@ const stringify = fastJson(mySchema, {
 <a name="fastJsonStringify"></a>
 ### fastJsonStringify(schema)
 
-Build a `stringify()` function based on [jsonschema](https://json-schema.org/).
+Build a `stringify()` function based on [jsonschema draft 7 spec](https://json-schema.org/specification-links.html#draft-7).
 
 Supported types:
 
@@ -307,11 +320,11 @@ const obj = {
 console.log(stringify(obj)) // '{"nickname":"nick","matchfoo":"42","otherfoo":"str","matchnum":3,"nomatchstr":"valar morghulis",nomatchint:"313"}'
 ```
 
-#### AnyOf
+#### AnyOf and OneOf
 
-`fast-json-stringify` supports the anyOf keyword as defined by JSON schema. *anyOf* must be an array of valid JSON schemas. The different schemas will be tested in the specified order. The more schemas `stringify` has to try before finding a match, the slower it will be.
+`fast-json-stringify` supports the **anyOf** and **oneOf** keywords as defined by JSON schema. Both must be an array of valid JSON schemas. The different schemas will be tested in the specified order. The more schemas `stringify` has to try before finding a match, the slower it will be.
 
-*anyOf* uses [ajv](https://www.npmjs.com/package/ajv) as a JSON schema validator to find the schema that matches the data. This has an impact on performance—only use it as a last resort.
+*anyOf* and *oneOf* use [ajv](https://www.npmjs.com/package/ajv) as a JSON schema validator to find the schema that matches the data. This has an impact on performance—only use it as a last resort.
 
 Example:
 ```javascript
@@ -521,46 +534,7 @@ const stringify = fastJson(schema, { schema: externalSchema })
 
 <a name="long"></a>
 #### Long integers
-By default the library will automatically handle [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) from Node.js v10.3 and above.
-If you can't use BigInts in your environment, long integers (64-bit) are also supported using the [long](https://github.com/dcodeIO/long.js) module.
-Example:
-```javascript
-// => using native BigInt
-const stringify = fastJson({
-  title: 'Example Schema',
-  type: 'object',
-  properties: {
-    id: {
-      type: 'integer'
-    }
-  }
-})
-
-const obj = {
-  id: 18446744073709551615n
-}
-
-console.log(stringify(obj)) // '{"id":18446744073709551615}'
-
-// => using the long library
-const Long = require('long')
-
-const stringify = fastJson({
-  title: 'Example Schema',
-  type: 'object',
-  properties: {
-    id: {
-      type: 'integer'
-    }
-  }
-})
-
-const obj = {
-  id: Long.fromString('18446744073709551615', true)
-}
-
-console.log(stringify(obj)) // '{"id":18446744073709551615}'
-```
+By default the library will handle automatically [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt).
 
 <a name="integer"></a>
 #### Integers

package/bench.js

@@ -38,6 +38,21 @@ const schemaCJS = {
   }
 }
 
+const schemaAJVJTD = {
+  properties: {
+    firstName: {
+      type: 'string'
+    },
+    lastName: {
+      type: 'string',
+      nullable: true
+    },
+    age: {
+      type: 'uint8'
+    }
+  }
+}
+
 const arraySchema = {
   title: 'array schema',
   type: 'array',
@@ -50,6 +65,10 @@ const arraySchemaCJS = {
   items: schemaCJS
 }
 
+const arraySchemaAJVJTD = {
+  elements: schemaAJVJTD
+}
+
 const dateFormatSchema = {
   description: 'Date of birth',
   type: 'string',
@@ -85,6 +104,12 @@ const stringifyDate = FJS(dateFormatSchema)
 const stringifyString = FJS({ type: 'string' })
 let str = ''
 
+const Ajv = require('ajv/dist/jtd')
+const ajv = new Ajv()
+const ajvSerialize = ajv.compileSerializer(schemaAJVJTD)
+const ajvSerializeArray = ajv.compileSerializer(arraySchemaAJVJTD)
+const ajvSerializeString = ajv.compileSerializer({ type: 'string' })
+
 // eslint-disable-next-line
 for (var i = 0; i < 10000; i++) {
   str += i
@@ -105,6 +130,9 @@ suite.add('FJS creation', function () {
 suite.add('CJS creation', function () {
   CJS(schemaCJS)
 })
+suite.add('AJV Serialize creation', function () {
+  ajv.compileSerializer(schemaAJVJTD)
+})
 
 suite.add('JSON.stringify array', function () {
   JSON.stringify(multiArray)
@@ -118,6 +146,10 @@ suite.add('compile-json-stringify array', function () {
   CJSStringifyArray(multiArray)
 })
 
+suite.add('AJV Serialize array', function () {
+  ajvSerializeArray(multiArray)
+})
+
 suite.add('JSON.stringify long string', function () {
   JSON.stringify(str)
 })
@@ -130,6 +162,10 @@ suite.add('compile-json-stringify long string', function () {
   CJSStringifyString(str)
 })
 
+suite.add('AJV Serialize long string', function () {
+  ajvSerializeString(str)
+})
+
 suite.add('JSON.stringify short string', function () {
   JSON.stringify('hello world')
 })
@@ -142,6 +178,10 @@ suite.add('compile-json-stringify short string', function () {
   CJSStringifyString('hello world')
 })
 
+suite.add('AJV Serialize short string', function () {
+  ajvSerializeString('hello world')
+})
+
 suite.add('JSON.stringify obj', function () {
   JSON.stringify(obj)
 })
@@ -154,6 +194,10 @@ suite.add('compile-json-stringify obj', function () {
   CJSStringify(obj)
 })
 
+suite.add('AJV Serialize obj', function () {
+  ajvSerialize(obj)
+})
+
 suite.add('JSON stringify date', function () {
   JSON.stringify(date)
 })

package/build-schema-validator.js

@@ -1,21 +1,26 @@
 'use strict'
 
 const Ajv = require('ajv')
+const standaloneCode = require('ajv/dist/standalone').default
+const ajvFormats = require('ajv-formats')
 const fs = require('fs')
 const path = require('path')
-const pack = require('ajv-pack')
 
 const ajv = new Ajv({
-  sourceCode: true // this option is required by ajv-pack
+  addUsedSchema: false,
+  allowUnionTypes: true,
+  code: {
+    source: true,
+    lines: true,
+    optimize: 3
+  }
 })
+ajvFormats(ajv)
 
-const validate = ajv.compile(require('ajv/lib/refs/json-schema-draft-07.json'))
+const schema = require('ajv/lib/refs/json-schema-draft-07.json')
+const validate = ajv.compile(schema)
+const validationCode = standaloneCode(ajv, validate)
 
-const moduleCode = `// This file is autogenerated by ${path.basename(__filename)}, do not edit
-
-function nop () { return true }
-
-${pack(ajv, validate).replace(/root\.refVal\[0\]/gm, 'nop')}
-`
+const moduleCode = `/* CODE GENERATED BY '${path.basename(__filename)}' DO NOT EDIT! */\n${validationCode}`
 
 fs.writeFileSync(path.join(__dirname, 'schema-validator.js'), moduleCode)

package/index.js

@@ -3,6 +3,7 @@
 /* eslint no-prototype-builtins: 0 */
 
 const Ajv = require('ajv')
+const ajvFormats = require('ajv-formats')
 const merge = require('deepmerge')
 const clone = require('rfdc')({ proto: true })
 const fjsCloned = Symbol('fast-json-stringify.cloned')
@@ -10,13 +11,6 @@ const fjsCloned = Symbol('fast-json-stringify.cloned')
 const validate = require('./schema-validator')
 let stringSimilarity = null
 
-let isLong
-try {
-  isLong = require('long').isLong
-} catch (e) {
-  isLong = null
-}
-
 const addComma = `
   if (addComma) {
     json += ','
@@ -33,7 +27,7 @@ function isValidSchema (schema, name) {
       name = ''
     }
     const first = validate.errors[0]
-    const err = new Error(`${name}schema is invalid: data${first.dataPath} ${first.message}`)
+    const err = new Error(`${name}schema is invalid: data${first.instancePath} ${first.message}`)
     err.errors = isValidSchema.errors
     throw err
   }
@@ -47,10 +41,12 @@ function mergeLocation (source, dest) {
   }
 }
 
-const referenceSerializersMap = new Map()
+const arrayItemsReferenceSerializersMap = new Map()
+const objectReferenceSerializersMap = new Map()
 
 function build (schema, options) {
-  referenceSerializersMap.clear()
+  arrayItemsReferenceSerializersMap.clear()
+  objectReferenceSerializersMap.clear()
   options = options || {}
   isValidSchema(schema)
   if (options.schema) {
@@ -77,7 +73,39 @@ function build (schema, options) {
   code += `
     ${asFunctions}
 
-    var isLong = ${isLong ? isLong.toString() : false}
+    
+    /**
+     * Used by schemas that are dependant on calling 'ajv.validate' during runtime,
+     * it stores the value of the '$id' property of the schema (if it has it) inside
+     * a cache which is used to figure out if the schema was compiled into a validator
+     * by ajv on a previous call, if it was then the '$id' string will be used to 
+     * invoke 'ajv.validate', this allows:
+     * 
+     * 1. Schemas that depend on ajv.validate calls to leverage ajv caching system.
+     * 2. To avoid errors, since directly invoking 'ajv.validate' with the same 
+     * schema (that contains an '$id' property) twice will throw an error.
+     */
+    const $validateWithAjv = (function() {
+      const cache = new Set()
+
+      return function (schema, target) {
+        const id = schema.$id
+        
+        if (!id) {
+          return ajv.validate(schema, target)
+        }
+
+        const cached = cache.has(id)
+
+        if (cached) {
+          return ajv.validate(id, target)
+        } else {
+          cache.add(id)
+          return ajv.validate(schema, target)
+        }
+      }
+    })()
+
 
     function parseInteger(int) { return Math.${intParseFunctionName}(int) }
     `
@@ -136,7 +164,9 @@ function build (schema, options) {
      return ${main}
   `
 
-  const dependencies = [new Ajv(options.ajv)]
+  const ajvInstance = new Ajv(options.ajv)
+  ajvFormats(ajvInstance)
+  const dependencies = [ajvInstance]
   const dependenciesName = ['ajv']
   dependenciesName.push(code)
 
@@ -147,7 +177,8 @@ function build (schema, options) {
     return dependenciesName
   }
 
-  referenceSerializersMap.clear()
+  arrayItemsReferenceSerializersMap.clear()
+  objectReferenceSerializersMap.clear()
 
   return (Function.apply(null, dependenciesName).apply(null, dependencies))
 }
@@ -239,9 +270,7 @@ function $asNull () {
 }
 
 function $asInteger (i) {
-  if (isLong && isLong(i)) {
-    return i.toString()
-  } else if (typeof i === 'bigint') {
+  if (typeof i === 'bigint') {
     return i.toString()
   } else if (Number.isInteger(i)) {
     return $asNumber(i)
@@ -399,51 +428,60 @@ function addPatternProperties (location) {
     } catch (err) {
       throw new Error(`${err.message}. Found at ${regex} matching ${JSON.stringify(pp[regex])}`)
     }
-    code += `
-        if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {
-    `
+
+    const ifPpKeyExists = `if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {`
+
     if (type === 'object') {
       code += `${buildObject(ppLocation, '', 'buildObjectPP' + index)}
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + buildObjectPP${index}(obj[keys[i]])
       `
     } else if (type === 'array') {
       code += `${buildArray(ppLocation, '', 'buildArrayPP' + index)}
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + buildArrayPP${index}(obj[keys[i]])
       `
     } else if (type === 'null') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) +':null'
       `
     } else if (type === 'string') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + ${stringSerializer}(obj[keys[i]])
       `
     } else if (type === 'integer') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asInteger(obj[keys[i]])
       `
     } else if (type === 'number') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asNumber(obj[keys[i]])
       `
     } else if (type === 'boolean') {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asBoolean(obj[keys[i]])
       `
     } else if (type === undefined) {
       code += `
+          ${ifPpKeyExists}
           ${addComma}
           json += $asString(keys[i]) + ':' + $asAny(obj[keys[i]])
       `
     } else {
       code += `
+        ${ifPpKeyExists}
         throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
       `
     }
@@ -506,22 +544,11 @@ function additionalProperty (location) {
   } else if (type === 'integer') {
     code += `
         var t = Number(obj[keys[i]])
+        if (!isNaN(t)) {
+          ${addComma}
+          json += $asString(keys[i]) + ':' + t
+        }
     `
-    if (isLong) {
-      code += `
-          if (isLong(obj[keys[i]]) || !isNaN(t)) {
-            ${addComma}
-            json += $asString(keys[i]) + ':' + $asInteger(obj[keys[i]])
-          }
-      `
-    } else {
-      code += `
-          if (!isNaN(t)) {
-            ${addComma}
-            json += $asString(keys[i]) + ':' + t
-          }
-      `
-    }
   } else if (type === 'number') {
     code += `
         var t = Number(obj[keys[i]])
@@ -723,33 +750,12 @@ function buildCode (location, code, laterCode, name) {
     } else if (type === 'integer') {
       code += `
           var rendered = false
-      `
-      if (isLong) {
-        code += `
-            if (isLong(obj[${sanitized}])) {
-              ${addComma}
-              json += ${asString} + ':' + obj[${sanitized}].toString()
-              rendered = true
-            } else {
-              var t = Number(obj[${sanitized}])
-              if (!isNaN(t)) {
-                ${addComma}
-                json += ${asString} + ':' + t
-                rendered = true
-              }
-            }
-        `
-      } else {
-        code += `
-            var t = $asInteger(obj[${sanitized}])
-            if (!isNaN(t)) {
-              ${addComma}
-              json += ${asString} + ':' + t
-              rendered = true
-            }
-        `
-      }
-      code += `
+          var t = $asInteger(obj[${sanitized}])
+          if (!isNaN(t)) {
+            ${addComma}
+            json += ${asString} + ':' + t
+            rendered = true
+          }
           if (rendered) {
       `
     } else {
@@ -807,6 +813,12 @@ function buildCode (location, code, laterCode, name) {
     `
   }
 
+  if (schema.allOf) {
+    const builtCode = buildCodeWithAllOfs(location, code, laterCode, name)
+    code = builtCode.code
+    laterCode = builtCode.laterCode
+  }
+
   return { code: code, laterCode: laterCode }
 }
 
@@ -863,7 +875,7 @@ function addIfThenElse (location, name) {
   let mergedLocation = mergeLocation(location, { schema: merged })
 
   code += `
-    valid = ajv.validate(${JSON.stringify(i)}, obj)
+    valid = $validateWithAjv(${JSON.stringify(i)}, obj)
     if (valid) {
   `
   if (merged.if && merged.then) {
@@ -922,6 +934,16 @@ function buildObject (location, code, name) {
       }
   `
   }
+
+  if (objectReferenceSerializersMap.has(schema)) {
+    code += `
+      return ${objectReferenceSerializersMap.get(schema)}(input)
+    }
+    `
+    return code
+  }
+  objectReferenceSerializersMap.set(schema, name)
+
   code += `
       var obj = ${toJSON('input')}
       var json = '{'
@@ -978,14 +1000,14 @@ function buildArray (location, code, name, key = null) {
     location = refFinder(schema.items.$ref, location)
     schema.items = location.schema
 
-    if (referenceSerializersMap.has(schema.items)) {
+    if (arrayItemsReferenceSerializersMap.has(schema.items)) {
       code += `
-      return ${referenceSerializersMap.get(schema.items)}(obj)
+      return ${arrayItemsReferenceSerializersMap.get(schema.items)}(obj)
       }
       `
       return code
     }
-    referenceSerializersMap.set(schema.items, name)
+    arrayItemsReferenceSerializersMap.set(schema.items, name)
   }
 
   let result = { code: '', laterCode: '' }
@@ -1203,7 +1225,7 @@ function nested (laterCode, name, key, location, subKey, isArray) {
           // 2. `nested`, through `buildCode`, replaces any reference in object properties with the actual schema
           // (see https://github.com/fastify/fast-json-stringify/blob/6da3b3e8ac24b1ca5578223adedb4083b7adf8db/index.js#L631)
           code += `
-            ${index === 0 ? 'if' : 'else if'}(ajv.validate(${JSON.stringify(location.schema)}, ${testValue}))
+            ${index === 0 ? 'if' : 'else if'}($validateWithAjv(${JSON.stringify(location.schema)}, ${testValue}))
               ${nestedResult.code}
           `
           laterCode = nestedResult.laterCode
@@ -1220,7 +1242,7 @@ function nested (laterCode, name, key, location, subKey, isArray) {
           const testValue = testSerializer !== undefined ? `${testSerializer}(obj${accessor}, true)` : `obj${accessor}`
           // see comment on anyOf about dereferencing the schema before calling ajv.validate
           code += `
-            ${index === 0 ? 'if' : 'else if'}(ajv.validate(${JSON.stringify(location.schema)}, ${testValue}))
+            ${index === 0 ? 'if' : 'else if'}($validateWithAjv(${JSON.stringify(location.schema)}, ${testValue}))
               ${nestedResult.code}
           `
           laterCode = nestedResult.laterCode
@@ -1335,7 +1357,9 @@ module.exports.restore = function (debugModeStr, options = {}) {
   const args = []
   if (debugModeStr.startsWith('ajv')) {
     dependencies.unshift('ajv')
-    args.push(new Ajv(options.ajv))
+    const ajvInstance = new Ajv(options.ajv)
+    ajvFormats(ajvInstance)
+    args.push(ajvInstance)
   }
 
   // eslint-disable-next-line

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "2.7.11",
+  "version": "3.0.1",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -30,11 +30,9 @@
   },
   "homepage": "https://github.com/fastify/fast-json-stringify#readme",
   "devDependencies": {
-    "ajv-pack": "^0.3.1",
     "benchmark": "^2.1.4",
     "compile-json-stringify": "^0.1.2",
     "is-my-json-valid": "^2.20.0",
-    "long": "^4.0.0",
     "moment": "^2.24.0",
     "pre-commit": "^1.2.2",
     "proxyquire": "^2.1.3",
@@ -45,7 +43,8 @@
     "webpack": "^5.40.0"
   },
   "dependencies": {
-    "ajv": "^6.11.0",
+    "ajv": "^8.6.2",
+    "ajv-formats": "^2.1.1",
     "deepmerge": "^4.2.2",
     "rfdc": "^1.2.0",
     "string-similarity": "^4.0.1"