fast-json-stringify 5.7.0 → 5.9.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Set default behavior to automatically convert line endings
+* text=auto eol=lf

package/.github/workflows/benchmark.yml

@@ -1,4 +1,4 @@
-name: Benchmark
+name: Benchmark PR
 
 on:
   pull_request_target:
@@ -11,25 +11,18 @@ jobs:
     permissions:
       contents: read
     outputs:
-      PR-BENCH-14: ${{ steps.benchmark-pr.outputs.BENCH_RESULT14 }}
-      PR-BENCH-16: ${{ steps.benchmark-pr.outputs.BENCH_RESULT16 }}
-      PR-BENCH-18: ${{ steps.benchmark-pr.outputs.BENCH_RESULT18 }}
-      MAIN-BENCH-14: ${{ steps.benchmark-main.outputs.BENCH_RESULT14 }}
-      MAIN-BENCH-16: ${{ steps.benchmark-main.outputs.BENCH_RESULT16 }}
-      MAIN-BENCH-18: ${{ steps.benchmark-main.outputs.BENCH_RESULT18 }}
-    strategy:
-      matrix:
-        node-version: [14, 16, 18]
+      PR-BENCH: ${{ steps.benchmark-pr.outputs.BENCH_RESULT }}
+      MASTER-BENCH: ${{ steps.benchmark-master.outputs.BENCH_RESULT }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
           ref: ${{github.event.pull_request.head.sha}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
-          node-version: ${{ matrix.node-version }}
+          node-version: 18
 
       - name: Install
         run: |
@@ -38,15 +31,15 @@ jobs:
       - name: Run benchmark
         id: benchmark-pr
         run: |
-          npm run --silent benchmark > ./bench-result
+          npm run --silent bench > ./bench-result
           content=$(cat ./bench-result)
           content="${content//'%'/'%25'}"
           content="${content//$'\n'/'%0A'}"
           content="${content//$'\r'/'%0D'}"
-          echo "::set-output name=BENCH_RESULT${{matrix.node-version}}::$content"
+          echo "::set-output name=BENCH_RESULT::$content"
 
-      # main benchmark
-      - uses: actions/checkout@v3
+      # master benchmark
+      - uses: actions/checkout@v4
         with:
           ref: 'master'
 
@@ -57,14 +50,15 @@ jobs:
       - name: Run benchmark
         id: benchmark-master
         run: |
-          npm run --silent benchmark > ./bench-result
+          npm run --silent bench > ./bench-result
           content=$(cat ./bench-result)
           content="${content//'%'/'%25'}"
           content="${content//$'\n'/'%0A'}"
           content="${content//$'\r'/'%0D'}"
-          echo "::set-output name=BENCH_RESULT${{matrix.node-version}}::$content"
+          echo "::set-output name=BENCH_RESULT::$content"
 
   output-benchmark:
+    if: "always()"
     needs: [benchmark]
     runs-on: ubuntu-latest
     permissions:
@@ -75,38 +69,13 @@ jobs:
         with:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           message: |
-            **Node**: 14
             **PR**:
             ```
-            ${{ needs.benchmark.outputs.PR-BENCH-14 }}
+            ${{ needs.benchmark.outputs.PR-BENCH }}
             ```
-            **MAIN**:
+            **MASTER**:
             ```
-            ${{ needs.benchmark.outputs.MAIN-BENCH-14 }}
-            ```
-            
-            ---
-            
-            **Node**: 16
-            **PR**:
-            ```
-            ${{ needs.benchmark.outputs.PR-BENCH-16 }}
-            ```
-            **MAIN**:
-            ```
-            ${{ needs.benchmark.outputs.MAIN-BENCH-16 }}
-            ```
-            
-            ---
-            
-            **Node**: 18
-            **PR**:
-            ```
-            ${{ needs.benchmark.outputs.PR-BENCH-18 }}
-            ```
-            **MAIN**:
-            ```
-            ${{ needs.benchmark.outputs.MAIN-BENCH-18 }}
+            ${{ needs.benchmark.outputs.MASTER-BENCH }}
             ```
             
       - uses: actions-ecosystem/action-remove-labels@v1

package/.github/workflows/ci.yml

@@ -2,6 +2,11 @@ name: CI
 
 on:
   push:
+    branches:
+     - main
+     - master
+     - next
+     - 'v*'
     paths-ignore:
       - 'docs/**'
       - '*.md'

package/README.md

@@ -692,7 +692,7 @@ The standalone mode is used to compile the code that can be directly run by `nod
 itself. You need to have `fast-json-stringify` installed for the standalone code to work.
 
 ```js
-const fs = require('fs')
+const fs = require('node:fs')
 const code = fastJson({
   title: 'default string',
   type: 'object',

package/benchmark/bench-cmp-branch.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { spawn } = require('child_process')
+const { spawn } = require('node:child_process')
 
 const cliSelect = require('cli-select')
 const simpleGit = require('simple-git')

package/benchmark/bench-thread.js

@@ -1,9 +1,9 @@
 'use strict'
 
-const { workerData: benchmark, parentPort } = require('worker_threads')
+const { workerData: benchmark, parentPort } = require('node:worker_threads')
 
 const Benchmark = require('benchmark')
-Benchmark.options.minSamples = 500
+Benchmark.options.minSamples = 100
 
 const suite = Benchmark.Suite()
 

package/benchmark/bench.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const path = require('path')
-const { Worker } = require('worker_threads')
+const path = require('node:path')
+const { Worker } = require('node:worker_threads')
 
 const BENCH_THREAD_PATH = path.join(__dirname, 'bench-thread.js')
 
@@ -18,6 +18,11 @@ function getRandomInt (max) {
   return Math.floor(Math.random() * max)
 }
 
+let longSimpleString = ''
+for (let i = 0; i < LONG_STRING_LENGTH; i++) {
+  longSimpleString += i
+}
+
 let longString = ''
 for (let i = 0; i < LONG_STRING_LENGTH; i++) {
   longString += i
@@ -42,6 +47,20 @@ const benchmarks = [
     },
     input: 'hello world'
   },
+  {
+    name: 'short string with double quote',
+    schema: {
+      type: 'string'
+    },
+    input: 'hello " world'
+  },
+  {
+    name: 'long string without double quotes',
+    schema: {
+      type: 'string'
+    },
+    input: longSimpleString
+  },
   {
     name: 'long string',
     schema: {
@@ -235,6 +254,28 @@ const benchmarks = [
     },
     input: { firstName: 'Max', lastName: 'Power', age: 22 }
   },
+  {
+    name: 'simple object with required fields',
+    schema: {
+      title: 'Example Schema',
+      type: 'object',
+      properties: {
+        firstName: {
+          type: 'string'
+        },
+        lastName: {
+          type: ['string', 'null']
+        },
+        age: {
+          description: 'Age in years',
+          type: 'integer',
+          minimum: 0
+        }
+      },
+      required: ['firstName', 'lastName', 'age']
+    },
+    input: { firstName: 'Max', lastName: 'Power', age: 22 }
+  },
   {
     name: 'object with const string property',
     schema: {

package/build/build-schema-validator.js

@@ -3,8 +3,8 @@
 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 fs = require('node:fs')
+const path = require('node:path')
 
 const ajv = new Ajv({
   addUsedSchema: false,

package/examples/example.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const fastJson = require('..')
 const stringify = fastJson({
   title: 'Example Schema',

package/examples/server.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const http = require('http')
+const http = require('node:http')
 
 const stringify = require('fast-json-stringify')({
   type: 'object',

package/index.js

@@ -4,14 +4,16 @@
 
 const merge = require('@fastify/deepmerge')()
 const clone = require('rfdc')({ proto: true })
-const { randomUUID } = require('crypto')
+const { randomUUID } = require('node:crypto')
+const { RefResolver } = require('json-schema-ref-resolver')
 
 const validate = require('./lib/schema-validator')
 const Serializer = require('./lib/serializer')
 const Validator = require('./lib/validator')
-const RefResolver = require('./lib/ref-resolver')
 const Location = require('./lib/location')
 
+const SINGLE_TICK = /'/g
+
 let largeArraySize = 2e4
 let largeArrayMechanism = 'default'
 
@@ -53,8 +55,7 @@ function resolveRef (context, location, ref) {
   const jsonPointer = ref.slice(hashIndex) || '#'
 
   const schema = context.refResolver.getSchema(schemaId, jsonPointer)
-
-  if (schema === undefined) {
+  if (schema === null) {
     throw new Error(`Cannot find reference "${ref}"`)
   }
 
@@ -66,6 +67,13 @@ function resolveRef (context, location, ref) {
   return newLocation
 }
 
+function getSchemaId (schema, rootSchemaId) {
+  if (schema.$id && schema.$id.charAt(0) !== '#') {
+    return schema.$id
+  }
+  return rootSchemaId
+}
+
 function build (schema, options) {
   isValidSchema(schema)
 
@@ -76,17 +84,25 @@ function build (schema, options) {
     functionsCounter: 0,
     functionsNamesBySchema: new Map(),
     options,
+    wrapObjects: true,
     refResolver: new RefResolver(),
     rootSchemaId: schema.$id || randomUUID(),
     validatorSchemasIds: new Set()
   }
 
-  context.refResolver.addSchema(schema, context.rootSchemaId)
+  const schemaId = getSchemaId(schema, context.rootSchemaId)
+  if (!context.refResolver.hasSchema(schemaId)) {
+    context.refResolver.addSchema(schema, context.rootSchemaId)
+  }
 
   if (options.schema) {
-    for (const key of Object.keys(options.schema)) {
-      isValidSchema(options.schema[key], key)
-      context.refResolver.addSchema(options.schema[key], key)
+    for (const key in options.schema) {
+      const schema = options.schema[key]
+      const schemaId = getSchemaId(schema, key)
+      if (!context.refResolver.hasSchema(schemaId)) {
+        isValidSchema(schema, key)
+        context.refResolver.addSchema(schema, key)
+      }
     }
   }
 
@@ -123,7 +139,7 @@ function build (schema, options) {
 
   // If we have only the invocation of the 'anonymous0' function, we would
   // basically just wrap the 'anonymous0' function in the 'main' function and
-  // and the overhead of the intermediate variabe 'json'. We can avoid the
+  // and the overhead of the intermediate variable 'json'. We can avoid the
   // wrapping and the unnecessary memory allocation by aliasing 'anonymous0' to
   // 'main'
   if (code === 'json += anonymous0(input)') {
@@ -297,59 +313,96 @@ function buildExtraObjectPropertiesSerializer (context, location) {
 }
 
 function buildInnerObject (context, location) {
+  let code = ''
   const schema = location.schema
   const required = schema.required || []
 
-  let code = ''
-
   const propertiesLocation = location.getPropertyLocation('properties')
-  Object.keys(schema.properties || {}).forEach((key) => {
-    let propertyLocation = propertiesLocation.getPropertyLocation(key)
-    if (propertyLocation.schema.$ref) {
-      propertyLocation = resolveRef(context, location, propertyLocation.schema.$ref)
-    }
 
-    const sanitized = JSON.stringify(key)
+  const requiredWithDefault = []
+  const requiredWithoutDefault = []
+  if (schema.properties) {
+    for (const key of Object.keys(schema.properties)) {
+      if (required.indexOf(key) === -1) {
+        continue
+      }
+      let propertyLocation = propertiesLocation.getPropertyLocation(key)
+      if (propertyLocation.schema.$ref) {
+        propertyLocation = resolveRef(context, location, propertyLocation.schema.$ref)
+      }
 
-    // Using obj['key'] !== undefined instead of obj.hasOwnProperty(prop) for perf reasons,
-    // see https://github.com/mcollina/fast-json-stringify/pull/3 for discussion.
+      const sanitizedKey = JSON.stringify(key)
 
-    code += `
-      if (obj[${sanitized}] !== undefined) {
-        ${addComma}
-        json += ${JSON.stringify(sanitized + ':')}
-      `
+      // Using obj['key'] !== undefined instead of obj.hasOwnProperty(prop) for perf reasons,
+      // see https://github.com/mcollina/fast-json-stringify/pull/3 for discussion.
+      const defaultValue = propertyLocation.schema.default
+      if (defaultValue === undefined) {
+        code += `if (obj[${sanitizedKey}] === undefined) throw new Error('${sanitizedKey} is required!')\n`
+        requiredWithoutDefault.push(key)
+      }
+      requiredWithDefault.push(key)
+    }
+  }
 
-    code += buildValue(context, propertyLocation, `obj[${sanitized}]`)
+  // handle extraneous required fields
+  for (const requiredProperty of required) {
+    if (requiredWithDefault.indexOf(requiredProperty) !== -1) continue
+    code += `if (obj['${requiredProperty}'] === undefined) throw new Error('"${requiredProperty}" is required!')\n`
+  }
 
-    const defaultValue = propertyLocation.schema.default
-    if (defaultValue !== undefined) {
-      code += `
-      } else {
+  code += `
+    let addComma = false
+    let json = '${context.wrapObjects ? '{' : ''}'
+  `
+  const wrapObjects = context.wrapObjects
+  context.wrapObjects = true
+
+  if (schema.properties) {
+    for (const key of Object.keys(schema.properties)) {
+      let propertyLocation = propertiesLocation.getPropertyLocation(key)
+      if (propertyLocation.schema.$ref) {
+        propertyLocation = resolveRef(context, location, propertyLocation.schema.$ref)
+      }
+
+      const sanitizedKey = JSON.stringify(key)
+
+      if (requiredWithoutDefault.indexOf(key) !== -1) {
+        code += `
         ${addComma}
-        json += ${JSON.stringify(sanitized + ':' + JSON.stringify(defaultValue))}
+        json += ${JSON.stringify(sanitizedKey + ':')}
+        ${buildValue(context, propertyLocation, `obj[${sanitizedKey}]`)}
       `
-    } else if (required.includes(key)) {
-      code += `
       } else {
-        throw new Error('${sanitized} is required!')
-      `
-    }
-
-    code += `
+        // Using obj['key'] !== undefined instead of obj.hasOwnProperty(prop) for perf reasons,
+        // see https://github.com/mcollina/fast-json-stringify/pull/3 for discussion.
+        code += `
+        if (obj[${sanitizedKey}] !== undefined) {
+          ${addComma}
+          json += ${JSON.stringify(sanitizedKey + ':')}
+          ${buildValue(context, propertyLocation, `obj[${sanitizedKey}]`)}
+        }
+        `
+        const defaultValue = propertyLocation.schema.default
+        if (defaultValue !== undefined) {
+          code += `
+        else {
+          ${addComma}
+          json += ${JSON.stringify(sanitizedKey + ':' + JSON.stringify(defaultValue))}
+        }
+        `
+        }
       }
-    `
-  })
-
-  for (const requiredProperty of required) {
-    if (schema.properties && schema.properties[requiredProperty] !== undefined) continue
-    code += `if (obj['${requiredProperty}'] === undefined) throw new Error('"${requiredProperty}" is required!')\n`
+    }
   }
 
   if (schema.patternProperties || schema.additionalProperties) {
     code += buildExtraObjectPropertiesSerializer(context, location)
   }
 
+  context.wrapObjects = wrapObjects
+  code += `
+  return json${context.wrapObjects ? ' + \'}\'' : ''}
+  `
   return code
 }
 
@@ -504,19 +557,13 @@ function buildObject (context, location) {
   }
 
   let functionCode = `
-    function ${functionName} (input) {
-      // ${schemaRef}
   `
 
   functionCode += `
+    // ${schemaRef}
+    function ${functionName} (input) {
       const obj = ${toJSON('input')}
-      let json = '{'
-      let addComma = false
-  `
-
-  functionCode += buildInnerObject(context, location)
-  functionCode += `
-      return json + '}'
+      ${buildInnerObject(context, location)}
     }
   `
 
@@ -789,7 +836,7 @@ function buildConstSerializer (location, input) {
     `
   }
 
-  code += `json += '${JSON.stringify(schema.const)}'`
+  code += `json += '${JSON.stringify(schema.const).replace(SINGLE_TICK, "\\'")}'`
 
   if (hasNullType) {
     code += `
@@ -832,9 +879,19 @@ function buildValue (context, location, input) {
 
   let code = ''
 
-  if (type === undefined && (schema.anyOf || schema.oneOf)) {
+  if ((type === undefined || type === 'object') && (schema.anyOf || schema.oneOf)) {
     context.validatorSchemasIds.add(location.getSchemaId())
 
+    if (schema.type === 'object') {
+      context.wrapObjects = false
+      const funcName = buildObject(context, location)
+      code += `
+        json += '{'
+        json += ${funcName}(${input})
+        json += ','
+      `
+    }
+
     const type = schema.anyOf ? 'anyOf' : 'oneOf'
     const anyOfLocation = location.getPropertyLocation(type)
 
@@ -856,6 +913,12 @@ function buildValue (context, location, input) {
     code += `
       else throw new TypeError(\`The value of '${schemaRef}' does not match schema definition.\`)
     `
+    if (schema.type === 'object') {
+      code += `
+        json += '}'
+      `
+      context.wrapObjects = true
+    }
     return code
   }
 

package/lib/serializer.js

@@ -113,11 +113,10 @@ module.exports = class Serializer {
       }
     }
 
-    // Fast escape chars check
-    if (!STR_ESCAPE.test(str)) {
-      return '"' + str + '"'
-    } else if (str.length < 42) {
+    if (str.length < 42) {
       return this.asStringSmall(str)
+    } else if (STR_ESCAPE.test(str) === false) {
+      return '"' + str + '"'
     } else {
       return JSON.stringify(str)
     }
@@ -130,32 +129,32 @@ module.exports = class Serializer {
   // 34 and 92 happens all the time, so we
   // have a fast case for them
   asStringSmall (str) {
-    const l = str.length
+    const len = str.length
     let result = ''
-    let last = 0
-    let found = false
-    let surrogateFound = false
+    let last = -1
     let point = 255
+
     // eslint-disable-next-line
-    for (var i = 0; i < l && point >= 32; i++) {
+    for (var i = 0; i < len; i++) {
       point = str.charCodeAt(i)
+      if (point < 32) {
+        return JSON.stringify(str)
+      }
       if (point >= 0xD800 && point <= 0xDFFF) {
         // The current character is a surrogate.
-        surrogateFound = true
+        return JSON.stringify(str)
       }
-      if (point === 34 || point === 92) {
+      if (
+        point === 0x22 || // '"'
+        point === 0x5c // '\'
+      ) {
+        last === -1 && (last = 0)
         result += str.slice(last, i) + '\\'
         last = i
-        found = true
       }
     }
 
-    if (!found) {
-      result = str
-    } else {
-      result += str.slice(last)
-    }
-    return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
+    return (last === -1 && ('"' + str + '"')) || ('"' + result + str.slice(last) + '"')
   }
 
   getState () {

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.7.0",
+  "version": "5.9.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
+  "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
     "bench": "node ./benchmark/bench.js",
@@ -34,7 +35,7 @@
   "homepage": "https://github.com/fastify/fast-json-stringify#readme",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.26.5",
+    "@sinclair/typebox": "^0.31.1",
     "benchmark": "^2.1.4",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
@@ -42,7 +43,7 @@
     "simple-git": "^3.7.1",
     "standard": "^17.0.0",
     "tap": "^16.0.1",
-    "tsd": "^0.28.0",
+    "tsd": "^0.29.0",
     "webpack": "^5.40.0",
     "fast-json-stringify": "."
   },
@@ -52,7 +53,8 @@
     "ajv-formats": "^2.1.1",
     "fast-deep-equal": "^3.1.3",
     "fast-uri": "^2.1.0",
-    "rfdc": "^1.2.0"
+    "rfdc": "^1.2.0",
+    "json-schema-ref-resolver": "^1.0.1"
   },
   "standard": {
     "ignore": [

package/test/allof.test.js

@@ -220,6 +220,75 @@ test('object with nested allOfs', (t) => {
   t.equal(value, '{"id1":1,"id2":2,"id3":3}')
 })
 
+test('object with anyOf nested inside allOf', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with anyOf nested inside allOf',
+    type: 'object',
+    allOf: [
+      {
+        required: ['id1', 'obj'],
+        type: 'object',
+        properties: {
+          id1: {
+            type: 'integer'
+          },
+          obj: {
+            type: 'object',
+            properties: {
+              nested: { type: 'string' }
+            }
+          }
+        }
+      },
+      {
+        anyOf: [
+          {
+            type: 'object',
+            properties: {
+              id2: { type: 'string' }
+            },
+            required: ['id2']
+          },
+          {
+            type: 'object',
+            properties: {
+              id3: {
+                type: 'integer'
+              },
+              nestedObj: {
+                type: 'object',
+                properties: {
+                  nested: { type: 'string' }
+                }
+              }
+            },
+            required: ['id3']
+          },
+          {
+            type: 'object',
+            properties: {
+              id4: { type: 'integer' }
+            },
+            required: ['id4']
+          }
+        ]
+      }
+    ]
+  }
+
+  const stringify = build(schema)
+  const value = stringify({
+    id1: 1,
+    id3: 3,
+    id4: 4, // extra prop shouldn't be in result
+    obj: { nested: 'yes' },
+    nestedObj: { nested: 'yes' }
+  })
+  t.equal(value, '{"id1":1,"obj":{"nested":"yes"},"id3":3,"nestedObj":{"nested":"yes"}}')
+})
+
 test('object with $ref in allOf', (t) => {
   t.plan(1)
 

package/test/basic.test.js

@@ -344,7 +344,7 @@ test('patternProperties - throw on unknown type', (t) => {
   }
 })
 
-test('render a single quote as JSON', (t) => {
+test('render a double quote as JSON /1', (t) => {
   t.plan(2)
 
   const schema = {
@@ -360,6 +360,38 @@ test('render a single quote as JSON', (t) => {
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
+test('render a double quote as JSON /2', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+  const toStringify = 'double quote " 2'
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.equal(output, JSON.stringify(toStringify))
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('render a long string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+  const toStringify = 'the Ultimate Question of Life, the Universe, and Everything.'
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.equal(output, JSON.stringify(toStringify))
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
 test('returns JSON.stringify if schema type is boolean', t => {
   t.plan(1)
 

package/test/const.test.js

@@ -82,6 +82,26 @@ test('schema with const string and no input', (t) => {
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
+test('schema with const string that contains \'', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: "'bar'" }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: "'bar'"
+  })
+
+  t.equal(output, '{"foo":"\'bar\'"}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
 test('schema with const number', (t) => {
   t.plan(2)
 

package/test/ref.test.js

@@ -1377,7 +1377,10 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.equal(err.message, 'Cannot find reference "extrenal#/definitions/projectId"')
+      t.equal(
+        err.message,
+        'Cannot resolve ref "extrenal#/definitions/projectId". Schema with id "extrenal" is not found.'
+      )
     }
   })
 
@@ -2076,7 +2079,11 @@ test('should throw an Error if two non-identical schemas with same id are provid
     ]
   }
 
-  t.throws(() => build(schema), new Error('There is already another schema with id inner_schema'))
+  try {
+    build(schema)
+  } catch (err) {
+    t.equal(err.message, 'There is already another schema with id "inner_schema".')
+  }
 })
 
 test('ref internal - throw if schema has definition twice with different shape', (t) => {
@@ -2115,5 +2122,9 @@ test('ref internal - throw if schema has definition twice with different shape',
     }
   }
 
-  t.throws(() => build(schema), Error('There is already another schema with id test##uri'))
+  try {
+    build(schema)
+  } catch (err) {
+    t.equal(err.message, 'There is already another anchor "#uri" in a schema "test".')
+  }
 })

package/test/standalone-mode.test.js

@@ -2,8 +2,8 @@
 
 const test = require('tap').test
 const fjs = require('..')
-const fs = require('fs')
-const path = require('path')
+const fs = require('node:fs')
+const path = require('node:path')
 
 function build (opts, schema) {
   return fjs(schema || {

package/test/webpack.test.js

@@ -2,7 +2,7 @@
 
 const test = require('tap').test
 const webpack = require('webpack')
-const path = require('path')
+const path = require('node:path')
 
 test('the library should work with webpack', async (t) => {
   t.plan(1)

package/lib/ref-resolver.js

@@ -1,104 +0,0 @@
-'use strict'
-
-const deepEqual = require('fast-deep-equal')
-
-class RefResolver {
-  constructor () {
-    this.schemas = {}
-  }
-
-  addSchema (schema, schemaId) {
-    if (schema.$id !== undefined && schema.$id.charAt(0) !== '#') {
-      schemaId = schema.$id
-    }
-    if (this.getSchema(schemaId) === undefined) {
-      this.insertSchemaBySchemaId(schema, schemaId)
-      this.insertSchemaSubschemas(schema, schemaId)
-    }
-  }
-
-  getSchema (schemaId, jsonPointer = '#') {
-    const schema = this.schemas[schemaId]
-    if (schema === undefined) {
-      return undefined
-    }
-    if (schema.anchors[jsonPointer] !== undefined) {
-      return schema.anchors[jsonPointer]
-    }
-    return getDataByJSONPointer(schema.schema, jsonPointer)
-  }
-
-  getSchemaDependencies (schemaId, dependencies = {}) {
-    const schema = this.schemas[schemaId]
-
-    for (const dependencySchemaId of schema.dependencies) {
-      if (dependencies[dependencySchemaId] !== undefined) continue
-      dependencies[dependencySchemaId] = this.getSchema(dependencySchemaId)
-      this.getSchemaDependencies(dependencySchemaId, dependencies)
-    }
-
-    return dependencies
-  }
-
-  insertSchemaBySchemaId (schema, schemaId) {
-    if (
-      this.schemas[schemaId] !== undefined &&
-      !deepEqual(schema, this.schemas[schemaId].schema)
-    ) {
-      throw new Error(`There is already another schema with id ${schemaId}`)
-    }
-    this.schemas[schemaId] = { schema, anchors: {}, dependencies: [] }
-  }
-
-  insertSchemaByAnchor (schema, schemaId, anchor) {
-    const { anchors } = this.schemas[schemaId]
-    if (
-      anchors[anchor] !== undefined &&
-      !deepEqual(schema, anchors[anchor])
-    ) {
-      throw new Error(`There is already another schema with id ${schemaId}#${anchor}`)
-    }
-    anchors[anchor] = schema
-  }
-
-  insertSchemaSubschemas (schema, rootSchemaId) {
-    const schemaId = schema.$id
-    if (schemaId !== undefined && typeof schemaId === 'string') {
-      if (schemaId.charAt(0) === '#') {
-        this.insertSchemaByAnchor(schema, rootSchemaId, schemaId)
-      } else {
-        this.insertSchemaBySchemaId(schema, schemaId)
-        rootSchemaId = schemaId
-      }
-    }
-
-    const ref = schema.$ref
-    if (ref !== undefined && typeof ref === 'string') {
-      if (ref.charAt(0) !== '#') {
-        const dependencySchemaId = ref.split('#')[0]
-        this.schemas[rootSchemaId].dependencies.push(dependencySchemaId)
-      }
-    }
-
-    for (const key in schema) {
-      if (typeof schema[key] === 'object' && schema[key] !== null) {
-        this.insertSchemaSubschemas(schema[key], rootSchemaId)
-      }
-    }
-  }
-}
-
-function getDataByJSONPointer (data, jsonPointer) {
-  const parts = jsonPointer.split('/')
-  let current = data
-  for (const part of parts) {
-    if (part === '' || part === '#') continue
-    if (typeof current !== 'object' || current === null) {
-      return undefined
-    }
-    current = current[part]
-  }
-  return current
-}
-
-module.exports = RefResolver