modified

build/node_modules/json-schema-deref-sync/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - "8.0"
+  - "8"
+  - "10"

build/node_modules/json-schema-deref-sync/ISSUE_TEMPLATE.md

@@ -0,0 +1,7 @@
+1) What version of the module is the issue happening on? Does the issue happen on latest version?
+
+2) What platform and Node.js version? (For example Node.js 0.12 on Mac OS X)
+
+3) Sample source code or steps to reproduce
+
+(Write description of your issue here, stack traces from errors and code that reproduces the issue are helpful)

build/node_modules/json-schema-deref-sync/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Bojan D.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

build/node_modules/json-schema-deref-sync/LICENSE.txt

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2014 Bojan Djurkovic
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

build/node_modules/json-schema-deref-sync/README.md

@@ -0,0 +1,102 @@
+# json-schema-deref-sync
+
+[![npm version](https://img.shields.io/npm/v/json-schema-deref-sync.svg?style=flat-square)](https://www.npmjs.com/package/json-schema-deref-sync)
+[![build status](https://img.shields.io/travis/bojand/json-schema-deref-sync/master.svg?style=flat-square)](https://travis-ci.org/bojand/json-schema-deref-sync)
+[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](https://standardjs.com)
+[![License](https://img.shields.io/github/license/bojand/json-schema-deref-sync.svg?style=flat-square)](https://raw.githubusercontent.com/bojand/json-schema-deref-sync/master/LICENSE)
+
+Dereference JSON pointers in a JSON schemas with their true resolved values.
+Basically a lighter, synchronous version of [json-schema-deref](https://github.com/bojand/json-schema-deref) but omits web references.
+
+## Installation
+
+`npm install json-schema-deref-sync`
+
+## Overview
+
+Let's say you have the following JSON Schema:
+
+```json
+{
+  "description": "Just some JSON schema.",
+  "title": "Basic Widget",
+  "type": "object",
+  "definitions": {
+    "id": {
+      "description": "unique identifier",
+      "type": "string",
+      "minLength": 1,
+      "readOnly": true
+    }
+  },
+  "properties": {
+    "id": {
+      "$ref": "#/definitions/id"
+    },
+    "bar": {
+      "$ref": "bar.json"
+    }
+  }
+}
+```
+
+Sometimes you just want that schema to be fully expanded, with `$ref`'s being their (true) resolved values:
+
+```json
+{
+  "description": "Just some JSON schema.",
+  "title": "Basic Widget",
+  "type": "object",
+  "definitions": {
+    "id": {
+      "description": "unique identifier",
+      "type": "string",
+      "minLength": 1,
+      "readOnly": true
+    }
+  },
+  "properties": {
+    "id": {
+      "description": "unique identifier",
+      "type": "string",
+      "minLength": 1,
+      "readOnly": true
+    },
+    "bar": {
+      "description": "bar property",
+      "type": "boolean"
+    }
+  }
+}
+```
+
+This utility lets you do that:
+
+
+```js
+var deref = require('json-schema-deref-sync');
+var myschema = require('schema.json');
+
+var fullSchema = deref(myschema);
+```
+
+## API Reference
+
+<a name="deref"></a>
+
+## deref(schema, options) ⇒ <code>Object</code> \| <code>Error</code>
+Derefs <code>$ref</code>'s in JSON Schema to actual resolved values. Supports local, and file refs.
+
+**Kind**: global function  
+**Returns**: <code>Object</code> \| <code>Error</code> - the deref schema oran instance of <code>Error</code> if error.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| schema | <code>Object</code> | The JSON schema |
+| options | <code>Object</code> | options |
+| options.baseFolder | <code>String</code> | the base folder to get relative path files from. Default is <code>process.cwd()</code> |
+| options.failOnMissing | <code>Boolean</code> | By default missing / unresolved refs will be left as is with their ref value intact.                                        If set to <code>true</code> we will error out on first missing ref that we cannot                                        resolve. Default: <code>false</code>. |
+| options.mergeAdditionalProperties | <code>Boolean</code> | By default properties in a object with $ref will be removed in the output.                                                    If set to <code>true</code> they will be added/overwrite the output. This will use lodash's merge function.                                                    Default: <code>false</code>. |
+| options.removeIds | <code>Boolean</code> | By default <code>$id</code> fields will get copied when dereferencing.                                    If set to <code>true</code> they will be removed.  Merged properties will not get removed.                                    Default: <code>false</code>. |
+| options.loaders | <code>Object</code> | A hash mapping reference types (e.g., 'file') to loader functions. |
+

build/node_modules/json-schema-deref-sync/lib/index.js

@@ -0,0 +1,317 @@
+const path = require('path')
+const _ = require('lodash')
+const clone = require('clone')
+const traverse = require('traverse')
+const DAG = require('dag-map')
+const md5 = require('md5')
+const utils = require('./utils')
+const fileLoader = require('./loaders/file')
+
+const defaults = {
+  baseFolder: process.cwd()
+}
+
+let cache = {}
+
+const loaders = {
+  file: fileLoader
+}
+
+function getLoader (refType, options) {
+  return _.get(options, `loaders.${refType}`, loaders[refType]);
+}
+
+/**
+ * Returns the reference schema that refVal points to.
+ * If the ref val points to a ref within a file, the file is loaded and fully derefed, before we get the
+ * pointing property. Derefed files are cached.
+ *
+ * @param refVal
+ * @param refType
+ * @param parent
+ * @param options
+ * @param state
+ * @private
+ */
+function getRefSchema (refVal, refType, parent, options, state) {
+  const loader = getLoader(refType, options)
+  if (refType && loader) {
+    let newVal
+    let oldBasePath
+    let loaderValue
+    let filePath
+    let fullRefFilePath
+
+    if (refType === 'file') {
+      filePath = utils.getRefFilePath(refVal)
+      fullRefFilePath = utils.isAbsolute(filePath) ? filePath : path.resolve(state.cwd, filePath)
+
+      if (cache[fullRefFilePath]) {
+        loaderValue = cache[fullRefFilePath]
+      }
+    }
+
+    if (!loaderValue) {
+      loaderValue = loader(refVal, options)
+      if (loaderValue) {
+        // adjust base folder if needed so that we can handle paths in nested folders
+        if (refType === 'file') {
+          let dirname = path.dirname(filePath)
+          if (dirname === '.') {
+            dirname = ''
+          }
+
+          if (dirname) {
+            oldBasePath = state.cwd
+            const newBasePath = path.resolve(state.cwd, dirname)
+            options.baseFolder = state.cwd = newBasePath
+          }
+        }
+
+        loaderValue = derefSchema(loaderValue, options, state)
+
+        // reset
+        if (oldBasePath) {
+          options.baseFolder = state.cwd = oldBasePath
+        }
+      }
+    }
+
+    if (loaderValue) {
+      if (refType === 'file' && fullRefFilePath && !cache[fullRefFilePath]) {
+        cache[fullRefFilePath] = loaderValue
+      }
+
+      if (refVal.indexOf('#') >= 0) {
+        const refPaths = refVal.split('#')
+        const refPath = refPaths[1]
+        const refNewVal = utils.getRefPathValue(loaderValue, refPath)
+        if (refNewVal) {
+          newVal = refNewVal
+        }
+      } else {
+        newVal = loaderValue
+      }
+    }
+
+    return newVal
+  } else if (refType === 'local') {
+    return utils.getRefPathValue(parent, refVal)
+  }
+}
+
+/**
+ * Add to state history
+ * @param {Object} state the state
+ * @param {String} type ref type
+ * @param {String} value ref value
+ * @private
+ */
+function addToHistory (state, type, value) {
+  let dest
+
+  if (type === 'file') {
+    dest = utils.getRefFilePath(value)
+  } else {
+    if (value === '#') {
+      return false
+    }
+    dest = state.current.concat(`:${value}`)
+  }
+
+  if (dest) {
+    dest = dest.toLowerCase()
+    if (state.history.indexOf(dest) >= 0) {
+      return false
+    }
+
+    state.history.push(dest)
+  }
+  return true
+}
+
+/**
+ * Set the current into state
+ * @param {Object} state the state
+ * @param {String} type ref type
+ * @param {String} value ref value
+ * @private
+ */
+function setCurrent (state, type, value) {
+  let dest
+  if (type === 'file') {
+    dest = utils.getRefFilePath(value)
+  }
+
+  if (dest) {
+    state.current = dest
+  }
+}
+
+/**
+ * Check the schema for local circular refs using DAG
+ * @param {Object} schema the schema
+ * @return {Error|undefined} <code>Error</code> if circular ref, <code>undefined</code> otherwise if OK
+ * @private
+ */
+function checkLocalCircular (schema) {
+  const dag = new DAG()
+  const locals = traverse(schema).reduce(function (acc, node) {
+    if (!_.isNull(node) && !_.isUndefined(null) && typeof node.$ref === 'string') {
+      const refType = utils.getRefType(node)
+      if (refType === 'local') {
+        const value = utils.getRefValue(node)
+        if (value) {
+          const path = this.path.join('/')
+          acc.push({
+            from: path,
+            to: value
+          })
+        }
+      }
+    }
+    return acc
+  }, [])
+
+  if (!locals || !locals.length) {
+    return
+  }
+
+  if (_.some(locals, elem => elem.to === '#')) {
+    return new Error('Circular self reference')
+  }
+
+  const check = _.find(locals, elem => {
+    const fromEdge = elem.from.concat('/')
+    const dest = elem.to.substring(2).concat('/')
+    try {
+      dag.addEdge(fromEdge, dest)
+    } catch (e) {
+      return elem
+    }
+
+    if (fromEdge.indexOf(dest) === 0) {
+      return elem
+    }
+  })
+
+  if (check) {
+    return new Error(`Circular self reference from ${check.from} to ${check.to}`)
+  }
+}
+
+/**
+ * Derefs $ref types in a schema
+ * @param schema
+ * @param options
+ * @param state
+ * @param type
+ * @private
+ */
+function derefSchema (schema, options, state) {
+  const check = checkLocalCircular(schema)
+  if (check instanceof Error) {
+    return check
+  }
+
+  if (state.circular) {
+    return new Error(`circular references found: ${state.circularRefs.toString()}`)
+  } else if (state.error) {
+    return state.error
+  }
+
+  return traverse(schema).forEach(function (node) {
+    if (!_.isNull(node) && !_.isUndefined(null) && typeof node.$ref === 'string') {
+      const refType = utils.getRefType(node)
+      const refVal = utils.getRefValue(node)
+
+      const addOk = addToHistory(state, refType, refVal)
+      if (!addOk) {
+        state.circular = true
+        state.circularRefs.push(refVal)
+        state.error = new Error(`circular references found: ${state.circularRefs.toString()}`)
+        this.update(node, true)
+      } else {
+        setCurrent(state, refType, refVal)
+        let newValue = getRefSchema(refVal, refType, schema, options, state)
+        state.history.pop()
+        if (newValue === undefined) {
+          if (state.missing.indexOf(refVal) === -1) {
+            state.missing.push(refVal)
+          }
+          if (options.failOnMissing) {
+            state.error = new Error(`Missing $ref: ${refVal}`)
+          }
+          this.update(node, options.failOnMissing)
+        } else {
+          if (options.removeIds && newValue.hasOwnProperty('$id')) {
+            delete newValue.$id
+          }
+          if (options.mergeAdditionalProperties) {
+            delete node.$ref
+            newValue = _.merge({}, newValue, node)
+          }
+          this.update(newValue)
+          if (state.missing.indexOf(refVal) !== -1) {
+            state.missing.splice(state.missing.indexOf(refVal), 1)
+          }
+        }
+      }
+    }
+  })
+}
+
+/**
+ * Derefs <code>$ref</code>'s in JSON Schema to actual resolved values. Supports local, and file refs.
+ * @param {Object} schema - The JSON schema
+ * @param {Object} options - options
+ * @param {String} options.baseFolder - the base folder to get relative path files from. Default is <code>process.cwd()</code>
+ * @param {Boolean} options.failOnMissing - By default missing / unresolved refs will be left as is with their ref value intact.
+ *                                        If set to <code>true</code> we will error out on first missing ref that we cannot
+ *                                        resolve. Default: <code>false</code>.
+ * @param {Boolean} options.mergeAdditionalProperties - By default properties in a object with $ref will be removed in the output.
+ *                                                    If set to <code>true</code> they will be added/overwrite the output. This will use lodash's merge function.
+ *                                                    Default: <code>false</code>.
+ * @param {Boolean} options.removeIds - By default <code>$id</code> fields will get copied when dereferencing.
+ *                                    If set to <code>true</code> they will be removed. Merged properties will not get removed.
+ *                                    Default: <code>false</code>.
+ * @param {Object} options.loaders - A hash mapping reference types (e.g., 'file') to loader functions.
+ * @return {Object|Error} the deref schema oran instance of <code>Error</code> if error.
+ */
+function deref (schema, options) {
+  options = _.defaults(options, defaults)
+
+  const bf = options.baseFolder
+  let cwd = bf
+  if (!utils.isAbsolute(bf)) {
+    cwd = path.resolve(process.cwd(), bf)
+  }
+
+  const state = {
+    graph: new DAG(),
+    circular: false,
+    circularRefs: [],
+    cwd: cwd,
+    missing: [],
+    history: []
+  }
+
+  try {
+    const str = JSON.stringify(schema)
+    state.current = md5(str)
+  } catch (e) {
+    return e
+  }
+
+  const baseSchema = clone(schema)
+
+  cache = {}
+
+  let ret = derefSchema(baseSchema, options, state)
+  if (ret instanceof Error === false && state.error) {
+    return state.error
+  }
+  return ret
+}
+
+module.exports = deref

build/node_modules/json-schema-deref-sync/lib/loaders/file.js

@@ -0,0 +1,34 @@
+const fs = require('fs')
+const path = require('path')
+const { getRefFilePath } = require('../utils')
+
+var cwd = process.cwd()
+
+/**
+ * Resolves a file link of a json schema to the actual value it references
+ * @param refValue the value. String. Ex. `/some/path/schema.json#/definitions/foo`
+ * @param options
+ *              baseFolder - the base folder to get relative path files from. Default is `process.cwd()`
+ * @returns {*}
+ * @private
+ */
+module.exports = function (refValue, options) {
+  let refPath = refValue
+  const baseFolder = options.baseFolder ? path.resolve(cwd, options.baseFolder) : cwd
+
+  if (refPath.indexOf('file:') === 0) {
+    refPath = refPath.substring(5)
+  } else {
+    refPath = path.resolve(baseFolder, refPath)
+  }
+
+  const filePath = getRefFilePath(refPath)
+
+  let newValue
+  try {
+    var data = fs.readFileSync(filePath)
+    newValue = JSON.parse(data)
+  } catch (e) {}
+
+  return newValue
+};

build/node_modules/json-schema-deref-sync/lib/utils.js

@@ -0,0 +1,122 @@
+const path = require('path')
+const validUrl = require('valid-url')
+const isValidPath = require('is-valid-path')
+
+const isWindows = process.platform === 'win32'
+
+/**
+ * Gets the ref value of a search result from prop-search or ref object
+ * @param ref The search result object from prop-search
+ * @returns {*} The value of $ref or undefined if not present in search object
+ * @private
+ */
+function getRefValue (ref) {
+  const thing = ref ? (ref.value ? ref.value : ref) : null
+  if (thing && thing.$ref && typeof thing.$ref === 'string') {
+    return thing.$ref
+  }
+}
+exports.getRefValue = getRefValue
+
+/**
+ * Gets the type of $ref from search result object.
+ * @param ref The search result object from prop-search or a ref object
+ * @returns {string}  `web` if it's a web url.
+ *                    `file` if it's a file path.
+ *                    `local` if it's a link to local schema.
+ *                    undefined otherwise
+ * @private
+ */
+function getRefType (ref) {
+  const val = getRefValue(ref)
+  if (val) {
+    if ((val.charAt(0) === '#')) {
+      return 'local'
+    }
+    
+    if (validUrl.isWebUri(val)) {
+      return 'web'
+    }
+
+    return 'file'
+  }
+}
+exports.getRefType = getRefType
+
+/**
+ * Determines if object is a $ref object. That is { $ref: <something> }
+ * @param thing object to test
+ * @returns {boolean} true if passes the test. false otherwise.
+ * @private
+ */
+function isRefObject (thing) {
+  if (thing && typeof thing === 'object' && !Array.isArray(thing)) {
+    const keys = Object.keys(thing)
+    return keys.length === 1 && keys[0] === '$ref' && typeof thing.$ref === 'string'
+  }
+  return false
+}
+exports.isRefObject = isRefObject
+
+/**
+ * Gets the value at the ref path within schema
+ * @param schema the (root) json schema to search
+ * @param refPath string ref path to get within the schema. Ex. `#/definitions/id`
+ * @returns {*} Returns the value at the path location or undefined if not found within the given schema
+ * @private
+ */
+function getRefPathValue (schema, refPath) {
+  let rpath = refPath
+  const hashIndex = refPath.indexOf('#')
+  if (hashIndex >= 0) {
+    rpath = refPath.substring(hashIndex)
+    if (rpath.length > 1) {
+      rpath = refPath.substring(1)
+    } else {
+      rpath = ''
+    }
+  }
+
+  // Walk through each /-separated path component, and get
+  // the value for that key (ignoring empty keys)
+  const keys = rpath.split('/').filter(k => !!k)
+  return keys.reduce(function (value, key) {
+    return value[key]
+  }, schema)
+}
+exports.getRefPathValue = getRefPathValue
+
+function getRefFilePath (refPath) {
+  let filePath = refPath
+  const hashIndex = filePath.indexOf('#')
+  if (hashIndex > 0) {
+    filePath = refPath.substring(0, hashIndex)
+  }
+
+  return filePath
+}
+exports.getRefFilePath = getRefFilePath
+
+// Regex to split a windows path into three parts: [*, device, slash,
+// tail] windows-only
+const splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/
+
+function win32StatPath (path) {
+  const result = splitDeviceRe.exec(path)
+  const device = result[1] || ''
+  const isUnc = !!device && device[1] !== ':'
+
+  return {
+    device: device,
+    isUnc: isUnc,
+    isAbsolute: isUnc || !!result[2], // UNC paths are always absolute
+    tail: result[3]
+  }
+}
+
+exports.isAbsolute = typeof path.isAbsolute === 'function' ? path.isAbsolute : function utilIsAbsolute (path) {
+  if (isWindows) {
+    return win32StatPath(path).isAbsolute
+  }
+  return !!path && path[0] === '/'
+}

build/node_modules/json-schema-deref-sync/package.json

@@ -0,0 +1,53 @@
+{
+  "author": {
+    "name": "Bojan D.",
+    "email": "dbojan@gmail.com"
+  },
+  "name": "json-schema-deref-sync",
+  "description": "Simple Node.js JSON Schema dereferencer",
+  "keywords": [
+    "json",
+    "schema",
+    "deref"
+  ],
+  "version": "0.14.0",
+  "homepage": "https://github.com/cvent/json-schema-deref-sync",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/cvent/json-schema-deref-sync.git"
+  },
+  "bugs": {
+    "url": "http://github.com/cvent/json-schema-deref-sync/issues"
+  },
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "main": "lib/index.js",
+  "dependencies": {
+    "clone": "^2.1.2",
+    "dag-map": "~1.0.0",
+    "is-valid-path": "^0.1.1",
+    "lodash": "^4.17.13",
+    "md5": "~2.2.0",
+    "memory-cache": "~0.2.0",
+    "traverse": "~0.6.6",
+    "valid-url": "~1.0.9"
+  },
+  "devDependencies": {
+    "async": "^2.6.2",
+    "chai": "^4.2.0",
+    "fs.extra": "~1.3.2",
+    "js-yaml": "^3.13.1",
+    "jsdoc-to-markdown": "^4.0.0",
+    "mocha": "^6.1.4",
+    "standard": "~12.0.0"
+  },
+  "scripts": {
+    "test": "mocha",
+    "docs": "jsdoc2md \"lib/**/*.js\" --template readme.hbs > README.md"
+  },
+  "directories": {
+    "test": "test"
+  }
+}

build/node_modules/json-schema-deref-sync/readme.hbs

@@ -0,0 +1,93 @@
+# json-schema-deref-sync
+
+[![npm version](https://img.shields.io/npm/v/json-schema-deref-sync.svg?style=flat-square)](https://www.npmjs.com/package/json-schema-deref-sync)
+[![build status](https://img.shields.io/travis/bojand/json-schema-deref-sync/master.svg?style=flat-square)](https://travis-ci.org/bojand/json-schema-deref-sync)
+[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](https://standardjs.com)
+[![License](https://img.shields.io/github/license/bojand/json-schema-deref-sync.svg?style=flat-square)](https://raw.githubusercontent.com/bojand/json-schema-deref-sync/master/LICENSE)
+
+Dereference JSON pointers in a JSON schemas with their true resolved values.
+Basically a lighter, synchronous version of [json-schema-deref](https://github.com/bojand/json-schema-deref) but omits web references.
+
+## Installation
+
+`npm install json-schema-deref-sync`
+
+## Overview
+
+Let's say you have the following JSON Schema:
+
+```json
+{
+  "description": "Just some JSON schema.",
+  "title": "Basic Widget",
+  "type": "object",
+  "definitions": {
+    "id": {
+      "description": "unique identifier",
+      "type": "string",
+      "minLength": 1,
+      "readOnly": true
+    }
+  },
+  "properties": {
+    "id": {
+      "$ref": "#/definitions/id"
+    },
+    "foo": {
+      "$ref": "http://www.mysite.com/myschema.json#/definitions/foo"
+    },
+    "bar": {
+      "$ref": "bar.json"
+    }
+  }
+}
+```
+
+Sometimes you just want that schema to be fully expanded, with `$ref`'s being their (true) resolved values:
+
+```json
+{
+  "description": "Just some JSON schema.",
+  "title": "Basic Widget",
+  "type": "object",
+  "definitions": {
+    "id": {
+      "description": "unique identifier",
+      "type": "string",
+      "minLength": 1,
+      "readOnly": true
+    }
+  },
+  "properties": {
+    "id": {
+      "description": "unique identifier",
+      "type": "string",
+      "minLength": 1,
+      "readOnly": true
+    },
+    "foo": {
+      "description": "foo property",
+      "readOnly": true,
+      "type": "number"
+    },
+    "bar": {
+      "description": "bar property",
+      "type": "boolean"
+    }
+  }
+}
+```
+
+This utility lets you do that:
+
+
+```js
+var deref = require('json-schema-deref-sync');
+var myschema = require('schema.json');
+
+var fullSchema = deref(myschema);
+```
+
+## API Reference
+
+{{>all-docs~}}