{"version":3,"sources":["webpack://web/./node_modules/fluent-json-schema/src/ArraySchema.js","webpack://web/./node_modules/fluent-json-schema/src/BaseSchema.js","webpack://web/./node_modules/fluent-json-schema/src/BooleanSchema.js","webpack://web/./node_modules/fluent-json-schema/src/FluentJSONSchema.js","webpack://web/./node_modules/fluent-json-schema/src/IntegerSchema.js","webpack://web/./node_modules/fluent-json-schema/src/MixedSchema.js","webpack://web/./node_modules/fluent-json-schema/src/NullSchema.js","webpack://web/./node_modules/fluent-json-schema/src/NumberSchema.js","webpack://web/./node_modules/fluent-json-schema/src/ObjectSchema.js","webpack://web/./node_modules/fluent-json-schema/src/RawSchema.js","webpack://web/./node_modules/fluent-json-schema/src/StringSchema.js","webpack://web/./node_modules/fluent-json-schema/src/utils.js"],"names":["BaseSchema","setAttribute","isFluentSchema","FluentSchemaError","initialState","type","definitions","properties","required","ArraySchema","schema","options","generateIds","factory","items","Array","isArray","filter","v","length","values","map","$schema","rest","valueOf","additionalItems","contains","value","uniqueItems","boolean","minItems","min","Number","isInteger","maxItems","max","module","exports","default","flat","omit","last","isUniq","patchIdsWithParentId","REQUIRED","setRaw","setComposeType","FLUENT_SCHEMA","isFluentJSONSchema","id","title","description","examples","ref","enum","const","defaults","readOnly","isReadOnly","undefined","writeOnly","isWriteOnly","props","currentProp","name","not","notSchema","parentId","anyOf","schemas","prop","allOf","oneOf","as","ifThen","ifClause","thenClause","ifClauseSchema","thenClauseSchema","if","then","ifThenElse","elseClause","elseClauseSchema","else","raw","fragment","_getState","isRoot","every","Object","assign","keys","BooleanSchema","FORMATS","TYPES","NullSchema","StringSchema","NumberSchema","IntegerSchema","ObjectSchema","MixedSchema","RawSchema","S","string","number","integer","array","object","baseSchema","null","mixed","types","t","includes","join","fluentSchema","withOptions","STRING","NUMBER","BOOLEAN","INTEGER","OBJECT","ARRAY","NULL","minimum","exclusiveMinimum","maximum","exclusiveMaximum","multipleOf","multiple","merge","hasCombiningKeywords","appendRequired","combineMerge","additionalProperties","maxProperties","minProperties","patternProperties","opts","entries","reduce","memo","pattern","dependencies","dependentRequired","dependentSchemas","propertyNames","JSON","stringify","target","def","attributes","$id","schemaPatched","attributesPatched","$ref","key","extend","base","src","extended","arrayMerge","only","p","definition","toArray","minLength","maxLength","format","RegExp","flags","toString","substr","replace","contentEncoding","encoding","contentMediaType","mediaType","obj","Error","constructor","message","super","this","reverse","i","a","indexOf","Symbol","for","schemaRequired","attributeRequired","item","patchedRequired","attribute","source","destination","slice","forEach","index","find","attr","cloneUnlessOtherwiseSpecified","isMergeableObject","propIndex","findIndex","push","RELATIVE_JSON_POINTER","JSON_POINTER","UUID","REGEX","IPV6","IPV4","HOSTNAME","EMAIL","URL","URI_TEMPLATE","URI_REFERENCE","URI","TIME","DATE","DATE_TIME"],"mappings":"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","file":"npm.fluent-json-schema.322d838c8fcba2cc3521.react.bundle.js","sourcesContent":["'use strict'\nconst { BaseSchema } = require('./BaseSchema')\nconst { setAttribute, isFluentSchema, FluentSchemaError } = require('./utils')\n\nconst initialState = {\n  // $schema: 'http://json-schema.org/draft-07/schema#',\n  type: 'array',\n  definitions: [],\n  properties: [],\n  required: [],\n}\n\n/**\n * Represents a ArraySchema.\n * @param {Object} [options] - Options\n * @param {StringSchema} [options.schema] - Default schema\n * @param {boolean} [options.generateIds = false] - generate the id automatically e.g. #properties.foo\n * @returns {ArraySchema}\n */\n// https://medium.com/javascript-scene/javascript-factory-functions-with-es6-4d224591a8b1\n// Factory Functions for Mixin Composition withBaseSchema\nconst ArraySchema = ({ schema = initialState, ...options } = {}) => {\n  options = {\n    generateIds: false,\n    factory: ArraySchema,\n    ...options,\n  }\n  return {\n    ...BaseSchema({ ...options, schema }),\n\n    /**\n     * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.\n     * If \"items\" is a schema, validation succeeds if all elements in the array successfully validate against that schema.\n     * If \"items\" is an array of schemas, validation succeeds if each element of the instance validates against the schema at the same position, if any.\n     * Omitting this keyword has the same behavior as an empty schema.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.4.1|reference}\n     * @param {FluentSchema|FluentSchema[]} items\n     * @returns {FluentSchema}\n     */\n\n    items: items => {\n      if (\n        !isFluentSchema(items) &&\n        !(\n          Array.isArray(items) &&\n          items.filter(v => isFluentSchema(v)).length > 0\n        )\n      )\n        throw new FluentSchemaError(\"'items' must be a S or an array of S\")\n      if (Array.isArray(items)) {\n        const values = items.map(v => {\n          const { $schema, ...rest } = v.valueOf()\n          return rest\n        })\n        return setAttribute({ schema, ...options }, ['items', values, 'array'])\n      }\n      const { $schema, ...rest } = items.valueOf()\n      return setAttribute({ schema, ...options }, [\n        'items',\n        { ...rest },\n        'array',\n      ])\n    },\n\n    /**\n     * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.4.2|reference}\n     * @param {FluentSchema|boolean} items\n     * @returns {FluentSchema}\n     */\n\n    additionalItems: items => {\n      if (typeof items !== 'boolean' && !isFluentSchema(items))\n        throw new FluentSchemaError(\n          \"'additionalItems' must be a boolean or a S\"\n        )\n      if (items === false) {\n        return setAttribute({ schema, ...options }, [\n          'additionalItems',\n          false,\n          'array',\n        ])\n      }\n      const { $schema, ...rest } = items.valueOf()\n      return setAttribute({ schema, ...options }, [\n        'additionalItems',\n        { ...rest },\n        'array',\n      ])\n    },\n\n    /**\n     * An array instance is valid against \"contains\" if at least one of its elements is valid against the given schema.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.4.6|reference}\n     * @param {FluentSchema} value\n     * @returns {FluentSchema}\n     */\n\n    contains: value => {\n      if (!isFluentSchema(value))\n        throw new FluentSchemaError(\"'contains' must be a S\")\n      const {\n        $schema,\n        definitions,\n        properties,\n        required,\n        ...rest\n      } = value.valueOf()\n      return setAttribute({ schema, ...options }, [\n        'contains',\n        { ...rest },\n        'array',\n      ])\n    },\n\n    /**\n     * If this keyword has boolean value false, the instance validates successfully.\n     * If it has boolean value true, the instance validates successfully if all of its elements are unique.\n     * Omitting this keyword has the same behavior as a value of false.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.4.5|reference}\n     * @param {boolean} boolean\n     * @returns {FluentSchema}\n     */\n\n    uniqueItems: boolean => {\n      if (typeof boolean !== 'boolean')\n        throw new FluentSchemaError(\"'uniqueItems' must be a boolean\")\n      return setAttribute({ schema, ...options }, [\n        'uniqueItems',\n        boolean,\n        'array',\n      ])\n    },\n\n    /**\n     * An array instance is valid against \"minItems\" if its size is greater than, or equal to, the value of this keyword.\n     * Omitting this keyword has the same behavior as a value of 0.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.4.4|reference}\n     * @param {number} min\n     * @returns {FluentSchema}\n     */\n\n    minItems: min => {\n      if (!Number.isInteger(min))\n        throw new FluentSchemaError(\"'minItems' must be a integer\")\n      return setAttribute({ schema, ...options }, ['minItems', min, 'array'])\n    },\n\n    /**\n     * An array instance is valid against \"minItems\" if its size is greater than, or equal to, the value of this keyword.\n     * Omitting this keyword has the same behavior as a value of 0.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.4.3|reference}\n     * @param {number} max\n     * @returns {FluentSchema}\n     */\n\n    maxItems: max => {\n      if (!Number.isInteger(max))\n        throw new FluentSchemaError(\"'maxItems' must be a integer\")\n      return setAttribute({ schema, ...options }, ['maxItems', max, 'array'])\n    },\n  }\n}\n\nmodule.exports = {\n  ArraySchema,\n  default: ArraySchema,\n}\n","'use strict'\nconst {\n  flat,\n  omit,\n  isFluentSchema,\n  last,\n  isUniq,\n  patchIdsWithParentId,\n  REQUIRED,\n  setAttribute,\n  setRaw,\n  setComposeType,\n  FluentSchemaError,\n  FLUENT_SCHEMA,\n} = require('./utils')\n\nconst initialState = {\n  properties: [],\n  required: [],\n}\n\n/**\n * Represents a BaseSchema.\n * @param {Object} [options] - Options\n * @param {BaseSchema} [options.schema] - Default schema\n * @param {boolean} [options.generateIds = false] - generate the id automatically e.g. #properties.foo\n * @returns {BaseSchema}\n */\n\nconst BaseSchema = (\n  { schema = initialState, ...options } = {\n    generateIds: false,\n    factory: BaseSchema,\n  }\n) => ({\n  [FLUENT_SCHEMA]: true,\n  isFluentSchema: true,\n  isFluentJSONSchema: true,\n\n  /**\n   * It defines a URI for the schema, and the base URI that other URI references within the schema are resolved against.\n   *\n   * {@link https://tools.ietf.org/html/draft-handrews-json-schema-01#section-8.2|reference}\n   * @param {string} id - an #id\n   * @returns {BaseSchema}\n   */\n\n  id: id => {\n    if (!id)\n      throw new FluentSchemaError(\n        `id should not be an empty fragment <#> or an empty string <> (e.g. #myId)`\n      )\n    return setAttribute({ schema, ...options }, ['$id', id, 'any'])\n  },\n\n  /**\n   * It can be used to decorate a user interface with information about the data produced by this user interface. A title will preferably be short.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.10.1|reference}\n   * @param {string} title\n   * @returns {BaseSchema}\n   */\n\n  title: title => {\n    return setAttribute({ schema, ...options }, ['title', title, 'any'])\n  },\n\n  /**\n   * It can be used to decorate a user interface with information about the data\n   * produced by this user interface. A description provides explanation about\n   * the purpose of the instance described by the schema.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.10.1|reference}\n   * @param {string} description\n   * @returns {BaseSchema}\n   */\n  description: description => {\n    return setAttribute({ schema, ...options }, [\n      'description',\n      description,\n      'any',\n    ])\n  },\n\n  /**\n   * The value of this keyword MUST be an array.\n   * There are no restrictions placed on the values within the array.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.10.4|reference}\n   * @param {string} examples\n   * @returns {BaseSchema}\n   */\n\n  examples: examples => {\n    if (!Array.isArray(examples))\n      throw new FluentSchemaError(\n        \"'examples' must be an array e.g. ['1', 'one', 'foo']\"\n      )\n    return setAttribute({ schema, ...options }, ['examples', examples, 'any'])\n  },\n\n  /**\n   * The value must be a valid id e.g. #properties/foo\n   *\n   * @param {string} ref\n   * @returns {BaseSchema}\n   */\n\n  ref: ref => {\n    return setAttribute({ schema, ...options }, ['$ref', ref, 'any'])\n  },\n\n  /**\n   * The value of this keyword MUST be an array. This array SHOULD have at least one element. Elements in the array SHOULD be unique.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.1.2|reference}\n   * @param {array} values\n   * @returns {BaseSchema}\n   */\n\n  enum: values => {\n    if (!Array.isArray(values))\n      throw new FluentSchemaError(\n        \"'enums' must be an array with at least an element e.g. ['1', 'one', 'foo']\"\n      )\n    return setAttribute({ schema, ...options }, ['enum', values, 'any'])\n  },\n\n  /**\n   * The value of this keyword MAY be of any type, including null.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.1.3|reference}\n   * @param value\n   * @returns {BaseSchema}\n   */\n\n  const: value => {\n    return setAttribute({ schema, ...options }, ['const', value, 'any'])\n  },\n\n  /**\n   * There are no restrictions placed on the value of this keyword.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.10.2|reference}\n   * @param defaults\n   * @returns {BaseSchema}\n   */\n\n  default: defaults => {\n    return setAttribute({ schema, ...options }, ['default', defaults, 'any'])\n  },\n\n  /**\n   * The value of readOnly can be left empty to indicate the property is readOnly.\n   * It takes an optional boolean which can be used to explicitly set readOnly true/false.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.10.3|reference}\n   * @param {boolean|undefined} isReadOnly\n   * @returns {BaseSchema}\n   */\n\n  readOnly: isReadOnly => {\n    const value = isReadOnly !== undefined ? isReadOnly : true\n    return setAttribute({ schema, ...options }, ['readOnly', value, 'boolean'])\n  },\n\n  /**\n   * The value of writeOnly can be left empty to indicate the property is writeOnly.\n   * It takes an optional boolean which can be used to explicitly set writeOnly true/false.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.10.3|reference}\n   * @param {boolean|undefined} isWriteOnly\n   * @returns {BaseSchema}\n   */\n\n  writeOnly: isWriteOnly => {\n    const value = isWriteOnly !== undefined ? isWriteOnly : true\n    return setAttribute({ schema, ...options }, ['writeOnly', value, 'boolean'])\n  },\n\n  /**\n   * Required has to be chained to a property:\n   * Examples:\n   * - S.prop('prop').required()\n   * - S.prop('prop', S.number()).required()\n   * - S.required(['foo', 'bar'])\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.5.3|reference}\n   * @returns {FluentSchema}\n   */\n  required: props => {\n    const currentProp = last(schema.properties)\n    const required = Array.isArray(props)\n      ? [...schema.required, ...props]\n      : currentProp\n      ? [...schema.required, currentProp.name]\n      : [REQUIRED]\n\n    if(!isUniq(required)){\n      throw new FluentSchemaError(\"'required' has repeated keys, check your calls to .required()\")\n    }\n\n    return options.factory({\n      schema: { ...schema, required },\n      ...options,\n    })\n  },\n\n  /**\n   * This keyword's value MUST be a valid JSON Schema.\n   * An instance is valid against this keyword if it fails to validate successfully against the schema defined by this keyword.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.7.4|reference}\n   * @param {FluentSchema} not\n   * @returns {BaseSchema}\n   */\n  not: not => {\n    if (!isFluentSchema(not))\n      throw new FluentSchemaError(\"'not' must be a BaseSchema\")\n    const notSchema = omit(not.valueOf(), ['$schema', 'definitions'])\n\n    return BaseSchema({\n      schema: {\n        ...schema,\n        not: patchIdsWithParentId({\n          schema: notSchema,\n          ...options,\n          parentId: '#not',\n        }),\n      },\n      ...options,\n    })\n  },\n  // return setAttribute({ schema, ...options }, ['defaults', defaults, 'any'])\n\n  /**\n   * It MUST be a non-empty array. Each item of the array MUST be a valid JSON Schema.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.7.2|reference}\n   * @param {array} schemas\n   * @returns {BaseSchema}\n   */\n\n  anyOf: schemas => setComposeType({ prop: 'anyOf', schemas, schema, options }),\n\n  /**\n   * It MUST be a non-empty array. Each item of the array MUST be a valid JSON Schema.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.7.1|reference}\n   * @param {array} schemas\n   * @returns {BaseSchema}\n   */\n\n  allOf: schemas => setComposeType({ prop: 'allOf', schemas, schema, options }),\n\n  /**\n   * It MUST be a non-empty array. Each item of the array MUST be a valid JSON Schema.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.7.3|reference}\n   * @param {array} schemas\n   * @returns {BaseSchema}\n   */\n\n  oneOf: schemas => setComposeType({ prop: 'oneOf', schemas, schema, options }),\n\n  /**\n   * @private set a property to a type. Use string number etc.\n   * @returns {BaseSchema}\n   */\n  as: type => setAttribute({ schema, ...options }, ['type', type]),\n\n  /**\n   * This validation outcome of this keyword's subschema has no direct effect on the overall validation result.\n   * Rather, it controls which of the \"then\" or \"else\" keywords are evaluated.\n   * When \"if\" is present, and the instance successfully validates against its subschema, then\n   * validation succeeds against this keyword if the instance also successfully validates against this keyword's subschema.\n   *\n   * @param {BaseSchema} ifClause\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.6.1|reference}\n   * @param {BaseSchema} thenClause\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.6.2|reference}\n   * @returns {BaseSchema}\n   */\n\n  ifThen: (ifClause, thenClause) => {\n    if (!isFluentSchema(ifClause))\n      throw new FluentSchemaError(\"'ifClause' must be a BaseSchema\")\n    if (!isFluentSchema(thenClause))\n      throw new FluentSchemaError(\"'thenClause' must be a BaseSchema\")\n\n    const ifClauseSchema = omit(ifClause.valueOf(), [\n      '$schema',\n      'definitions',\n      'type',\n    ])\n    const thenClauseSchema = omit(thenClause.valueOf(), [\n      '$schema',\n      'definitions',\n      'type',\n    ])\n\n    return options.factory({\n      schema: {\n        ...schema,\n        if: patchIdsWithParentId({\n          schema: ifClauseSchema,\n          ...options,\n          parentId: '#if',\n        }),\n        then: patchIdsWithParentId({\n          schema: thenClauseSchema,\n          ...options,\n          parentId: '#then',\n        }),\n      },\n      ...options,\n    })\n  },\n\n  /**\n   * When \"if\" is present, and the instance fails to validate against its subschema,\n   * then validation succeeds against this keyword if the instance successfully validates against this keyword's subschema.\n   *\n   * @param {BaseSchema} ifClause\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.6.1|reference}\n   * @param {BaseSchema} thenClause\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.6.2|reference}\n   * @param {BaseSchema} elseClause\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.6.3|reference}\n   * @returns {BaseSchema}\n   */\n\n  ifThenElse: (ifClause, thenClause, elseClause) => {\n    if (!isFluentSchema(ifClause))\n      throw new FluentSchemaError(\"'ifClause' must be a BaseSchema\")\n    if (!isFluentSchema(thenClause))\n      throw new FluentSchemaError(\"'thenClause' must be a BaseSchema\")\n    if (!isFluentSchema(elseClause))\n      throw new FluentSchemaError(\n        \"'elseClause' must be a BaseSchema or a false boolean value\"\n      )\n    const ifClauseSchema = omit(ifClause.valueOf(), [\n      '$schema',\n      'definitions',\n      'type',\n    ])\n    const thenClauseSchema = omit(thenClause.valueOf(), [\n      '$schema',\n      'definitions',\n      'type',\n    ])\n    const elseClauseSchema = omit(elseClause.valueOf(), [\n      '$schema',\n      'definitions',\n      'type',\n    ])\n\n    return options.factory({\n      schema: {\n        ...schema,\n        if: patchIdsWithParentId({\n          schema: ifClauseSchema,\n          ...options,\n          parentId: '#if',\n        }),\n        then: patchIdsWithParentId({\n          schema: thenClauseSchema,\n          ...options,\n          parentId: '#then',\n        }),\n        else: patchIdsWithParentId({\n          schema: elseClauseSchema,\n          ...options,\n          parentId: '#else',\n        }),\n      },\n      ...options,\n    })\n  },\n\n  /**\n   * Because the differences between JSON Schemas and Open API (Swagger)\n   * it can be handy to arbitrary modify the schema injecting a fragment\n   *\n   * * Examples:\n   * - S.number().raw({ nullable:true })\n   * - S.string().format('date').raw({ formatMaximum: '2020-01-01' })\n   *\n   * @param {string} fragment an arbitrary JSON Schema to inject\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.3.3|reference}\n   * @returns {BaseSchema}\n   */\n  raw: fragment => {\n    return setRaw({ schema, ...options }, fragment)\n  },\n\n  /**\n   * @private It returns the internal schema data structure\n   * @returns {object}\n   */\n  // TODO LS if we implement S.raw() we can drop this hack because from a JSON we can rebuild a fluent-json-schema\n  _getState: () => {\n    return schema\n  },\n\n  /**\n   * It returns all the schema values\n   *\n   * @param {Object} [options] - Options\n   * @param {boolean} [options.isRoot = true] - Is a root level schema\n   * @returns {object}\n   */\n  valueOf: ({ isRoot } = { isRoot: true }) => {\n    const { properties, definitions, required, $schema, ...rest } = schema\n\n    if (isRoot && required && !required.every((v) => typeof v === 'string')) {\n      throw new FluentSchemaError(\"'required' has called on root-level schema, check your calls to .required()\")\n    }\n\n    return Object.assign(\n      $schema ? { $schema } : {},\n      Object.keys(definitions || []).length > 0\n        ? { definitions: flat(definitions) }\n        : undefined,\n      { ...omit(rest, ['if', 'then', 'else']) },\n      Object.keys(properties || []).length > 0\n        ? { properties: flat(properties) }\n        : undefined,\n      required && required.length > 0 ? { required } : undefined,\n      schema.if ? { if: schema.if } : undefined,\n      schema.then ? { then: schema.then } : undefined,\n      schema.else ? { else: schema.else } : undefined\n    )\n  },\n})\n\nmodule.exports = {\n  BaseSchema,\n  default: BaseSchema,\n}\n","'use strict'\nconst { BaseSchema } = require('./BaseSchema')\nconst { setAttribute } = require('./utils')\n\nconst initialState = {\n  type: 'boolean',\n}\n\n/**\n * Represents a BooleanSchema.\n * @param {Object} [options] - Options\n * @param {StringSchema} [options.schema] - Default schema\n * @param {boolean} [options.generateIds = false] - generate the id automatically e.g. #properties.foo\n * @returns {StringSchema}\n */\n\nconst BooleanSchema = ({ schema = initialState, ...options } = {}) => {\n  options = {\n    generateIds: false,\n    factory: BaseSchema,\n    ...options,\n  }\n  return {\n    ...BaseSchema({ ...options, schema }),\n  }\n}\n\nmodule.exports = {\n  BooleanSchema,\n  default: BooleanSchema,\n}\n","'use strict'\n\nconst { FORMATS, TYPES, FluentSchemaError } = require('./utils')\n\nconst { BaseSchema } = require('./BaseSchema')\nconst { NullSchema } = require('./NullSchema')\nconst { BooleanSchema } = require('./BooleanSchema')\nconst { StringSchema } = require('./StringSchema')\nconst { NumberSchema } = require('./NumberSchema')\nconst { IntegerSchema } = require('./IntegerSchema')\nconst { ObjectSchema } = require('./ObjectSchema')\nconst { ArraySchema } = require('./ArraySchema')\nconst { MixedSchema } = require('./MixedSchema')\nconst { RawSchema } = require('./RawSchema')\n\nconst initialState = {\n  $schema: 'http://json-schema.org/draft-07/schema#',\n  definitions: [],\n  properties: [],\n  required: [],\n}\n\n/**\n * Represents a S.\n * @param {Object} [options] - Options\n * @param {S} [options.schema] - Default schema\n * @param {boolean} [options.generateIds = false] - generate the id automatically e.g. #properties.foo\n * @returns {S}\n */\n\nconst S = (\n  { schema = initialState, ...options } = {\n    generateIds: false,\n    factory: BaseSchema,\n  }\n) => ({\n  ...BaseSchema({ ...options, schema }),\n\n  /**\n   * Set a property to type string\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.3|reference}\n   * @returns {StringSchema}\n   */\n\n  string: () =>\n    StringSchema({\n      ...options,\n      schema,\n      factory: StringSchema,\n    }).as('string'),\n\n  /**\n   * Set a property to type number\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#numeric|reference}\n   * @returns {NumberSchema}\n   */\n\n  number: () =>\n    NumberSchema({\n      ...options,\n      schema,\n      factory: NumberSchema,\n    }).as('number'),\n\n  /**\n   * Set a property to type integer\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#numeric|reference}\n   * @returns {IntegerSchema}\n   */\n\n  integer: () =>\n    IntegerSchema({\n      ...options,\n      schema,\n      factory: IntegerSchema,\n    }).as('integer'),\n\n  /**\n   * Set a property to type boolean\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.7|reference}\n   * @returns {BooleanSchema}\n   */\n\n  boolean: () =>\n    BooleanSchema({\n      ...options,\n      schema,\n      factory: BooleanSchema,\n    }).as('boolean'),\n\n  /**\n   * Set a property to type array\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.4|reference}\n   * @returns {ArraySchema}\n   */\n\n  array: () =>\n    ArraySchema({\n      ...options,\n      schema,\n      factory: ArraySchema,\n    }).as('array'),\n\n  /**\n   * Set a property to type object\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.5|reference}\n   * @returns {ObjectSchema}\n   */\n\n  object: baseSchema =>\n    ObjectSchema({\n      ...options,\n      schema: baseSchema || schema,\n      factory: ObjectSchema,\n    }).as('object'),\n\n  /**\n   * Set a property to type null\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#general|reference}\n   * @returns {NullSchema}\n   */\n\n  null: () =>\n    NullSchema({\n      ...options,\n      schema,\n      factory: NullSchema,\n    }).null(),\n\n  /**\n   * A mixed schema is the union of multiple types (e.g. ['string', 'integer']\n   *\n   * @param {Array.<string>} types\n   * @returns {MixedSchema}\n   */\n\n  mixed: types => {\n    if (\n      !Array.isArray(types) ||\n      (Array.isArray(types) &&\n        types.filter(t => !Object.values(TYPES).includes(t)).length > 0)\n    ) {\n      throw new FluentSchemaError(\n        `Invalid 'types'. It must be an array of types. Valid types are ${Object.values(\n          TYPES\n        ).join(' | ')}`\n      )\n    }\n\n    return MixedSchema({\n      ...options,\n      schema: {\n        ...schema,\n        type: types,\n      },\n      factory: MixedSchema,\n    })\n  },\n\n  /**\n   * Because the differences between JSON Schemas and Open API (Swagger)\n   * it can be handy to arbitrary modify the schema injecting a fragment\n   *\n   * * Examples:\n   * - S.raw({ nullable:true, format: 'date', formatMaximum: '2020-01-01' })\n   * - S.string().format('date').raw({ formatMaximum: '2020-01-01' })\n   *\n   * @param {string} fragment an arbitrary JSON Schema to inject\n   * @returns {BaseSchema}\n   */\n\n  raw: fragment => {\n    return RawSchema(fragment)\n  },\n})\n\nconst fluentSchema = {\n  ...BaseSchema(),\n  FORMATS,\n  TYPES,\n  FluentSchemaError,\n  withOptions: S,\n  string: () => S().string(),\n  mixed: types => S().mixed(types),\n  object: () => S().object(),\n  array: () => S().array(),\n  boolean: () => S().boolean(),\n  integer: () => S().integer(),\n  number: () => S().number(),\n  null: () => S().null(),\n  raw: fragment => S().raw(fragment),\n}\nmodule.exports = fluentSchema\nmodule.exports.default = fluentSchema\n","'use strict'\nconst { NumberSchema } = require('./NumberSchema')\n\nconst initialState = {\n  type: 'integer',\n}\n\n/**\n * Represents a NumberSchema.\n * @param {Object} [options] - Options\n * @param {NumberSchema} [options.schema] - Default schema\n * @param {boolean} [options.generateIds = false] - generate the id automatically e.g. #properties.foo\n * @returns {NumberSchema}\n */\n// https://medium.com/javascript-scene/javascript-factory-functions-with-es6-4d224591a8b1\n// Factory Functions for Mixin Composition withBaseSchema\nconst IntegerSchema = (\n  { schema, ...options } = {\n    schema: initialState,\n    generateIds: false,\n    factory: IntegerSchema,\n  }\n) => ({\n  ...NumberSchema({ ...options, schema }),\n})\n\nmodule.exports = {\n  IntegerSchema,\n  default: IntegerSchema,\n}\n","'use strict'\nconst { BaseSchema } = require('./BaseSchema')\nconst { NullSchema } = require('./NullSchema')\nconst { BooleanSchema } = require('./BooleanSchema')\nconst { StringSchema } = require('./StringSchema')\nconst { NumberSchema } = require('./NumberSchema')\nconst { IntegerSchema } = require('./IntegerSchema')\nconst { ObjectSchema } = require('./ObjectSchema')\nconst { ArraySchema } = require('./ArraySchema')\n\nconst { TYPES, setAttribute, FLUENT_SCHEMA } = require('./utils')\n\nconst initialState = {\n  type: [],\n  definitions: [],\n  properties: [],\n  required: [],\n}\n\n/**\n * Represents a MixedSchema.\n * @param {Object} [options] - Options\n * @param {MixedSchema} [options.schema] - Default schema\n * @param {boolean} [options.generateIds = false] - generate the id automatically e.g. #properties.foo\n * @returns {StringSchema}\n */\n\nconst MixedSchema = ({ schema = initialState, ...options } = {}) => {\n  options = {\n    generateIds: false,\n    factory: MixedSchema,\n    ...options,\n  }\n  return {\n    [FLUENT_SCHEMA]: true,\n    ...(schema.type.includes(TYPES.STRING)\n      ? StringSchema({ ...options, schema, factory: MixedSchema })\n      : {}),\n    ...(schema.type.includes(TYPES.NUMBER)\n      ? NumberSchema({ ...options, schema, factory: MixedSchema })\n      : {}),\n    ...(schema.type.includes(TYPES.BOOLEAN)\n      ? BooleanSchema({ ...options, schema, factory: MixedSchema })\n      : {}),\n    ...(schema.type.includes(TYPES.INTEGER)\n      ? IntegerSchema({ ...options, schema, factory: MixedSchema })\n      : {}),\n    ...(schema.type.includes(TYPES.OBJECT)\n      ? ObjectSchema({ ...options, schema, factory: MixedSchema })\n      : {}),\n    ...(schema.type.includes(TYPES.ARRAY)\n      ? ArraySchema({ ...options, schema, factory: MixedSchema })\n      : {}),\n    ...(schema.type.includes(TYPES.NULL)\n      ? NullSchema({ ...options, schema, factory: MixedSchema })\n      : {}),\n  }\n}\n\nmodule.exports = {\n  MixedSchema,\n  default: MixedSchema,\n}\n","'use strict'\nconst { BaseSchema } = require('./BaseSchema')\nconst { setAttribute, FLUENT_SCHEMA } = require('./utils')\n\nconst initialState = {\n  type: 'null',\n}\n\n/**\n * Represents a NullSchema.\n * @param {Object} [options] - Options\n * @param {StringSchema} [options.schema] - Default schema\n * @param {boolean} [options.generateIds = false] - generate the id automatically e.g. #properties.foo\n * @returns {StringSchema}\n */\n\nconst NullSchema = ({ schema = initialState, ...options } = {}) => {\n  options = {\n    generateIds: false,\n    factory: NullSchema,\n    ...options,\n  }\n  const { valueOf, raw } = BaseSchema({ ...options, schema })\n  return {\n    valueOf,\n    raw,\n    [FLUENT_SCHEMA]: true,\n    isFluentSchema: true,\n\n    /**\n     * Set a property to type null\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.1.1|reference}\n     * @returns {FluentSchema}\n     */\n    null: () => setAttribute({ schema, ...options }, ['type', 'null']),\n  }\n}\n\nmodule.exports = {\n  NullSchema,\n  default: NullSchema,\n}\n","'use strict'\nconst { BaseSchema } = require('./BaseSchema')\nconst { setAttribute, FluentSchemaError } = require('./utils')\n\nconst initialState = {\n  type: 'number',\n}\n\n/**\n * Represents a NumberSchema.\n * @param {Object} [options] - Options\n * @param {NumberSchema} [options.schema] - Default schema\n * @param {boolean} [options.generateIds = false] - generate the id automatically e.g. #properties.foo\n * @returns {NumberSchema}\n */\n// https://medium.com/javascript-scene/javascript-factory-functions-with-es6-4d224591a8b1\n// Factory Functions for Mixin Composition withBaseSchema\nconst NumberSchema = (\n  { schema, ...options } = {\n    schema: initialState,\n    generateIds: false,\n    factory: NumberSchema,\n  }\n) => ({\n  ...BaseSchema({ ...options, schema }),\n\n  /**\n   * It represents  an inclusive lower limit for a numeric instance.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.2.4|reference}\n   * @param {number} min\n   * @returns {FluentSchema}\n   */\n\n  minimum: min => {\n    if (typeof min !== 'number')\n      throw new FluentSchemaError(\"'minimum' must be a Number\")\n    if (schema.type === 'integer' && !Number.isInteger(min))\n      throw new FluentSchemaError(\"'minimum' must be an Integer\")\n    return setAttribute({ schema, ...options }, ['minimum', min, 'number'])\n  },\n\n  /**\n   * It represents an exclusive lower limit for a numeric instance.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.2.5|reference}\n   * @param {number} min\n   * @returns {FluentSchema}\n   */\n\n  exclusiveMinimum: min => {\n    if (typeof min !== 'number')\n      throw new FluentSchemaError(\"'exclusiveMinimum' must be a Number\")\n    if (schema.type === 'integer' && !Number.isInteger(min))\n      throw new FluentSchemaError(\"'exclusiveMinimum' must be an Integer\")\n    return setAttribute({ schema, ...options }, [\n      'exclusiveMinimum',\n      min,\n      'number',\n    ])\n  },\n\n  /**\n   * It represents  an inclusive upper limit for a numeric instance.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.2.2|reference}\n   * @param {number} max\n   * @returns {FluentSchema}\n   */\n\n  maximum: max => {\n    if (typeof max !== 'number')\n      throw new FluentSchemaError(\"'maximum' must be a Number\")\n    if (schema.type === 'integer' && !Number.isInteger(max))\n      throw new FluentSchemaError(\"'maximum' must be an Integer\")\n    return setAttribute({ schema, ...options }, ['maximum', max, 'number'])\n  },\n\n  /**\n   * It represents an exclusive upper limit for a numeric instance.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.2.3|reference}\n   * @param {number} max\n   * @returns {FluentSchema}\n   */\n\n  exclusiveMaximum: max => {\n    if (typeof max !== 'number')\n      throw new FluentSchemaError(\"'exclusiveMaximum' must be a Number\")\n    if (schema.type === 'integer' && !Number.isInteger(max))\n      throw new FluentSchemaError(\"'exclusiveMaximum' must be an Integer\")\n    return setAttribute({ schema, ...options }, [\n      'exclusiveMaximum',\n      max,\n      'number',\n    ])\n  },\n\n  /**\n   * It's strictly greater than 0.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.2.1|reference}\n   * @param {number} multiple\n   * @returns {FluentSchema}\n   */\n\n  multipleOf: multiple => {\n    if (typeof multiple !== 'number')\n      throw new FluentSchemaError(\"'multipleOf' must be a Number\")\n    if (schema.type === 'integer' && !Number.isInteger(multiple))\n      throw new FluentSchemaError(\"'multipleOf' must be an Integer\")\n    return setAttribute({ schema, ...options }, [\n      'multipleOf',\n      multiple,\n      'number',\n    ])\n  },\n})\n\nmodule.exports = {\n  NumberSchema,\n  default: NumberSchema,\n}\n","'use strict'\nconst merge = require('deepmerge')\nconst { BaseSchema } = require('./BaseSchema')\nconst {\n  omit,\n  setAttribute,\n  isFluentSchema,\n  hasCombiningKeywords,\n  patchIdsWithParentId,\n  appendRequired,\n  FluentSchemaError,\n  combineMerge,\n} = require('./utils')\n\nconst initialState = {\n  type: 'object',\n  definitions: [],\n  properties: [],\n  required: [],\n}\n\n/**\n * Represents a ObjectSchema.\n * @param {Object} [options] - Options\n * @param {StringSchema} [options.schema] - Default schema\n * @param {boolean} [options.generateIds = false] - generate the id automatically e.g. #properties.foo\n * @returns {StringSchema}\n */\n\nconst ObjectSchema = ({ schema = initialState, ...options } = {}) => {\n  // TODO LS think about default values and how pass all of them through the functions\n  options = {\n    generateIds: false,\n    factory: ObjectSchema,\n    ...options,\n  }\n  return {\n    ...BaseSchema({ ...options, schema }),\n\n    /**\n     * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.\n     * Validation with \"additionalProperties\" applies only to the child values of instance names that do not match any names in \"properties\",\n     * and do not match any regular expression in \"patternProperties\".\n     * For all such properties, validation succeeds if the child instance validates against the \"additionalProperties\" schema.\n     * Omitting this keyword has the same behavior as an empty schema.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.5.6|reference}\n     * @param {FluentSchema|boolean} value\n     * @returns {FluentSchema}\n     */\n\n    additionalProperties: value => {\n      if (typeof value === 'boolean') {\n        return setAttribute({ schema, ...options }, [\n          'additionalProperties',\n          value,\n          'object',\n        ])\n      }\n      if (isFluentSchema(value)) {\n        const { $schema, ...rest } = value.valueOf({ isRoot: false })\n        return setAttribute({ schema, ...options }, [\n          'additionalProperties',\n          { ...rest },\n          'array',\n        ])\n      }\n\n      throw new FluentSchemaError(\n        \"'additionalProperties' must be a boolean or a S\"\n      )\n    },\n\n    /**\n     * An object instance is valid against \"maxProperties\" if its number of properties is less than, or equal to, the value of this keyword.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.5.1|reference}\n     * @param {number} max\n     * @returns {FluentSchema}\n     */\n\n    maxProperties: max => {\n      if (!Number.isInteger(max))\n        throw new FluentSchemaError(\"'maxProperties' must be a Integer\")\n      return setAttribute({ schema, ...options }, [\n        'maxProperties',\n        max,\n        'object',\n      ])\n    },\n\n    /**\n     * An object instance is valid against \"minProperties\" if its number of properties is greater than, or equal to, the value of this keyword.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.5.2|reference}\n     * @param {number} min\n     * @returns {FluentSchema}\n     */\n\n    minProperties: min => {\n      if (!Number.isInteger(min))\n        throw new FluentSchemaError(\"'minProperties' must be a Integer\")\n      return setAttribute({ schema, ...options }, [\n        'minProperties',\n        min,\n        'object',\n      ])\n    },\n\n    /**\n     * Each property name of this object SHOULD be a valid regular expression, according to the ECMA 262 regular expression dialect.\n     * Each property value of this object MUST be a valid JSON Schema.\n     * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.\n     * Validation of the primitive instance type against this keyword always succeeds.\n     * Validation succeeds if, for each instance name that matches any regular expressions that appear as a property name in this keyword's value, the child instance for that name successfully validates against each schema that corresponds to a matching regular expression.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.5.5|reference}\n     * @param {object} opts\n     * @returns {FluentSchema}\n     */\n\n    patternProperties: opts => {\n      const values = Object.entries(opts).reduce((memo, [pattern, schema]) => {\n        if (!isFluentSchema(schema))\n          throw new FluentSchemaError(\n            \"'patternProperties' invalid options. Provide a valid map e.g. { '^fo.*$': S.string() }\"\n          )\n        return {\n          ...memo,\n          [pattern]: omit(schema.valueOf({ isRoot: false }), ['$schema']),\n        }\n      }, {})\n      return setAttribute({ schema, ...options }, [\n        'patternProperties',\n        values,\n        'object',\n      ])\n    },\n\n    /**\n     * This keyword specifies rules that are evaluated if the instance is an object and contains a certain property.\n     * This keyword's value MUST be an object. Each property specifies a dependency. Each dependency value MUST be an array or a valid JSON Schema.\n     * If the dependency value is a subschema, and the dependency key is a property in the instance, the entire instance must validate against the dependency value.\n     * If the dependency value is an array, each element in the array, if any, MUST be a string, and MUST be unique. If the dependency key is a property in the instance, each of the items in the dependency value must be a property that exists in the instance.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.5.7|reference}\n     * @param {object} opts\n     * @returns {FluentSchema}\n     */\n\n    dependencies: opts => {\n      const values = Object.entries(opts).reduce((memo, [prop, schema]) => {\n        if (!isFluentSchema(schema) && !Array.isArray(schema))\n          throw new FluentSchemaError(\n            \"'dependencies' invalid options. Provide a valid map e.g. { 'foo': ['bar'] } or { 'foo': S.string() }\"\n          )\n        return {\n          ...memo,\n          [prop]: Array.isArray(schema)\n            ? schema\n            : omit(schema.valueOf({ isRoot: false }), ['$schema', 'type', 'definitions']),\n        }\n      }, {})\n      return setAttribute({ schema, ...options }, [\n        'dependencies',\n        values,\n        'object',\n      ])\n    },\n\n    /**\n     * The value of \"properties\" MUST be an object. Each dependency value MUST be an array.\n     * Each element in the array MUST be a string and MUST be unique. If the dependency key is a property in the instance, each of the items in the dependency value must be a property that exists in the instance.\n     * \n     * {@link https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.6.5.4|reference}\n     * @param {object} opts\n     * @returns {FluentSchema}\n     */\n\n    dependentRequired: opts => {\n    const values = Object.entries(opts).reduce((memo, [prop, schema]) => {\n      if (!Array.isArray(schema))\n        throw new FluentSchemaError(\n          \"'dependentRequired' invalid options. Provide a valid array e.g. { 'foo': ['bar'] }\"\n        )\n      return {\n        ...memo,\n        [prop]: schema,\n      }\n    }, {})\n\n    return setAttribute({ schema, ...options }, [\n      'dependentRequired',\n      values,\n      'object',\n    ])\n  },\n\n    /**\n     * The value of \"properties\" MUST be an object. The dependency value MUST be a valid JSON Schema.\n     * Each dependency key is a property in the instance and the entire instance must validate against the dependency value.\n     * \n     * {@link https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.9.2.2.4|reference}\n     * @param {object} opts\n     * @returns {FluentSchema}\n     */\n  dependentSchemas: opts => {\n    const values = Object.entries(opts).reduce((memo, [prop, schema]) => {\n      if (!isFluentSchema(schema))\n        throw new FluentSchemaError(\n          \"'dependentSchemas' invalid options. Provide a valid schema e.g. { 'foo': S.string() }\"\n        )\n\n      return {\n        ...memo,\n        [prop]: omit(schema.valueOf({ isRoot: false }), ['$schema', 'type', 'definitions']),\n      }\n    }, {})\n\n    return setAttribute({ schema, ...options }, [\n      'dependentSchemas',\n      values,\n      'object',\n    ])\n  },\n\n    /**\n     * If the instance is an object, this keyword validates if every property name in the instance validates against the provided schema.\n     * Note the property name that the schema is testing will always be a string.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.5.8|reference}\n     * @param {FluentSchema} value\n     * @returns {FluentSchema}\n     */\n\n    propertyNames: value => {\n      if (!isFluentSchema(value))\n        throw new FluentSchemaError(\"'propertyNames' must be a S\")\n      return setAttribute({ schema, ...options }, [\n        'propertyNames',\n        omit(value.valueOf({ isRoot: false }), ['$schema']),\n        'object',\n      ])\n    },\n\n    /**\n     * The value of \"properties\" MUST be an object. Each value of this object MUST be a valid JSON Schema.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.5.4|reference}\n     * @param {string} name\n     * @param {FluentSchema} props\n     * @returns {FluentSchema}\n     */\n\n    prop: (name, props = {}) => {\n      if (Array.isArray(props) || typeof props !== 'object')\n        throw new FluentSchemaError(\n          `'${name}' doesn't support value '${JSON.stringify(\n            props\n          )}'. Pass a FluentSchema object`\n        )\n      const target = props.def ? 'definitions' : 'properties'\n      let attributes = props.valueOf({ isRoot: false })\n      const $id =\n        attributes.$id ||\n        (options.generateIds ? `#${target}/${name}` : undefined)\n      if (isFluentSchema(props)) {\n        attributes = patchIdsWithParentId({\n          schema: attributes,\n          parentId: $id,\n          ...options,\n        })\n\n        const [schemaPatched, attributesPatched] = appendRequired({\n          schema,\n          attributes: {\n            ...attributes,\n            name,\n          },\n        })\n\n        schema = schemaPatched\n        attributes = attributesPatched\n      }\n\n      const type = hasCombiningKeywords(attributes)\n        ? undefined\n        : attributes.type\n\n      const $ref = attributes.$ref\n\n      // strip undefined values or empty arrays or internals\n      attributes = Object.entries({ ...attributes, $id, type }).reduce(\n        (memo, [key, value]) => {\n          return key === '$schema' ||\n            key === 'def' ||\n            value === undefined ||\n            (Array.isArray(value) && value.length === 0 && key !== 'default')\n            ? memo\n            : { ...memo, [key]: value }\n        },\n        {}\n      )\n\n      return ObjectSchema({\n        schema: {\n          ...schema,\n          [target]: [\n            ...schema[target],\n            $ref ? { name, $ref } : Object.assign({}, { name }, attributes),\n          ],\n        },\n        ...options,\n      })\n    },\n\n    extend: base => {\n      if (!base) {\n        throw new FluentSchemaError(\"Schema can't be null or undefined\")\n      }\n      if (!base.isFluentSchema) {\n        throw new FluentSchemaError(\"Schema isn't FluentSchema type\")\n      }\n      const src = base._getState()\n      const extended = merge(src, schema, { arrayMerge: combineMerge })\n      const {\n        valueOf,\n        isFluentSchema,\n        FLUENT_SCHEMA,\n        _getState,\n        extend,\n        ...rest\n      } = ObjectSchema({ schema: extended, ...options })\n      return { valueOf, isFluentSchema, FLUENT_SCHEMA, _getState, extend }\n    },\n\n    /**\n     * Returns an object schema with only a subset of keys provided\n     *\n     * @param properties a list of properties you want to keep\n     * @returns {ObjectSchema}\n     */\n    only: properties => {\n      return ObjectSchema({\n        schema: {\n          ...schema,\n          properties: schema.properties.filter(p =>\n            properties.includes(p.name)\n          ),\n          required: schema.required.filter(p => properties.includes(p)),\n        },\n        ...options,\n      })\n    },\n\n    /**\n     * The \"definitions\" keywords provides a standardized location for schema authors to inline re-usable JSON Schemas into a more general schema.\n     * There are no restrictions placed on the values within the array.\n     *\n     * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.9|reference}\n     * @param {string} name\n     * @param {FluentSchema} props\n     * @returns {FluentSchema}\n     */\n    // FIXME LS move to BaseSchema and remove .prop\n    // TODO LS Is a definition a proper schema?\n    definition: (name, props = {}) =>\n      ObjectSchema({ schema, ...options }).prop(name, {\n        ...props.valueOf({ isRoot: false }),\n        def: true,\n      }),\n  }\n}\n\nmodule.exports = {\n  ObjectSchema,\n  default: ObjectSchema,\n}\n","'use strict'\nconst { BaseSchema } = require('./BaseSchema')\nconst { BooleanSchema } = require('./BooleanSchema')\nconst { StringSchema } = require('./StringSchema')\nconst { NumberSchema } = require('./NumberSchema')\nconst { IntegerSchema } = require('./IntegerSchema')\nconst { ObjectSchema } = require('./ObjectSchema')\nconst { ArraySchema } = require('./ArraySchema')\nconst { toArray, FluentSchemaError } = require('./utils')\n\n/**\n * Represents a raw JSON Schema that will be parsed\n * @param {Object} schema\n * @returns {FluentSchema}\n */\n\nconst RawSchema = (schema = {}) => {\n  if (typeof schema !== 'object') {\n    throw new FluentSchemaError('A fragment must be a JSON object')\n  }\n  const { type, definitions, properties, required, ...props } = schema\n  switch (schema.type) {\n    case 'string': {\n      const schema = {\n        type,\n        ...props,\n      }\n      return StringSchema({ schema, factory: StringSchema })\n    }\n\n    case 'integer': {\n      const schema = {\n        type,\n        ...props,\n      }\n      return IntegerSchema({ schema, factory: NumberSchema })\n    }\n    case 'number': {\n      const schema = {\n        type,\n        ...props,\n      }\n      return NumberSchema({ schema, factory: NumberSchema })\n    }\n\n    case 'boolean': {\n      const schema = {\n        type,\n        ...props,\n      }\n      return BooleanSchema({ schema, factory: BooleanSchema })\n    }\n\n    case 'object': {\n      const schema = {\n        type,\n        definitions: toArray(definitions) || [],\n        properties: toArray(properties) || [],\n        required: required || [],\n        ...props,\n      }\n      return ObjectSchema({ schema, factory: ObjectSchema })\n    }\n\n    case 'array': {\n      const schema = {\n        type,\n        ...props,\n      }\n      return ArraySchema({ schema, factory: ArraySchema })\n    }\n\n    default: {\n      const schema = {\n        ...props,\n      }\n\n      return BaseSchema({\n        schema,\n        factory: BaseSchema,\n      })\n    }\n  }\n}\n\nmodule.exports = {\n  RawSchema,\n  default: RawSchema,\n}\n","'use strict'\nconst { BaseSchema } = require('./BaseSchema')\nconst { FORMATS, setAttribute, FluentSchemaError } = require('./utils')\n\nconst initialState = {\n  type: 'string',\n  // properties: [], //FIXME it shouldn't be set for a string because it has only attributes\n  required: [],\n}\n\n/**\n * Represents a StringSchema.\n * @param {Object} [options] - Options\n * @param {StringSchema} [options.schema] - Default schema\n * @param {boolean} [options.generateIds = false] - generate the id automatically e.g. #properties.foo\n * @returns {StringSchema}\n */\n// https://medium.com/javascript-scene/javascript-factory-functions-with-es6-4d224591a8b1\n// Factory Functions for Mixin Composition withBaseSchema\nconst StringSchema = (\n  { schema, ...options } = {\n    schema: initialState,\n    generateIds: false,\n    factory: StringSchema,\n  }\n) => ({\n  ...BaseSchema({ ...options, schema }),\n  /*/!**\n   * Set a property to type string\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.3|reference}\n   * @returns {StringSchema}\n   *!/\n\n  string: () =>\n    StringSchema({ schema: { ...schema }, ...options }).as('string'),*/\n\n  /**\n   * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.\n   * The length of a string instance is defined as the number of its characters as defined by RFC 7159 [RFC7159].\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.3.2|reference}\n   * @param {number} min\n   * @returns {StringSchema}\n   */\n\n  minLength: min => {\n    if (!Number.isInteger(min))\n      throw new FluentSchemaError(\"'minLength' must be an Integer\")\n    return setAttribute({ schema, ...options }, ['minLength', min, 'string'])\n  },\n\n  /**\n   * A string instance is valid against this keyword if its length is less than, or equal to, the value of this keyword.\n   * The length of a string instance is defined as the number of its characters as defined by RFC 7159 [RFC7159].\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.3.1|reference}\n   * @param {number} max\n   * @returns {StringSchema}\n   */\n\n  maxLength: max => {\n    if (!Number.isInteger(max))\n      throw new FluentSchemaError(\"'maxLength' must be an Integer\")\n    return setAttribute({ schema, ...options }, ['maxLength', max, 'string'])\n  },\n\n  /**\n   * A string value can be RELATIVE_JSON_POINTER, JSON_POINTER, UUID, REGEX, IPV6, IPV4, HOSTNAME, EMAIL, URL, URI_TEMPLATE, URI_REFERENCE, URI, TIME, DATE,\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.7.3|reference}\n   * @param {string} format\n   * @returns {StringSchema}\n   */\n\n  format: format => {\n    if (!Object.values(FORMATS).includes(format))\n      throw new FluentSchemaError(\n        `'format' must be one of ${Object.values(FORMATS).join(', ')}`\n      )\n    return setAttribute({ schema, ...options }, ['format', format, 'string'])\n  },\n\n  /**\n   *  This string SHOULD be a valid regular expression, according to the ECMA 262 regular expression dialect.\n   *  A string instance is considered valid if the regular expression matches the instance successfully.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.6.3.3|reference}\n   * @param {string} pattern\n   * @returns {StringSchema}\n   */\n  pattern: pattern => {\n    if (!(typeof pattern === 'string') && !(pattern instanceof RegExp))\n      throw new FluentSchemaError(\n        `'pattern' must be a string or a RegEx (e.g. /.*/)`\n      )\n\n    if (pattern instanceof RegExp) {\n      const flags = new RegExp(pattern).flags\n      pattern = pattern\n        .toString()\n        .substr(1)\n        .replace(new RegExp(`/${flags}$`), '')\n    }\n\n    return setAttribute({ schema, ...options }, ['pattern', pattern, 'string'])\n  },\n\n  /**\n   *  If the instance value is a string, this property defines that the string SHOULD\n   *  be interpreted as binary data and decoded using the encoding named by this property.\n   *  RFC 2045, Sec 6.1 [RFC2045] lists the possible values for this property.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.8.3|reference}\n   * @param {string} encoding\n   * @returns {StringSchema}\n   */\n\n  contentEncoding: encoding => {\n    if (!(typeof encoding === 'string'))\n      throw new FluentSchemaError(`'contentEncoding' must be a string`)\n    return setAttribute({ schema, ...options }, [\n      'contentEncoding',\n      encoding,\n      'string',\n    ])\n  },\n\n  /**\n   *  The value of this property must be a media type, as defined by RFC 2046 [RFC2046].\n   *  This property defines the media type of instances which this schema defines.\n   *\n   * {@link https://tools.ietf.org/id/draft-handrews-json-schema-validation-01.html#rfc.section.8.4|reference}\n   * @param {string} mediaType\n   * @returns {StringSchema}\n   */\n\n  contentMediaType: mediaType => {\n    if (!(typeof mediaType === 'string'))\n      throw new FluentSchemaError(`'contentMediaType' must be a string`)\n    return setAttribute({ schema, ...options }, [\n      'contentMediaType',\n      mediaType,\n      'string',\n    ])\n  },\n})\n\nmodule.exports = {\n  StringSchema,\n  FORMATS,\n  default: StringSchema,\n}\n","'use strict'\nconst merge = require('deepmerge')\nconst isFluentSchema = obj => obj && obj.isFluentSchema\n\nconst hasCombiningKeywords = attributes =>\n  attributes.allOf || attributes.anyOf || attributes.oneOf || attributes.not\n\nclass FluentSchemaError extends Error {\n  constructor(message) {\n    super(message)\n    this.name = 'FluentSchemaError'\n  }\n}\n\nconst last = array => {\n  if (!array) return\n  const [prop] = [...array].reverse()\n  return prop\n}\n\nconst isUniq = array => array.filter((v, i, a) => a.indexOf(v) === i).length === array.length;\n\nconst omit = (obj, props) =>\n  Object.entries(obj).reduce((memo, [key, value]) => {\n    if (props.includes(key)) return memo\n    return {\n      ...memo,\n      [key]: value,\n    }\n  }, {})\n\nconst flat = array =>\n  array.reduce((memo, prop) => {\n    const { name, ...rest } = prop\n    return {\n      ...memo,\n      [name]: rest,\n    }\n  }, {})\n\nconst combineMerge = (target, source, options) => {\n  const destination = target.slice()\n\n  source.forEach((item, index) => {\n    const prop = target.find(attr => attr.name === item.name)\n    if (typeof destination[index] === 'undefined') {\n      destination[index] = options.cloneUnlessOtherwiseSpecified(item, options)\n    } else if (options.isMergeableObject(prop)) {\n      const propIndex = target.findIndex(prop => prop.name === item.name)\n      destination[propIndex] = merge(prop, item, options)\n    } else if (target.indexOf(item) === -1) {\n      destination.push(item)\n    }\n  })\n  return destination\n}\n\nconst toArray = obj =>\n  obj && Object.entries(obj).map(([key, value]) => ({ name: key, ...value }))\n\nconst REQUIRED = Symbol('required')\nconst FLUENT_SCHEMA = Symbol.for('fluent-schema-object')\n\nconst RELATIVE_JSON_POINTER = 'relative-json-pointer'\nconst JSON_POINTER = 'json-pointer'\nconst UUID = 'uuid'\nconst REGEX = 'regex'\nconst IPV6 = 'ipv6'\nconst IPV4 = 'ipv4'\nconst HOSTNAME = 'hostname'\nconst EMAIL = 'email'\nconst URL = 'url'\nconst URI_TEMPLATE = 'uri-template'\nconst URI_REFERENCE = 'uri-reference'\nconst URI = 'uri'\nconst TIME = 'time'\nconst DATE = 'date'\nconst DATE_TIME = 'date-time'\n\nconst FORMATS = {\n  RELATIVE_JSON_POINTER,\n  JSON_POINTER,\n  UUID,\n  REGEX,\n  IPV6,\n  IPV4,\n  HOSTNAME,\n  EMAIL,\n  URL,\n  URI_TEMPLATE,\n  URI_REFERENCE,\n  URI,\n  TIME,\n  DATE,\n  DATE_TIME,\n}\n\nconst STRING = 'string'\nconst NUMBER = 'number'\nconst BOOLEAN = 'boolean'\nconst INTEGER = 'integer'\nconst OBJECT = 'object'\nconst ARRAY = 'array'\nconst NULL = 'null'\n\nconst TYPES = {\n  STRING,\n  NUMBER,\n  BOOLEAN,\n  INTEGER,\n  OBJECT,\n  ARRAY,\n  NULL,\n}\n\nconst patchIdsWithParentId = ({ schema, generateIds, parentId }) => {\n  const properties = Object.entries(schema.properties || {})\n  if (properties.length === 0) return schema\n  return {\n    ...schema,\n    properties: properties.reduce((memo, [key, props]) => {\n      const target = props.def ? 'definitions' : 'properties'\n      const $id = props.$id || (generateIds ? `#${target}/${key}` : undefined)\n      return {\n        ...memo,\n        [key]: {\n          ...props,\n          $id:\n            generateIds && parentId\n              ? `${parentId}/${$id.replace('#', '')}`\n              : $id, // e.g. #properties/foo/properties/bar\n        },\n      }\n    }, {}),\n  }\n}\n\nconst appendRequired = ({\n  attributes: { name, required, ...attributes },\n  schema,\n}) => {\n  const { schemaRequired, attributeRequired } = (required || []).reduce(\n    (memo, item) => {\n      return item === REQUIRED\n        ? {\n            ...memo,\n            // append prop name to the schema.required\n            schemaRequired: [...memo.schemaRequired, name],\n          }\n        : {\n            ...memo,\n            // propagate required attributes\n            attributeRequired: [...memo.attributeRequired, item],\n          }\n    },\n    { schemaRequired: [], attributeRequired: [] }\n  )\n\n  const patchedRequired = [...schema.required, ...schemaRequired];\n  if(!isUniq(patchedRequired)){\n    throw new FluentSchemaError(\"'required' has repeated keys, check your calls to .required()\")\n  }\n\n  const schemaPatched = {\n    ...schema,\n    required: patchedRequired,\n  }\n  const attributesPatched = {\n    ...attributes,\n    required: attributeRequired,\n  }\n  return [schemaPatched, attributesPatched]\n}\n\nconst setAttribute = ({ schema, ...options }, attribute) => {\n  const [key, value] = attribute\n  const currentProp = last(schema.properties)\n  if (currentProp) {\n    const { name, ...props } = currentProp\n    return options.factory({ schema, ...options }).prop(name, {\n      [key]: value,\n      ...props,\n    })\n  }\n  return options.factory({ schema: { ...schema, [key]: value }, ...options })\n}\n\nconst setRaw = ({ schema, ...options }, raw) => {\n  const currentProp = last(schema.properties)\n  if (currentProp) {\n    const { name, ...props } = currentProp\n    return options.factory({ schema, ...options }).prop(name, {\n      ...raw,\n      ...props,\n    })\n  }\n  return options.factory({ schema: { ...schema, ...raw }, ...options })\n}\n// TODO LS maybe we can just use setAttribute and remove this one\nconst setComposeType = ({ prop, schemas, schema, options }) => {\n  if (!(Array.isArray(schemas) && schemas.every(v => isFluentSchema(v)))) {\n    throw new FluentSchemaError(\n      `'${prop}' must be a an array of FluentSchema rather than a '${typeof schemas}'`\n    )\n  }\n\n  const values = schemas.map(schema => {\n    const { $schema, ...props } = schema.valueOf({ isRoot: false })\n    return props\n  })\n\n  return options.factory({ schema: { ...schema, [prop]: values }, ...options })\n}\n\nmodule.exports = {\n  isFluentSchema,\n  hasCombiningKeywords,\n  FluentSchemaError,\n  last,\n  isUniq,\n  flat,\n  toArray,\n  omit,\n  REQUIRED,\n  patchIdsWithParentId,\n  appendRequired,\n  setRaw,\n  setAttribute,\n  setComposeType,\n  combineMerge,\n  FORMATS,\n  TYPES,\n  FLUENT_SCHEMA,\n}\n"],"sourceRoot":""}