@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/esm/lib/validation/engine/json-schema/parsers/json.js

@@ -0,0 +1,1460 @@
+/**
+ * Derived from the upstream lib/parsers/json.js (see UPSTREAM.md; MIT, see THIRD_PARTY_NOTICES.md)
+ */
+import { escapeRegex } from '../../utils/index.js';
+import { FLOAT_MAX, integerTypes } from '../../schema/types/number.js';
+import { combinations } from '../combinations.js';
+import * as _ from '../helpers.js';
+/**
+ * Default logical operator (or/and/nand/xor/oxor) parsers
+ */
+const LOGICAL_OP_PARSER = {
+    or: function (schema, dependency) {
+        schema.anyOf = _.map(dependency.peers, (peer) => {
+            return { required: [peer] };
+        });
+    },
+    and: function (schema, dependency) {
+        schema.oneOf = [{ required: dependency.peers }];
+        schema.oneOf.push({
+            allOf: _.map(dependency.peers, (peer) => {
+                return { not: { required: [peer] } };
+            })
+        });
+    },
+    nand: function (schema, dependency) {
+        schema.not = { required: dependency.peers };
+    },
+    xor: function (schema, dependency) {
+        schema.if = {
+            propertyNames: { enum: dependency.peers },
+            minProperties: 2
+        };
+        schema.then = false;
+        schema.else = {
+            oneOf: _.map(dependency.peers, (peer) => {
+                return { required: [peer] };
+            })
+        };
+    },
+    oxor: function (schema, dependency) {
+        schema.oneOf = _.map(dependency.peers, (peer) => {
+            return { required: [peer] };
+        });
+        schema.oneOf.push({
+            not: {
+                oneOf: _.map(combinations(dependency.peers, 1, 2), (combination) => {
+                    return { required: combination };
+                })
+            }
+        });
+    },
+    with: function (schema, dependency) {
+        schema.dependencies = schema.dependencies || {};
+        schema.dependencies[dependency.key] = dependency.peers;
+    },
+    without: function (schema, dependency) {
+        schema.if = { required: [dependency.key] };
+        schema.then = {
+            not: {
+                anyOf: _.map(dependency.peers, (peer) => {
+                    return { required: [peer] };
+                })
+            }
+        };
+    }
+};
+/**
+ * The rules of number schemas which require integers
+ */
+const INTEGER_RULES = ['integer', 'port', ...Object.keys(integerTypes)];
+/**
+ * The rules the type setters convert, by type (the rules of the other types, and the other rules, are dropped)
+ */
+const CONVERTED_RULES = {
+    any: ['allOf'],
+    alternatives: ['allOf'],
+    boolean: ['allOf'],
+    number: ['allOf', 'min', 'max', 'greater', 'less', 'multiple', 'sign', 'port', 'float', 'double', 'integer', ...Object.keys(integerTypes)],
+    bigint: ['allOf', 'min', 'max', 'greater', 'less', 'multiple', 'negative', 'positive'],
+    string: ['allOf', 'min', 'max', 'length', 'format', 'email', 'hostname', 'uri', 'ip', 'pattern', 'alphanum', 'token', 'hex', 'trim', 'isoDate', 'isoDuration', 'guid', 'uuid'],
+    object: ['allOf', 'min', 'max', 'length', 'keyNames'],
+    array: ['allOf', 'min', 'max', 'length', 'unique', 'has', 'items', 'ordered']
+};
+/**
+ * The schema types which no JSON value matches
+ */
+const NON_JSON_TYPES = ['function', 'symbol'];
+/**
+ * The keywords which annotate a schema, without constraining the values
+ */
+const ANNOTATIONS = ['title', 'description', 'default', 'examples', 'example', 'deprecated', 'readOnly', 'writeOnly', '$comment'];
+/**
+ * The keywords of a subschema, which a single schema object can only hold once
+ */
+const CONDITION_KEYWORDS = ['if', 'then', 'else'];
+/**
+ * Recognize the `override` representation in `describe()` output.
+ *
+ * `override` is a Symbol that can be used in `any().valid(…)`
+ * statements, to reset the list of valid values. In `describe()` output, it
+ * turns up as an object with 1 property:
+ *
+ * ```
+ * { override: true }
+ * ```
+ */
+function isOverride(e) {
+    return typeof e === 'object'
+        && e !== null
+        && Object.keys(e).length === 1
+        && e.override === true;
+}
+/**
+ * Whether a value is a JSON value (lakutata's own)
+ * @param value
+ */
+function isJsonValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype)
+        return Object.values(value).every(isJsonValue);
+    return false;
+}
+/**
+ * The literal values of a values list of a schema description (null: a reference or a template, not expressible)
+ * @param values
+ */
+function literals(values) {
+    const result = [];
+    for (const value of values || []) {
+        if (isOverride(value))
+            continue;
+        if (value !== null && typeof value === 'object') {
+            const keys = Object.keys(value);
+            if (keys.length === 1 && keys[0] === 'value') {
+                result.push(value.value);
+                continue;
+            }
+            return null;
+        }
+        result.push(value);
+    }
+    return result;
+}
+/**
+ * The number of a limit of a schema description (undefined: a reference, or not a safe number)
+ * @param limit
+ */
+function numberLimit(limit) {
+    if (typeof limit === 'number' && isFinite(limit))
+        return limit;
+    if (typeof limit === 'bigint' && limit <= BigInt(Number.MAX_SAFE_INTEGER) && limit >= BigInt(Number.MIN_SAFE_INTEGER))
+        return Number(limit);
+    return undefined;
+}
+/**
+ * The tighter of a bound and a limit
+ * @param bound
+ * @param limit
+ * @param exclusive
+ * @param lower
+ */
+function tighter(bound, limit, exclusive, lower) {
+    const value = numberLimit(limit);
+    if (value === undefined)
+        return bound;
+    if (!bound || (lower ? value > bound.value : value < bound.value))
+        return { value, exclusive };
+    if (value === bound.value && exclusive)
+        return { value, exclusive };
+    return bound;
+}
+/**
+ * The pattern of a regular expression of a schema description (null: its flags have no JSON Schema equivalent, or it
+ * is not a valid Unicode regular expression, as JSON Schema patterns are)
+ * @param regex
+ */
+function toPattern(regex) {
+    if (typeof regex !== 'string')
+        return null;
+    const match = /^\/([\s\S]*)\/([a-z]*)$/.exec(regex);
+    if (!match)
+        return null;
+    const [, source, flags] = match;
+    if (/[imsgyv]/.test(flags))
+        return null;
+    try {
+        new RegExp(source, 'u');
+    }
+    catch {
+        return null;
+    }
+    return { source, flags };
+}
+/**
+ * A pattern matching the strings of a list, case-insensitively (as the insensitive flag compares them)
+ * @param values
+ */
+function insensitivePattern(values) {
+    const alternatives = values.map((value) => Array.from(value).map((character) => {
+        const lower = character.toLowerCase();
+        const upper = character.toUpperCase();
+        if (lower === upper || Array.from(lower).length !== 1 || Array.from(upper).length !== 1)
+            return escapeRegex(character);
+        return `[${escapeRegex(lower)}${escapeRegex(upper)}]`;
+    }).join(''));
+    return `^(?:${alternatives.join('|')})$`;
+}
+/**
+ * Converts schema descriptions into JSON schemas (draft 07)
+ */
+export class JsonSchemaParser {
+    constructor(opts = {}) {
+        //Whether the schema being converted is exact so far: nothing of it was dropped (lakutata's own)
+        this._exact = true;
+        //The converted schemas which are not exact: they accept more values than the schemas
+        this._inexactSchemas = new WeakSet();
+        //Like upstream: false options read as no options
+        const settings = opts;
+        this.$schema = settings.$schema || 'http://json-schema.org/draft-07/schema#';
+        this.includeSchemaDialect = settings.includeSchemaDialect || false;
+        this.childrenFieldName = this._getChildrenFieldName();
+        this.optionsFieldName = this._getOptionsFieldName();
+        this.ruleArgFieldName = this._getRuleArgFieldName();
+        this.enumFieldName = this._getEnumFieldName();
+        this.allowUnknownFlagName = this._getAllowUnknownFlagName();
+        //The validation preferences the schemas are used with (lakutata's own)
+        this.inheritedPreferences = settings.preferences ? [settings.preferences] : [];
+        if (settings.logicalOpParser === false) {
+            this.logicalOpParser = {};
+        }
+        else {
+            this.logicalOpParser = _.merge({}, LOGICAL_OP_PARSER, settings.logicalOpParser);
+        }
+    }
+    parse(spec, definitions = {}, level = 0) {
+        const outer = this._exact;
+        this._exact = true;
+        const schema = this._parse(spec, definitions, level);
+        if (!this._exact)
+            this._inexactSchemas.add(schema);
+        this._exact = outer && this._exact;
+        return schema;
+    }
+    /**
+     * Whether a converted schema is exact: it accepts the values the schema accepts (without conversion), and only
+     * them (lakutata's own). Formats are named after the rules, and the numbers beyond the safe integers are accepted.
+     * @param schema
+     */
+    isExact(schema) {
+        return !this._inexactSchemas.has(schema);
+    }
+    /**
+     * Marks the schema being converted as not exact: something of it has no JSON Schema equivalent and is dropped
+     */
+    _inexact() {
+        this._exact = false;
+    }
+    _parse(spec, definitions, level) {
+        let schema = {};
+        const hasPreferences = this._pushInheritiedPreferences(spec);
+        if (this._getPresence(spec) === 'forbidden') {
+            if (hasPreferences)
+                this._popInheritiedPreferences();
+            schema.not = {};
+            return schema;
+        }
+        this._checkRules(spec);
+        this._setBasicProperties(schema, spec);
+        this._setNumberFieldProperties(schema, spec);
+        this._setBinaryFieldProperties(schema, spec);
+        this._setStringFieldProperties(schema, spec);
+        this._setDateFieldProperties(schema, spec);
+        this._setArrayFieldProperties(schema, spec, definitions, level);
+        this._setObjectProperties(schema, spec, definitions, level);
+        this._setAlternativesProperties(schema, spec, definitions, level);
+        this._setConditionProperties(schema, spec, definitions, level, 'whens');
+        this._setAllOf(schema, spec, definitions, level);
+        this._setMetaProperties(schema, spec);
+        this._setLinkFieldProperties(schema, spec);
+        this._setAnyProperties(schema);
+        this._setNonJsonProperties(schema, spec);
+        schema = this._setSingle(schema, spec);
+        schema = this._setValues(schema, spec);
+        if (!_.isEmpty(spec.shared)) {
+            _.each(spec.shared, (sharedSchema) => {
+                this.parse(sharedSchema, definitions, level);
+            });
+        }
+        this._copyMetasToSchema(spec, schema);
+        //Last step to remove any unknown keys that are not in the JSON Schema specification or known meta keys
+        schema = this._retainKnownKeys(schema);
+        const schemaId = _.get(spec, 'flags.id');
+        if (schemaId) {
+            definitions[schemaId] = schema;
+            schema = {
+                $ref: `${this._getLocalSchemaBasePath()}/${schemaId}`
+            };
+        }
+        if (level === 0 && !_.isEmpty(definitions))
+            _.set(schema, `${this._getLocalSchemaBasePath().replace('#/', '').replace(/\//, '.')}`, definitions);
+        if (this.includeSchemaDialect && level === 0 && this.$schema)
+            schema.$schema = this.$schema;
+        if (hasPreferences)
+            this._popInheritiedPreferences();
+        return schema;
+    }
+    _retainKnownKeys(schema) {
+        if (!this.knownKeys)
+            return schema;
+        const knownKeys = this.knownKeys;
+        const retained = _.pickBy(schema, (value, key) => knownKeys.includes(key) || this._isKnownMetaKey(key));
+        //A dropped keyword makes the schema not exact
+        if (Object.keys(schema).some((key) => !(key in retained) && !ANNOTATIONS.includes(key)))
+            this._inexact();
+        return retained;
+    }
+    /**
+     * Marks the schemas with constructs JSON Schema cannot express as not exact (the constructs the type setters do
+     * not convert)
+     * @param spec
+     */
+    _checkRules(spec) {
+        const converted = CONVERTED_RULES[spec.type];
+        //The types JSON has no equivalent for
+        if (!converted) {
+            if (!['any', 'alternatives', 'link', 'function', 'symbol'].includes(spec.type))
+                this._inexact();
+            if (spec.type === 'link' && _.get(spec, 'link.ref.type') !== 'local')
+                this._inexact();
+        }
+        for (const rule of spec.rules || []) {
+            if (!converted || !converted.includes(rule.name))
+                this._inexact();
+        }
+        const flags = spec.flags || {};
+        //Values made undefined, and single values as arrays
+        if (flags.empty !== undefined || flags.single)
+            this._inexact();
+        if (spec.renames || spec.externals)
+            this._inexact();
+    }
+    _pushInheritiedPreferences(spec) {
+        if (spec.preferences) {
+            this.inheritedPreferences.push(_.merge({}, this._getInheritedPreferences(), spec.preferences));
+            return true;
+        }
+        return false;
+    }
+    _popInheritiedPreferences() {
+        this.inheritedPreferences.pop();
+    }
+    _getInheritedPreferences() {
+        return this.inheritedPreferences[this.inheritedPreferences.length - 1] || {};
+    }
+    /**
+     * The preferences of a schema: its preferences merged with the inherited ones (upstream uses its preferences
+     * instead of the inherited ones)
+     * @param spec
+     */
+    _getPreferences(spec) {
+        const preferences = spec[this.optionsFieldName];
+        return preferences ? { ...this._getInheritedPreferences(), ...preferences } : this._getInheritedPreferences();
+    }
+    _isIfThenElseSupported() {
+        return true;
+    }
+    _getChildrenFieldName() {
+        return 'keys';
+    }
+    _getOptionsFieldName() {
+        return 'preferences';
+    }
+    _getRuleArgFieldName() {
+        return 'args';
+    }
+    _getEnumFieldName() {
+        return 'allow';
+    }
+    _getAllowUnknownFlagName() {
+        return 'unknown';
+    }
+    _getLocalSchemaBasePath() {
+        return '#/$defs';
+    }
+    _getFieldDescription(fieldDefn) {
+        return _.get(fieldDefn, 'flags.description');
+    }
+    _getFieldType(fieldDefn) {
+        const type = fieldDefn.type;
+        //Any integer rule makes an integer (upstream: only a first integer rule)
+        if (type === 'number' && _.some(fieldDefn.rules, (rule) => INTEGER_RULES.includes(rule.name)))
+            return 'integer';
+        //JSON has no big integers: they are integers
+        if (type === 'bigint')
+            return 'integer';
+        //No JSON value is a function or a symbol
+        if (NON_JSON_TYPES.includes(type))
+            return undefined;
+        return type;
+    }
+    /**
+     * Makes a schema with a null type nullable (OpenAPI 3.0), and replaces the type lists where types are lists
+     * @param _fieldSchema
+     * @param _fieldDefn
+     */
+    _addNullTypeIfNullable(_fieldSchema, _fieldDefn) {
+        //The null type is added by _setValues() (lakutata): JSON Schema has type lists
+    }
+    _getFieldExample(fieldDefn) {
+        const examples = _.get(fieldDefn, 'examples');
+        if (!Array.isArray(examples))
+            return examples;
+        const jsonExamples = examples.filter(isJsonValue);
+        return jsonExamples.length ? jsonExamples : undefined;
+    }
+    _getPresence(fieldDefn) {
+        const presence = _.get(fieldDefn, 'flags.presence');
+        if (presence !== undefined)
+            return presence;
+        const preferences = this._getPreferences(fieldDefn);
+        return _.get(preferences, 'presence');
+    }
+    _isRequired(fieldDefn) {
+        const presence = this._getPresence(fieldDefn);
+        return presence === 'required';
+    }
+    _getDefaultValue(fieldDefn) {
+        const value = _.get(fieldDefn, 'flags.default');
+        //Only JSON values: not a default computed by a function, or the deep default of objects
+        return isJsonValue(value) && !(value !== null && typeof value === 'object' && _.get(value, 'special') === 'deep') ? value : undefined;
+    }
+    /**
+     * Whether the unknown keys of an object are accepted (true), rejected (false), or must match a schema
+     * @param spec
+     */
+    _getUnknown(spec) {
+        const allowUnknown = _.get(spec, `flags.${this.allowUnknownFlagName}`);
+        if (allowUnknown !== undefined)
+            return allowUnknown;
+        const preferences = this._getPreferences(spec);
+        if (preferences.allowUnknown)
+            return true;
+        //The stripped unknown keys are accepted (lakutata)
+        const stripUnknown = preferences.stripUnknown;
+        return stripUnknown === true || !!(stripUnknown && stripUnknown.objects);
+    }
+    /**
+     * Whether the unknown keys of an object are stripped before its rules
+     * @param spec
+     */
+    _stripsUnknown(spec) {
+        if (_.get(spec, `flags.${this.allowUnknownFlagName}`) !== undefined)
+            return false;
+        //Without keys, the keys are not processed
+        if (!spec[this.childrenFieldName] && !spec.patterns)
+            return false;
+        const stripUnknown = _.get(this._getPreferences(spec), 'stripUnknown');
+        return stripUnknown === true || !!(stripUnknown && stripUnknown.objects);
+    }
+    /**
+     * Whether the items of arrays which match no item schema are stripped
+     * @param spec
+     */
+    _stripsArrayItems(spec) {
+        const stripUnknown = _.get(this._getPreferences(spec), 'stripUnknown');
+        return !!(stripUnknown && typeof stripUnknown === 'object' && stripUnknown.arrays);
+    }
+    _setIfNotEmpty(schema, field, value) {
+        if (value !== null && value !== undefined)
+            schema[field] = value;
+    }
+    /**
+     * The tighter of a bound and a limit (a reference limit is dropped)
+     * @param bound
+     * @param limit
+     * @param exclusive
+     * @param lower
+     */
+    _bound(bound, limit, exclusive, lower) {
+        if (numberLimit(limit) === undefined)
+            this._inexact();
+        return tighter(bound, limit, exclusive, lower);
+    }
+    /**
+     * Adds a keyword, or a subschema of the keyword to allOf when the schema has the keyword (lakutata)
+     * @param schema
+     * @param keyword
+     * @param value
+     */
+    _addKeyword(schema, keyword, value) {
+        if (schema[keyword] === undefined) {
+            schema[keyword] = value;
+        }
+        else {
+            schema.allOf = schema.allOf || [];
+            schema.allOf.push({ [keyword]: value });
+        }
+    }
+    /**
+     * Merges the keywords of a subschema, or adds the subschema to allOf when the keywords conflict (lakutata)
+     * @param schema
+     * @param part
+     */
+    _mergeKeywords(schema, part) {
+        const keys = Object.keys(part);
+        if (!keys.length)
+            return;
+        const conflicts = keys.some((key) => schema[key] !== undefined) ||
+            keys.some((key) => CONDITION_KEYWORDS.includes(key)) && CONDITION_KEYWORDS.some((key) => schema[key] !== undefined);
+        if (!conflicts) {
+            Object.assign(schema, part);
+        }
+        else if (keys.length === 1 && keys[0] === 'allOf') {
+            schema.allOf = [...(schema.allOf || []), ...part.allOf];
+        }
+        else {
+            schema.allOf = schema.allOf || [];
+            schema.allOf.push(part);
+        }
+    }
+    _setBasicProperties(fieldSchema, fieldDefn) {
+        this._setIfNotEmpty(fieldSchema, 'type', this._getFieldType(fieldDefn));
+        this._setIfNotEmpty(fieldSchema, 'examples', this._getFieldExample(fieldDefn));
+        this._setIfNotEmpty(fieldSchema, 'description', this._getFieldDescription(fieldDefn));
+        this._setIfNotEmpty(fieldSchema, 'default', this._getDefaultValue(fieldDefn));
+    }
+    /**
+     * The schema of a values list (only these values)
+     * @param values
+     */
+    _getValuesSchema(values) {
+        return values.length === 1 ? { const: values[0] } : { enum: values };
+    }
+    /**
+     * Applies the valid and invalid values of a schema description (lakutata's own; upstream sets the enum of the
+     * valid values, and adds null to the type): the valid values of `valid()` are the only accepted values, the
+     * values of `allow()` are accepted besides the values of the schema, and the invalid values are rejected
+     * @param schema
+     * @param spec
+     */
+    _setValues(schema, spec) {
+        const flags = spec.flags || {};
+        const allowed = literals(spec[this.enumFieldName]);
+        const invalid = literals(spec.invalid);
+        const annotations = {};
+        for (const key of Object.keys(schema)) {
+            if (ANNOTATIONS.includes(key) || key.startsWith('x-'))
+                annotations[key] = schema[key];
+        }
+        if (!allowed || !invalid)
+            this._inexact();
+        if (flags.only) {
+            //Only the valid values (the other keywords do not apply to them)
+            if (!allowed || !allowed.length)
+                return { ...annotations };
+            const values = _.uniq(allowed);
+            const strings = values.filter((value) => typeof value === 'string');
+            if (flags.insensitive && strings.length) {
+                const others = values.filter((value) => typeof value !== 'string');
+                const insensitive = { type: 'string', pattern: insensitivePattern(strings) };
+                if (!others.length)
+                    return { ...annotations, ...insensitive };
+                return { ...annotations, anyOf: [insensitive, this._getValuesSchema(others)] };
+            }
+            return { ...annotations, ...this._getValuesSchema(values) };
+        }
+        if (invalid && invalid.length)
+            this._addKeyword(schema, 'not', { enum: invalid });
+        //Strings are not empty, unless allowed, or a minimum length of zero (or made undefined by empty())
+        const allowsEmpty = !!allowed && allowed.includes('') ||
+            _.some(spec.rules, (rule) => rule.name === 'min' && _.get(rule, `${this.ruleArgFieldName}.limit`) === 0);
+        if (schema.type === 'string' && spec.type === 'string' && !allowsEmpty && flags.empty === undefined && !this._rejectsEmpty(schema))
+            schema.minLength = 1;
+        //Values of references may be allowed
+        if (!allowed)
+            return { ...annotations };
+        if (!allowed.length) {
+            this._addNullTypeIfNullable(schema, spec);
+            return schema;
+        }
+        //A schema without constraints accepts the allowed values
+        if (Object.keys(schema).every((key) => annotations[key] !== undefined))
+            return schema;
+        let rest = _.uniq(allowed);
+        //The empty string is accepted by the schema without its minLength
+        if (schema.type === 'string' && rest.includes('') && this._acceptsEmpty(schema))
+            rest = rest.filter((value) => value !== '');
+        //Null is added to the type
+        if (rest.includes(null) && this._canAddType(schema)) {
+            if (Array.isArray(schema.type)) {
+                if (!schema.type.includes('null'))
+                    schema.type = [...schema.type, 'null'];
+            }
+            else if (schema.type !== 'null') {
+                schema.type = [schema.type, 'null'];
+            }
+            rest = rest.filter((value) => value !== null);
+        }
+        this._addNullTypeIfNullable(schema, spec);
+        if (!rest.length)
+            return schema;
+        //The other allowed values are accepted besides the values of the schema
+        const constraints = {};
+        for (const key of Object.keys(schema)) {
+            if (annotations[key] === undefined)
+                constraints[key] = schema[key];
+        }
+        return { ...annotations, anyOf: [constraints, this._getValuesSchema(rest)] };
+    }
+    /**
+     * Arrays accepting single values also accept a value their items accept (lakutata's own)
+     * @param schema
+     * @param spec
+     */
+    _setSingle(schema, spec) {
+        if (spec.type !== 'array' || !_.get(spec, 'flags.single'))
+            return schema;
+        const annotations = {};
+        const constraints = {};
+        for (const key of Object.keys(schema)) {
+            if (ANNOTATIONS.includes(key) || key.startsWith('x-')) {
+                annotations[key] = schema[key];
+            }
+            else {
+                constraints[key] = schema[key];
+            }
+        }
+        const items = schema.prefixItems || schema.items;
+        //The single value must also make a valid array: its items schema is looser
+        const single = Array.isArray(items) ? (items.length ? { anyOf: items } : {}) : (items || {});
+        return { ...annotations, anyOf: [constraints, single] };
+    }
+    /**
+     * Whether a string schema certainly accepts the empty string
+     * @param schema
+     */
+    _acceptsEmpty(schema) {
+        for (const key of Object.keys(schema)) {
+            if (ANNOTATIONS.includes(key) || key.startsWith('x-') || key === 'type' || key === 'maxLength' || key === 'contentEncoding')
+                continue;
+            if (key === 'minLength' && schema.minLength < 1)
+                continue;
+            if (key === 'pattern' && new RegExp(schema.pattern, 'u').test(''))
+                continue;
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Whether a string schema certainly rejects the empty string
+     * @param schema
+     */
+    _rejectsEmpty(schema) {
+        if (typeof schema.minLength === 'number' && schema.minLength >= 1)
+            return true;
+        if (typeof schema.pattern === 'string' && !new RegExp(schema.pattern, 'u').test(''))
+            return true;
+        return typeof schema.format === 'string' && ['date', 'time', 'date-time', 'duration', 'email', 'idn-email', 'hostname', 'ipv4', 'ipv6', 'uri', 'uuid'].includes(schema.format);
+    }
+    /**
+     * Whether null can be accepted by adding it to the type of a schema: its keywords apply to other types
+     * @param schema
+     */
+    _canAddType(schema) {
+        if (!schema.type)
+            return false;
+        return !['enum', 'const', 'anyOf', 'oneOf', 'allOf', 'not', 'if', '$ref'].some((key) => schema[key] !== undefined);
+    }
+    _setBinaryFieldProperties(fieldSchema, fieldDefn) {
+        if (fieldSchema.type !== 'binary')
+            return;
+        fieldSchema.type = 'string';
+        if (fieldDefn.flags && fieldDefn.flags.encoding)
+            fieldSchema.contentEncoding = fieldDefn.flags.encoding;
+        this._setIfNotEmpty(fieldSchema, 'format', this._getBinaryFormat());
+    }
+    /**
+     * The format of binary strings (JSON Schema has none: upstream sets binary)
+     */
+    _getBinaryFormat() {
+        return undefined;
+    }
+    _setObjectProperties(schema, spec, definitions, level) {
+        if (schema.type !== 'object')
+            return;
+        const keys = spec[this.childrenFieldName];
+        const unknown = this._getUnknown(spec);
+        if (!keys && !spec.patterns) {
+            //Without keys, the schema accepts every key (upstream applies the unknown keys handling)
+            if (typeof unknown === 'object')
+                schema.additionalProperties = this.parse(unknown, definitions, level + 1);
+        }
+        else {
+            const properties = {};
+            const required = [];
+            schema.properties = properties;
+            _.map(keys, (fieldDefn, key) => {
+                const fieldSchema = this.parse(fieldDefn, definitions, level + 1);
+                if (this._isRequired(fieldDefn))
+                    required.push(key);
+                properties[key] = fieldSchema;
+            });
+            if (required.length)
+                schema.required = required;
+            const expressible = this._setPatternProperties(schema, spec, Object.keys(keys || {}), definitions, level);
+            if (!expressible || spec.renames) {
+                //Keys matched by patterns JSON Schema cannot express, and renamed keys, are accepted
+                this._inexact();
+                schema.additionalProperties = true;
+            }
+            else if (typeof unknown === 'object') {
+                schema.additionalProperties = this.parse(unknown, definitions, level + 1);
+            }
+            else {
+                schema.additionalProperties = unknown;
+            }
+        }
+        _.each(spec.rules, (rule) => {
+            const args = (rule[this.ruleArgFieldName] || {});
+            const limit = numberLimit(args.limit);
+            switch (rule.name) {
+                case 'min':
+                case 'length':
+                    //The keys with defaults may be added before the rules
+                    if (limit !== undefined && !_.some(Object.values(keys || {}), (key) => _.get(key, 'flags.default') !== undefined)) {
+                        this._addKeyword(schema, 'minProperties', limit);
+                        //The stripped unknown keys are not counted
+                        if (this._stripsUnknown(spec))
+                            this._inexact();
+                    }
+                    else {
+                        this._inexact();
+                    }
+                    if (rule.name === 'min')
+                        break;
+                //Falls through for length
+                case 'max':
+                    //The unknown keys may be stripped before the rules
+                    if (limit !== undefined && !this._stripsUnknown(spec)) {
+                        this._addKeyword(schema, 'maxProperties', limit);
+                    }
+                    else {
+                        this._inexact();
+                    }
+                    break;
+                case 'keyNames': {
+                    const names = this.parse(args.schema, definitions, level + 1);
+                    //The stripped unknown keys are not checked: only the defined keys and the keys of the patterns
+                    this._setPropertyNames(schema, this._stripsUnknown(spec) ? { anyOf: [names, { not: this._knownKeys(spec) }] } : names);
+                    break;
+                }
+                default:
+                    break;
+            }
+        });
+        this._setObjectDependencies(schema, spec);
+    }
+    /**
+     * Sets the schema of the key names
+     * @param schema
+     * @param names
+     */
+    _setPropertyNames(schema, names) {
+        this._addKeyword(schema, 'propertyNames', names);
+    }
+    /**
+     * Sets the patternProperties of the patterns of an object (lakutata's own; upstream also adds each pattern as a
+     * property): like the engine, a pattern applies to the keys which are not defined keys and which no previous
+     * pattern (without fallthrough) matched. Returns false when a pattern is not expressible.
+     * @param schema
+     * @param spec
+     * @param definedKeys
+     * @param definitions
+     * @param level
+     */
+    _setPatternProperties(schema, spec, definedKeys, definitions, level) {
+        if (!spec.patterns || !spec.patterns.length)
+            return true;
+        const patternProperties = {};
+        //The previous patterns which stop the matching of the next ones
+        const stops = [];
+        for (const patternObj of spec.patterns) {
+            if (typeof patternObj.rule !== 'object' || patternObj.regex === undefined)
+                return false;
+            if (patternObj.matches !== undefined)
+                return false;
+            const pattern = toPattern(patternObj.regex);
+            if (!pattern)
+                return false;
+            const regex = new RegExp(pattern.source, 'u');
+            const excludedKeys = definedKeys.filter((key) => regex.test(key));
+            let source = pattern.source;
+            if (excludedKeys.length || stops.length) {
+                //Backreferences would be renumbered by the groups of the other patterns
+                if ([pattern.source, ...stops].some((part) => /\\[1-9]|\\k</.test(part)))
+                    return false;
+                const exclusions = excludedKeys.length ? `(?!(?:${excludedKeys.map((key) => escapeRegex(key)).join('|')})$)` : '';
+                source = `^${exclusions}${stops.map((stop) => `(?![\\s\\S]*?(?:${stop}))`).join('')}[\\s\\S]*?(?:${pattern.source})`;
+                try {
+                    new RegExp(source, 'u');
+                }
+                catch {
+                    return false;
+                }
+            }
+            const ruleSchema = this.parse(patternObj.rule, definitions, level + 1);
+            if (patternProperties[source]) {
+                patternProperties[source] = { allOf: [patternProperties[source], ruleSchema] };
+            }
+            else {
+                patternProperties[source] = ruleSchema;
+            }
+            if (!patternObj.fallthrough)
+                stops.push(pattern.source);
+        }
+        schema.patternProperties = patternProperties;
+        return true;
+    }
+    /**
+     * The schema of the key names an object processes (its defined keys and the keys its patterns match)
+     * @param spec
+     */
+    _knownKeys(spec) {
+        const definedKeys = Object.keys((spec[this.childrenFieldName] || {}));
+        const known = definedKeys.length ? [{ enum: definedKeys }] : [];
+        for (const patternObj of spec.patterns || []) {
+            const pattern = toPattern(patternObj.regex);
+            //A key schema matches keys JSON Schema cannot express: any key may be known
+            if (!pattern)
+                return {};
+            known.push({ pattern: pattern.source });
+        }
+        if (!known.length)
+            return { not: {} };
+        return known.length === 1 ? known[0] : { anyOf: known };
+    }
+    /**
+     * Whether a key is processed by an object (not stripped as an unknown key)
+     * @param spec
+     * @param key
+     */
+    _isKnownKey(spec, key) {
+        if (Object.hasOwn((spec[this.childrenFieldName] || {}), key))
+            return true;
+        return _.some(spec.patterns, (patternObj) => {
+            const pattern = toPattern(patternObj.regex);
+            return !pattern || new RegExp(pattern.source, 'u').test(key);
+        });
+    }
+    _setObjectDependencies(schema, spec) {
+        if (!Array.isArray(spec.dependencies) || spec.dependencies.length === 0)
+            return;
+        const strips = this._stripsUnknown(spec);
+        const dependencies = spec.dependencies.filter((dependency) => {
+            const keys = [dependency.key, ...dependency.peers];
+            //Keys of nested objects have no JSON Schema equivalent, and the unknown keys are stripped before the
+            //dependencies are checked
+            if (keys.some((key) => typeof key === 'string' && (key.includes('.') || strips && !this._isKnownKey(spec, key)))) {
+                this._inexact();
+                return false;
+            }
+            return true;
+        });
+        if (dependencies.length === 1) {
+            this._mergeKeywords(schema, this._setDependencySubSchema({}, dependencies[0]));
+        }
+        else if (dependencies.length > 1) {
+            //Like upstream: the with dependencies are merged, the others are all of the dependencies
+            const allOf = [];
+            const withDependencies = {};
+            for (const dependency of dependencies) {
+                if (dependency.rel === 'with') {
+                    this._setDependencySubSchema(withDependencies, dependency);
+                    continue;
+                }
+                const subSchema = this._setDependencySubSchema({}, dependency);
+                if (!_.isEmpty(subSchema))
+                    allOf.push(subSchema);
+            }
+            if (allOf.length)
+                this._mergeKeywords(schema, { allOf });
+            this._mergeKeywords(schema, withDependencies);
+        }
+    }
+    _setDependencySubSchema(schema, dependency) {
+        const opParser = this.logicalOpParser[dependency.rel];
+        if (typeof opParser !== 'function') {
+            this._inexact();
+            return schema;
+        }
+        opParser(schema, dependency);
+        return schema;
+    }
+    /**
+     * The format of a number schema (JSON Schema has no number formats)
+     * @param _rules
+     */
+    _getNumberFormat(_rules) {
+        return undefined;
+    }
+    _setNumberFieldProperties(fieldSchema, fieldDefn) {
+        if (fieldSchema.type !== 'number' && fieldSchema.type !== 'integer')
+            return;
+        const ruleArgFieldName = this.ruleArgFieldName;
+        let lower;
+        let upper;
+        const rules = fieldDefn.rules || [];
+        _.each(rules, (rule) => {
+            const value = (rule[ruleArgFieldName] || {});
+            const range = integerTypes[rule.name];
+            if (range) {
+                lower = this._bound(lower, range[0], false, true);
+                upper = this._bound(upper, range[1], false, false);
+                return;
+            }
+            switch (rule.name) {
+                case 'max':
+                    upper = this._bound(upper, value.limit, false, false);
+                    break;
+                case 'min':
+                    lower = this._bound(lower, value.limit, false, true);
+                    break;
+                case 'greater':
+                    lower = this._bound(lower, value.limit, true, true);
+                    break;
+                case 'less':
+                    upper = this._bound(upper, value.limit, true, false);
+                    break;
+                case 'port':
+                    lower = this._bound(lower, 0, false, true);
+                    upper = this._bound(upper, 65535, false, false);
+                    break;
+                case 'float':
+                    lower = this._bound(lower, -FLOAT_MAX, false, true);
+                    upper = this._bound(upper, FLOAT_MAX, false, false);
+                    break;
+                case 'multiple': {
+                    const base = numberLimit(value.base);
+                    if (base !== undefined) {
+                        this._addKeyword(fieldSchema, 'multipleOf', base);
+                    }
+                    else {
+                        this._inexact();
+                    }
+                    break;
+                }
+                case 'sign':
+                case 'positive':
+                case 'negative': {
+                    const sign = rule.name === 'sign' ? value.sign : rule.name;
+                    if (sign === 'positive')
+                        lower = this._bound(lower, 0, true, true);
+                    if (sign === 'negative')
+                        upper = this._bound(upper, 0, true, false);
+                    break;
+                }
+                default:
+                    break;
+            }
+        });
+        if (lower)
+            fieldSchema[lower.exclusive ? 'exclusiveMinimum' : 'minimum'] = lower.value;
+        if (upper)
+            fieldSchema[upper.exclusive ? 'exclusiveMaximum' : 'maximum'] = upper.value;
+        this._setIfNotEmpty(fieldSchema, 'format', this._getNumberFormat(rules));
+    }
+    _setStringFieldProperties(fieldSchema, fieldDefn) {
+        if (fieldSchema.type !== 'string' || fieldDefn.type !== 'string')
+            return;
+        if (fieldDefn.flags && fieldDefn.flags.encoding)
+            fieldSchema.contentEncoding = fieldDefn.flags.encoding;
+        const ruleArgFieldName = this.ruleArgFieldName;
+        let lower;
+        let upper;
+        const addPattern = (source, invert = false) => {
+            if (invert) {
+                this._addKeyword(fieldSchema, 'not', { pattern: source });
+            }
+            else {
+                this._addKeyword(fieldSchema, 'pattern', source);
+            }
+        };
+        _.each(fieldDefn.rules, (rule) => {
+            const args = (rule[ruleArgFieldName] || {});
+            const options = (args.options || {});
+            switch (rule.name) {
+                case 'min':
+                case 'max':
+                case 'length':
+                    //Lengths in bytes have no JSON Schema equivalent
+                    if (args.encoding) {
+                        this._inexact();
+                        break;
+                    }
+                    if (rule.name !== 'max')
+                        lower = this._bound(lower, args.limit, false, true);
+                    if (rule.name !== 'min')
+                        upper = this._bound(upper, args.limit, false, false);
+                    break;
+                case 'format':
+                    this._addKeyword(fieldSchema, 'format', args.name);
+                    break;
+                case 'email':
+                    this._addKeyword(fieldSchema, 'format', 'email');
+                    break;
+                case 'hostname':
+                    this._addKeyword(fieldSchema, 'format', 'hostname');
+                    break;
+                case 'uri':
+                    this._addKeyword(fieldSchema, 'format', options.allowRelative || options.relativeOnly ? 'uri-reference' : 'uri');
+                    //The formats accept every scheme, and absolute URIs
+                    if (options.scheme || options.relativeOnly)
+                        this._inexact();
+                    break;
+                case 'ip': {
+                    const versions = options.version || [];
+                    const formats = versions.length ? versions.filter((version) => version === 'ipv4' || version === 'ipv6') : ['ipv4', 'ipv6'];
+                    const alternatives = options.cidr === 'required' ? [] : formats.map((format) => ({ format }));
+                    //Addresses with a CIDR prefix have no format (and the other versions): a looser pattern accepts them
+                    if (options.cidr !== 'forbidden' || formats.length !== (versions.length || 2)) {
+                        this._inexact();
+                        alternatives.push({ pattern: '^[0-9a-zA-Z:.]+(?:/[0-9]{1,3})?$' });
+                    }
+                    if (alternatives.length === 1) {
+                        this._mergeKeywords(fieldSchema, alternatives[0]);
+                    }
+                    else {
+                        this._addKeyword(fieldSchema, 'anyOf', alternatives);
+                    }
+                    break;
+                }
+                case 'pattern': {
+                    const pattern = toPattern(args.regex);
+                    if (pattern) {
+                        addPattern(pattern.source, !!options.invert);
+                    }
+                    else {
+                        this._inexact();
+                    }
+                    break;
+                }
+                case 'alphanum':
+                    addPattern('^[a-zA-Z0-9]+$');
+                    break;
+                case 'token':
+                    addPattern('^[a-zA-Z0-9_]+$');
+                    break;
+                case 'hex':
+                    addPattern(options.prefix === 'optional' ? '^(?:0[xX])?[0-9a-fA-F]+$' : options.prefix === true ? '^0[xX][0-9a-fA-F]+$' : '^[0-9a-fA-F]+$');
+                    if (options.byteAligned)
+                        addPattern('^(?:[\\s\\S]{2})*$');
+                    break;
+                case 'trim':
+                    if (args.enabled !== false)
+                        addPattern('^(?:\\S(?:[\\s\\S]*\\S)?)?$');
+                    break;
+                case 'isoDate':
+                    this._addKeyword(fieldSchema, 'format', 'date-time');
+                    break;
+                case 'isoDuration':
+                    this._addKeyword(fieldSchema, 'format', 'duration');
+                    break;
+                case 'uuid':
+                case 'guid':
+                    this._addKeyword(fieldSchema, 'format', 'uuid');
+                    break;
+                default:
+                    break;
+            }
+        });
+        //A minimum length of zero only allows the empty string
+        if (lower && lower.value > 0)
+            fieldSchema.minLength = lower.value;
+        if (upper)
+            fieldSchema.maxLength = upper.value;
+    }
+    /**
+     * Sets the schema the items of an array contain
+     * @param schema
+     * @param contains
+     * @param options
+     */
+    _setContains(schema, contains, options) {
+        const min = options.min === undefined ? 1 : options.min;
+        //Draft 07 has no count of the matching items
+        if (min !== 1 || options.max !== undefined)
+            this._inexact();
+        if (min < 1)
+            return;
+        this._addKeyword(schema, 'contains', contains);
+    }
+    /**
+     * Sets the items of an array with ordered items
+     * @param schema
+     * @param ordered
+     * @param rest the schema of the other items (undefined: no other items)
+     */
+    _setTuple(schema, ordered, rest) {
+        schema.items = ordered;
+        schema.additionalItems = rest === undefined ? false : rest;
+    }
+    _setArrayFieldProperties(fieldSchema, fieldDefn, definitions, level) {
+        if (fieldSchema.type !== 'array')
+            return;
+        const ruleArgFieldName = this.ruleArgFieldName;
+        let lower;
+        let upper;
+        _.each(fieldDefn.rules, (rule) => {
+            const value = (rule[ruleArgFieldName] || {});
+            switch (rule.name) {
+                case 'max':
+                    upper = this._bound(upper, value.limit, false, false);
+                    break;
+                case 'min':
+                    lower = this._bound(lower, value.limit, false, true);
+                    break;
+                case 'length':
+                    lower = this._bound(lower, value.limit, false, true);
+                    upper = this._bound(upper, value.limit, false, false);
+                    break;
+                case 'unique':
+                    //A custom comparator may accept duplicates
+                    if (typeof value.comparator !== 'function') {
+                        fieldSchema.uniqueItems = true;
+                    }
+                    else {
+                        this._inexact();
+                    }
+                    break;
+                case 'has':
+                    this._setContains(fieldSchema, this.parse(value.schema, definitions, level + 1), (value.options || {}));
+                    break;
+                default:
+                    break;
+            }
+        });
+        if (lower)
+            fieldSchema.minItems = lower.value;
+        if (upper)
+            fieldSchema.maxItems = upper.value;
+        //The items which match no item schema may be stripped
+        if (this._stripsArrayItems(fieldDefn)) {
+            this._inexact();
+            fieldSchema.items = {};
+            return;
+        }
+        //Required item schemas require a matching item, forbidden ones forbid them
+        if (_.some([...(fieldDefn.items || []), ...(fieldDefn.ordered || [])], (item) => this._getPresence(item) !== undefined && this._getPresence(item) !== 'optional'))
+            this._inexact();
+        let rest;
+        if (fieldDefn.items && fieldDefn.items.length) {
+            if (fieldDefn.items.length === 1) {
+                rest = this.parse(fieldDefn.items[0], definitions, level + 1);
+            }
+            else {
+                rest = {
+                    anyOf: _.map(fieldDefn.items, (itemSchema) => {
+                        return this.parse(itemSchema, definitions, level + 1);
+                    })
+                };
+            }
+        }
+        const ordered = fieldDefn.ordered;
+        if (ordered && ordered.length) {
+            this._setTuple(fieldSchema, ordered.map((itemSchema) => this.parse(itemSchema, definitions, level + 1)), rest);
+        }
+        else {
+            fieldSchema.items = rest || {};
+        }
+    }
+    _setDateFieldProperties(fieldSchema, fieldDefn) {
+        if (fieldSchema.type !== 'date')
+            return;
+        const format = fieldDefn.flags && fieldDefn.flags.format;
+        if (format === 'javascript' || format === 'unix') {
+            //Timestamps (unix timestamps may have decimals)
+            fieldSchema.type = 'number';
+        }
+        else {
+            //https://datatracker.ietf.org/doc/draft-handrews-json-schema-validation
+            //JSON Schema does not have date type, but use string with format.
+            //However, the schema definition cannot clearly tells the date/time/date-time format
+            fieldSchema.type = 'string';
+            fieldSchema.format = 'date-time';
+        }
+    }
+    _setAlternativesProperties(schema, spec, definitions, level) {
+        if (schema.type !== 'alternatives')
+            return;
+        delete schema.type;
+        if (spec.matches.length === 0)
+            return;
+        const matches = spec.matches;
+        if (matches[0].schema) {
+            //try style
+            const mode = spec.flags && spec.flags.match;
+            const schemas = _.map(matches, (match) => {
+                return this.parse(match.schema, definitions, level + 1);
+            });
+            //Negating schemas which accept more values would reject values of the schema: they are dropped
+            const exact = schemas.every((converted) => this.isExact(converted));
+            if (mode === 'none') {
+                //None of the alternatives (lakutata)
+                if (exact)
+                    this._mergeKeywords(schema, { not: schemas.length === 1 ? schemas[0] : { anyOf: schemas } });
+            }
+            else if (schemas.length === 1) {
+                this._mergeKeywords(schema, schemas[0]);
+            }
+            else {
+                this._mergeKeywords(schema, { [mode === 'one' ? (exact ? 'oneOf' : 'anyOf') : mode === 'all' ? 'allOf' : 'anyOf']: schemas });
+            }
+        }
+        else {
+            this._setConditionProperties(schema, spec, definitions, level, 'matches', 'anyOf');
+        }
+    }
+    _setConditionProperties(schema, spec, definitions, level, conditionFieldName, logicKeyword = 'allOf') {
+        const conditions = spec[conditionFieldName];
+        if (!conditions || conditions.length === 0)
+            return;
+        //The conditions of whens are concatenated to the schema, which may replace its values and flags (not the ones of
+        //a schema without constraints)
+        if (conditionFieldName === 'whens' && (spec.type !== 'any' || spec.rules || spec.allow || spec.invalid))
+            this._inexact();
+        let ifThenStyle = this._isIfThenElseSupported();
+        const styleSetting = _.remove(spec.metas, (meta) => {
+            return typeof meta['if-style'] !== 'undefined';
+        });
+        if (ifThenStyle && styleSetting.length > 0 && styleSetting[0]['if-style'] === false)
+            ifThenStyle = false;
+        if (conditions.length > 1) {
+            //Multiple case
+            this._mergeKeywords(schema, {
+                [logicKeyword]: _.compact(_.map(conditions, (condition) => {
+                    return this._setConditionSchema(ifThenStyle, {}, condition, definitions, level + 1);
+                }))
+            });
+        }
+        else {
+            const part = this._setConditionSchema(ifThenStyle, {}, conditions[0], definitions, level + 1);
+            if (part)
+                this._mergeKeywords(schema, part);
+        }
+    }
+    _setConditionSchema(ifThenStyle, schema, conditionSpec, definitions, level) {
+        //When "if" is not present, both "then" and "else" MUST be entirely ignored.
+        //There must be either "is" or "switch"
+        if (!conditionSpec.is && !conditionSpec.switch)
+            return;
+        if (conditionSpec.switch) {
+            this._parseSwitchCondition(ifThenStyle, schema, conditionSpec, definitions, level);
+        }
+        else {
+            if (ifThenStyle) {
+                this._parseIfThenElseCondition(schema, conditionSpec, definitions, level);
+            }
+            else {
+                this._setConditionCompositionStyle(schema, conditionSpec, definitions, level);
+            }
+        }
+        return schema;
+    }
+    _parseIfThenElseCondition(schema, conditionSpec, definitions, level) {
+        //Currently, if there is reference, if-then-else style is not supported
+        //To use it, the condition must be defined in parent level using schema-style is
+        if (conditionSpec.ref)
+            return this._setConditionCompositionStyle(schema, conditionSpec, definitions, level);
+        const condition = this.parse(conditionSpec.is, definitions, level);
+        if (!this.isExact(condition))
+            return this._setBranches(schema, conditionSpec, definitions, level);
+        schema.if = condition;
+        if (conditionSpec.then)
+            schema.then = this.parse(conditionSpec.then, definitions, level);
+        if (conditionSpec.otherwise)
+            schema.else = this.parse(conditionSpec.otherwise, definitions, level);
+        return schema;
+    }
+    /**
+     * Sets the branches of a condition which cannot be converted: a value matches one of them (lakutata's own)
+     * @param schema
+     * @param conditionSpec
+     * @param definitions
+     * @param level
+     */
+    _setBranches(schema, conditionSpec, definitions, level) {
+        this._inexact();
+        //A missing branch accepts every value
+        if (!conditionSpec.then || !conditionSpec.otherwise)
+            return schema;
+        schema.anyOf = [this.parse(conditionSpec.then, definitions, level), this.parse(conditionSpec.otherwise, definitions, level)];
+        return schema;
+    }
+    _parseSwitchCondition(ifThenStyle, schema, condition, definitions, level) {
+        //Switch cannot be used if the condition is a schema
+        //Hence, condition.ref should always exists
+        if (condition.ref)
+            this._inexact();
+        const anyOf = [];
+        for (const switchCondition of condition.switch) {
+            if (ifThenStyle && !condition.ref) {
+                const innerSchema = this._parseIfThenElseCondition({}, switchCondition, definitions, level + 1);
+                anyOf.push(innerSchema);
+            }
+            else {
+                if (switchCondition.then)
+                    anyOf.push(this.parse(switchCondition.then, definitions, level + 1));
+                if (switchCondition.otherwise)
+                    anyOf.push(this.parse(switchCondition.otherwise, definitions, level + 1));
+            }
+        }
+        if (anyOf.length > 1) {
+            schema.anyOf = anyOf;
+        }
+        else {
+            //A single branch is merged (upstream merged an undeclared variable here, and threw)
+            _.merge(schema, anyOf[0]);
+        }
+    }
+    _setConditionCompositionStyle(schema, condition, definitions, level) {
+        if (condition.ref) {
+            //If the condition is refering to other field, cannot use the `is` condition for composition
+            //Simple choise between then / otherwise (anyOf: both may match, upstream uses oneOf)
+            this._inexact();
+            const anyOf = schema.anyOf || [];
+            if (condition.then)
+                anyOf.push(this.parse(condition.then, definitions, level + 1));
+            if (condition.otherwise)
+                anyOf.push(this.parse(condition.otherwise, definitions, level + 1));
+            if (anyOf.length > 1) {
+                schema.anyOf = anyOf;
+            }
+            else {
+                _.merge(schema, anyOf[0]);
+            }
+        }
+        else {
+            //Before Draft 7, you can express an “if-then” conditional using the Schema Composition keywords
+            //and a boolean algebra concept called “implication”.
+            //A -> B(pronounced, A implies B) means that if A is true, then B must also be true.
+            //It can be expressed as !A || B
+            //Variations of implication can express the same things you can express with the if/then/else keywords.
+            //if/then can be expressed as A -> B, if/else can be expressed as !A -> B,
+            //and if/then/else can be expressed as A -> B AND !A -> C
+            if (condition.is && !this.isExact(this.parse(condition.is, definitions, level + 1))) {
+                this._setBranches(schema, condition, definitions, level + 1);
+            }
+            else if (condition.is && condition.then && condition.otherwise) {
+                schema.allOf = [
+                    {
+                        anyOf: [
+                            {
+                                not: this.parse(condition.is, definitions, level + 1)
+                            },
+                            this.parse(condition.then, definitions, level + 1)
+                        ]
+                    },
+                    {
+                        anyOf: [
+                            this.parse(condition.is, definitions, level + 1),
+                            this.parse(condition.otherwise, definitions, level + 1)
+                        ]
+                    }
+                ];
+            }
+            else if (condition.is && condition.then) {
+                schema.anyOf = [
+                    {
+                        not: this.parse(condition.is, definitions, level + 1)
+                    },
+                    this.parse(condition.then, definitions, level + 1)
+                ];
+            }
+            else if (condition.is && condition.otherwise) {
+                schema.anyOf = [
+                    this.parse(condition.is, definitions, level + 1),
+                    this.parse(condition.otherwise, definitions, level + 1)
+                ];
+            }
+        }
+        return schema;
+    }
+    _setAnyProperties(schema) {
+        if (schema.type !== 'any')
+            return;
+        schema.type = [
+            'array',
+            'boolean',
+            'number',
+            'object',
+            'string',
+            'null'
+        ];
+    }
+    /**
+     * The schemas the value must also match (lakutata)
+     * @param schema
+     * @param spec
+     * @param definitions
+     * @param level
+     */
+    _setAllOf(schema, spec, definitions, level) {
+        for (const rule of spec.rules || []) {
+            if (rule.name !== 'allOf')
+                continue;
+            const schemas = _.get(rule, `${this.ruleArgFieldName}.schemas`);
+            this._mergeKeywords(schema, { allOf: schemas.map((subschema) => this.parse(subschema, definitions, level + 1)) });
+        }
+    }
+    /**
+     * No JSON value is a function or a symbol (lakutata)
+     * @param schema
+     * @param spec
+     */
+    _setNonJsonProperties(schema, spec) {
+        if (!NON_JSON_TYPES.includes(spec.type))
+            return;
+        this._addKeyword(schema, 'not', {});
+    }
+    _setMetaProperties(schema, spec) {
+        _.each(spec.metas, (m) => {
+            if (m.contentMediaType)
+                schema.contentMediaType = m.contentMediaType;
+            if (m.format)
+                schema.format = m.format;
+            if (m.title)
+                schema.title = m.title;
+        });
+    }
+    _setLinkFieldProperties(schema, spec) {
+        if (schema.type !== 'link')
+            return;
+        delete schema.type;
+        if (_.get(spec, 'link.ref.type') === 'local') {
+            schema.$ref = `${this._getLocalSchemaBasePath()}/${spec.link.ref.path.join('/')}`;
+        }
+    }
+    _copyMetasToSchema(spec, schema) {
+        if (!_.isEmpty(spec.metas)) {
+            _.each(spec.metas, (meta) => {
+                _.each(meta, (value, key) => {
+                    if (this._isKnownMetaKey(key))
+                        schema[key] = value;
+                });
+            });
+        }
+    }
+    /**
+     * Intended to be overridden by child parsers. By default no meta key will be is considered "known".
+     * @param _key
+     */
+    _isKnownMetaKey(_key) {
+        return false;
+    }
+}