@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/esm/lib/validation/engine/schema/types/keys.js

@@ -0,0 +1,873 @@
+/**
+ * Derived from the upstream lib/types/keys.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { applyToDefaults, clone as Clone } from '../../utils/index.js';
+import { assert, definition } from '../assert.js';
+import * as Sorting from '../../sorter/index.js';
+import * as Common from '../common.js';
+import * as Compile from '../compile.js';
+import * as Errors from '../errors.js';
+import * as Ref from '../ref.js';
+import { Template } from '../template.js';
+import Any from './any.js';
+const renameDefaults = {
+    //Keep old value in place
+    alias: false,
+    //Allow renaming multiple keys into the same target
+    multiple: false,
+    //Overrides an existing key
+    override: false
+};
+const KeysType = Any.extend({
+    type: '_keys',
+    properties: {
+        typeof: 'object'
+    },
+    flags: {
+        unknown: { default: undefined }
+    },
+    terms: {
+        dependencies: { init: null },
+        keys: { init: null, manifest: { mapped: { from: 'schema', to: 'key' } } },
+        patterns: { init: null },
+        renames: { init: null }
+    },
+    args(schema, keys) {
+        return schema.keys(keys);
+    },
+    validate(input, { schema, error, state, prefs }) {
+        if (!input ||
+            typeof input !== schema.$_property('typeof') ||
+            Array.isArray(input)) {
+            return { value: input, errors: error('object.base', { type: schema.$_property('typeof') }) };
+        }
+        //Skip if there are no other rules to test
+        if (!schema.$_terms.renames &&
+            !schema.$_terms.dependencies &&
+            //null allows any keys
+            !schema.$_terms.keys &&
+            !schema.$_terms.patterns &&
+            !schema.$_terms.externals &&
+            //A schema for the unknown keys
+            typeof schema._flags.unknown !== 'object') {
+            return;
+        }
+        //Shallow clone value
+        const value = clone(input, prefs);
+        const errors = [];
+        //Rename keys
+        if (schema.$_terms.renames &&
+            !rename(schema, value, state, prefs, errors)) {
+            return { value, errors };
+        }
+        //Anything allowed
+        if (!schema.$_terms.keys &&
+            //null allows any keys
+            !schema.$_terms.patterns &&
+            !schema.$_terms.dependencies &&
+            typeof schema._flags.unknown !== 'object') {
+            return { value, errors };
+        }
+        //Defined keys
+        const unprocessed = new Set(Object.keys(value));
+        if (schema.$_terms.keys) {
+            const ancestors = [value, ...state.ancestors];
+            for (const child of schema.$_terms.keys) {
+                const key = child.key;
+                const item = value[key];
+                unprocessed.delete(key);
+                const localState = state.localize([...state.path, key], ancestors, child);
+                const result = child.schema.$_validate(item, localState, prefs);
+                if (result.errors) {
+                    if (prefs.abortEarly)
+                        return { value, errors: result.errors };
+                    if (result.value !== undefined)
+                        value[key] = result.value;
+                    errors.push(...result.errors);
+                }
+                else if (child.schema._flags.result === 'strip' ||
+                    result.value === undefined && item !== undefined) {
+                    delete value[key];
+                }
+                else if (result.value !== undefined) {
+                    value[key] = result.value;
+                }
+            }
+        }
+        //Unknown keys
+        if (unprocessed.size ||
+            schema._flags._hasPatternMatch) {
+            const early = unknown(schema, value, unprocessed, errors, state, prefs);
+            if (early)
+                return early;
+        }
+        //Validate dependencies
+        if (schema.$_terms.dependencies) {
+            for (const dep of schema.$_terms.dependencies) {
+                if (dep.key !== null &&
+                    isPresent(dep.options)(dep.key.resolve(value, state, prefs, null, { shadow: false })) === false) {
+                    continue;
+                }
+                const failed = dependencies[dep.rel](schema, dep, value, state, prefs);
+                if (failed) {
+                    const report = schema.$_createError(failed.code, value, failed.context, state, prefs);
+                    if (prefs.abortEarly)
+                        return { value, errors: report };
+                    errors.push(report);
+                }
+            }
+        }
+        return { value, errors };
+    },
+    rules: {
+        and: {
+            method(...peers) {
+                Common.verifyFlat(peers, 'and');
+                return dependency(this, 'and', null, peers);
+            }
+        },
+        append: {
+            method(schema) {
+                if (schema === null ||
+                    schema === undefined ||
+                    Object.keys(schema).length === 0) {
+                    return this;
+                }
+                return this.keys(schema);
+            }
+        },
+        assert: {
+            method(subject, schema, message) {
+                if (!Template.isTemplate(subject))
+                    subject = Compile.ref(subject);
+                assert(message === undefined || typeof message === 'string', 'Message must be a string');
+                schema = this.$_compile(schema, { appendPath: true });
+                const obj = this.$_addRule({ name: 'assert', args: { subject, schema, message } });
+                obj.$_mutateRegister(subject);
+                obj.$_mutateRegister(schema);
+                return obj;
+            },
+            validate(value, { error, prefs, state }, { subject, schema, message }) {
+                const about = subject.resolve(value, state, prefs);
+                const path = Ref.isRef(subject) ? subject.absolute(state) : [];
+                if (schema.$_match(about, state.localize(path, [value, ...state.ancestors], schema), prefs))
+                    return value;
+                return error('object.assert', { subject, message });
+            },
+            args: ['subject', 'schema', 'message'],
+            multi: true
+        },
+        instance: {
+            method(constructor, name) {
+                assert(typeof constructor === 'function', 'constructor must be a function');
+                name = name || constructor.name;
+                return this.$_addRule({ name: 'instance', args: { constructor, name } });
+            },
+            validate(value, helpers, { constructor, name }) {
+                if (value instanceof constructor)
+                    return value;
+                return helpers.error('object.instance', { type: name, value });
+            },
+            args: ['constructor', 'name']
+        },
+        keyNames: {
+            method(schema) {
+                //lakutata's own: every key name must match the schema
+                schema = this.$_compile(schema);
+                const obj = this.$_addRule({ name: 'keyNames', args: { schema } });
+                obj.$_mutateRegister(schema);
+                return obj;
+            },
+            validate(value, { state, prefs, error }, { schema }) {
+                const names = schema;
+                const ancestors = [value, ...state.ancestors];
+                for (const name of Object.keys(value)) {
+                    const localState = state.localize([...state.path, name], ancestors, names);
+                    if (!names.$_match(name, localState, prefs))
+                        return error('object.keyNames', { name });
+                }
+                return value;
+            },
+            args: ['schema']
+        },
+        keys: {
+            method(schema) {
+                assert(schema === undefined || typeof schema === 'object', 'Object schema must be a valid object');
+                assert(!Common.isSchema(schema), 'Object schema cannot be a schema object');
+                const obj = this.clone();
+                if (!schema) {
+                    //Allow all
+                    obj.$_terms.keys = null;
+                }
+                else if (!Object.keys(schema).length) {
+                    //Allow none
+                    obj.$_terms.keys = new Keys();
+                }
+                else {
+                    obj.$_terms.keys = obj.$_terms.keys ? obj.$_terms.keys.filter((child) => !Object.hasOwn(schema, child.key)) : new Keys();
+                    for (const key in schema) {
+                        Common.tryWithPath(() => obj.$_terms.keys.push({ key, schema: this.$_compile(schema[key]) }), key);
+                    }
+                }
+                return obj.$_mutateRebuild();
+            }
+        },
+        length: {
+            method(limit) {
+                return this.$_addRule({ name: 'length', args: { limit }, operator: '=' });
+            },
+            validate(value, helpers, { limit }, { name, operator, args }) {
+                if (Common.compare(Object.keys(value).length, limit, operator))
+                    return value;
+                return helpers.error('object.' + name, { limit: args.limit, value });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: Common.limit,
+                    message: 'must be a positive integer'
+                }
+            ]
+        },
+        max: {
+            method(limit) {
+                return this.$_addRule({ name: 'max', method: 'length', args: { limit }, operator: '<=' });
+            }
+        },
+        min: {
+            method(limit) {
+                return this.$_addRule({ name: 'min', method: 'length', args: { limit }, operator: '>=' });
+            }
+        },
+        nand: {
+            method(...peers) {
+                Common.verifyFlat(peers, 'nand');
+                return dependency(this, 'nand', null, peers);
+            }
+        },
+        or: {
+            method(...peers) {
+                Common.verifyFlat(peers, 'or');
+                return dependency(this, 'or', null, peers);
+            }
+        },
+        oxor: {
+            method(...peers) {
+                return dependency(this, 'oxor', null, peers);
+            }
+        },
+        pattern: {
+            method(pattern, schema, options = {}) {
+                const isRegExp = pattern instanceof RegExp;
+                if (!isRegExp)
+                    pattern = this.$_compile(pattern, { appendPath: true });
+                assert(schema !== undefined, 'Invalid rule');
+                Common.assertOptions(options, ['fallthrough', 'matches']);
+                if (isRegExp)
+                    assert(!pattern.flags.includes('g') && !pattern.flags.includes('y'), 'pattern should not use global or sticky mode');
+                schema = this.$_compile(schema, { appendPath: true });
+                const obj = this.clone();
+                obj.$_terms.patterns = obj.$_terms.patterns || [];
+                const config = { [isRegExp ? 'regex' : 'schema']: pattern, rule: schema };
+                if (options.matches) {
+                    config.matches = this.$_compile(options.matches);
+                    if (config.matches.type !== 'array')
+                        config.matches = config.matches.$_root.array().items(config.matches);
+                    obj.$_mutateRegister(config.matches);
+                    obj.$_setFlag('_hasPatternMatch', true, { clone: false });
+                }
+                if (options.fallthrough)
+                    config.fallthrough = true;
+                obj.$_terms.patterns.push(config);
+                obj.$_mutateRegister(schema);
+                return obj;
+            }
+        },
+        ref: {
+            method() {
+                return this.$_addRule('ref');
+            },
+            validate(value, helpers) {
+                if (Ref.isRef(value))
+                    return value;
+                return helpers.error('object.refType', { value });
+            }
+        },
+        regex: {
+            method() {
+                return this.$_addRule('regex');
+            },
+            validate(value, helpers) {
+                if (value instanceof RegExp)
+                    return value;
+                return helpers.error('object.regex', { value });
+            }
+        },
+        rename: {
+            method(from, to, options = {}) {
+                assert(typeof from === 'string' || from instanceof RegExp, 'Rename missing the from argument');
+                assert(typeof to === 'string' || to instanceof Template, 'Invalid rename to argument');
+                assert(to !== from, 'Cannot rename key to same name:', from);
+                Common.assertOptions(options, ['alias', 'ignoreUndefined', 'override', 'multiple']);
+                const obj = this.clone();
+                obj.$_terms.renames = obj.$_terms.renames || [];
+                for (const rename of obj.$_terms.renames)
+                    assert(rename.from !== from, 'Cannot rename the same key multiple times');
+                if (to instanceof Template)
+                    obj.$_mutateRegister(to);
+                obj.$_terms.renames.push({
+                    from,
+                    to,
+                    options: applyToDefaults(renameDefaults, options)
+                });
+                return obj;
+            }
+        },
+        schema: {
+            method(type = 'any') {
+                return this.$_addRule({ name: 'schema', args: { type } });
+            },
+            validate(value, helpers, { type }) {
+                if (Common.isSchema(value) &&
+                    (type === 'any' || value.type === type)) {
+                    return value;
+                }
+                return helpers.error('object.schema', { type });
+            }
+        },
+        unknown: {
+            method(allow) {
+                if (allow === undefined || allow === null || typeof allow === 'boolean')
+                    return this.$_setFlag('unknown', allow !== false);
+                //lakutata's own: the unknown keys are allowed and must match the schema
+                const obj = this.clone();
+                const schema = obj.$_compile(allow);
+                obj.$_mutateRegister(schema);
+                return obj.$_setFlag('unknown', schema, { clone: false });
+            }
+        },
+        with: {
+            method(key, peers, options = {}) {
+                return dependency(this, 'with', key, peers, options);
+            }
+        },
+        without: {
+            method(key, peers, options = {}) {
+                return dependency(this, 'without', key, peers, options);
+            }
+        },
+        xor: {
+            method(...peers) {
+                Common.verifyFlat(peers, 'xor');
+                return dependency(this, 'xor', null, peers);
+            }
+        }
+    },
+    overrides: {
+        default(value, options) {
+            if (value === undefined)
+                value = Common.symbols.deepDefault;
+            return this.$_parent('default', value, options);
+        },
+        isAsync() {
+            if (this.$_terms.externals?.length)
+                return true;
+            if (typeof this._flags.unknown === 'object' && this._flags.unknown.isAsync())
+                return true;
+            if (this.$_terms.keys?.length) {
+                for (const key of this.$_terms.keys) {
+                    if (key.schema.isAsync())
+                        return true;
+                }
+            }
+            if (this.$_terms.patterns?.length) {
+                for (const pattern of this.$_terms.patterns) {
+                    if (pattern.rule.isAsync())
+                        return true;
+                }
+            }
+            return false;
+        }
+    },
+    rebuild(schema) {
+        if (schema.$_terms.keys) {
+            const sorter = new Sorting.Sorter();
+            for (const child of schema.$_terms.keys) {
+                Common.tryWithPath(() => definition(() => sorter.add(child, { after: child.schema.$_rootReferences(), group: child.key })), child.key);
+            }
+            schema.$_terms.keys = new Keys(...sorter.nodes);
+        }
+    },
+    manifest: {
+        build(obj, desc) {
+            if (desc.keys)
+                obj = obj.keys(desc.keys);
+            if (desc.dependencies) {
+                for (const { rel, key = null, peers, options } of desc.dependencies)
+                    obj = dependency(obj, rel, key, peers, options);
+            }
+            if (desc.patterns) {
+                for (const { regex, schema, rule, fallthrough, matches } of desc.patterns)
+                    obj = obj.pattern(regex || schema, rule, { fallthrough, matches });
+            }
+            if (desc.renames) {
+                for (const { from, to, options } of desc.renames)
+                    obj = obj.rename(from, to, options);
+            }
+            return obj;
+        }
+    },
+    messages: {
+        'object.and': '{{#label}} contains {{#presentWithLabels}} without its required peers {{#missingWithLabels}}',
+        'object.assert': '{{#label}} is invalid because {if(#subject.key, `"` + #subject.key + `" failed to ` + (#message || "pass the assertion test"), #message || "the assertion failed")}',
+        'object.base': '{{#label}} must be of type {{#type}}',
+        'object.instance': '{{#label}} must be an instance of {{:#type}}',
+        'object.keyNames': '{{#label}} has a key name "{{#name}}" which is not allowed',
+        'object.length': '{{#label}} must have {{#limit}} key{if(#limit == 1, "", "s")}',
+        'object.max': '{{#label}} must have less than or equal to {{#limit}} key{if(#limit == 1, "", "s")}',
+        'object.min': '{{#label}} must have at least {{#limit}} key{if(#limit == 1, "", "s")}',
+        'object.missing': '{{#label}} must contain at least one of {{#peersWithLabels}}',
+        'object.nand': '{{:#mainWithLabel}} must not exist simultaneously with {{#peersWithLabels}}',
+        'object.oxor': '{{#label}} contains a conflict between optional exclusive peers {{#peersWithLabels}}',
+        'object.pattern.match': '{{#label}} keys failed to match pattern requirements',
+        'object.refType': '{{#label}} must be a reference',
+        'object.regex': '{{#label}} must be a RegExp object',
+        'object.rename.multiple': '{{#label}} cannot rename {{:#from}} because multiple renames are disabled and another key was already renamed to {{:#to}}',
+        'object.rename.override': '{{#label}} cannot rename {{:#from}} because override is disabled and target {{:#to}} exists',
+        'object.schema': '{{#label}} must be a schema of {{#type}} type',
+        'object.unknown': '{{#label}} is not allowed',
+        'object.with': '{{:#mainWithLabel}} missing required peer {{:#peerWithLabel}}',
+        'object.without': '{{:#mainWithLabel}} conflict with forbidden peer {{:#peerWithLabel}}',
+        'object.xor': '{{#label}} contains a conflict between exclusive peers {{#peersWithLabels}}'
+    }
+});
+export default KeysType;
+//Helpers
+/**
+ * Shallow clone the validated object or function
+ * @param value
+ * @param prefs
+ */
+function clone(value, prefs) {
+    //Object
+    if (typeof value === 'object') {
+        if (prefs.nonEnumerables)
+            return Clone(value, { shallow: true });
+        const clone = Object.create(Object.getPrototypeOf(value));
+        Object.assign(clone, value);
+        return clone;
+    }
+    //Function
+    const fn = value;
+    const clone = function (...args) {
+        return fn.apply(this, args);
+    };
+    clone.prototype = Clone(fn.prototype);
+    Object.defineProperty(clone, 'name', { value: fn.name, writable: false });
+    Object.defineProperty(clone, 'length', { value: fn.length, writable: false });
+    Object.assign(clone, value);
+    return clone;
+}
+/**
+ * Add a dependency between keys
+ * @param schema
+ * @param rel
+ * @param key
+ * @param peers
+ * @param options
+ */
+function dependency(schema, rel, key, peers, options) {
+    assert(key === null || typeof key === 'string', rel, 'key must be a strings');
+    //Extract options from peers array
+    if (!options)
+        options = peers.length > 1 && typeof peers[peers.length - 1] === 'object' ? peers.pop() : {};
+    Common.assertOptions(options, ['separator', 'isPresent']);
+    peers = [].concat(peers);
+    //Cast peer paths
+    const separator = Common.defaultValue(options.separator, '.');
+    const paths = [];
+    for (const peer of peers) {
+        assert(typeof peer === 'string', rel, 'peers must be strings');
+        paths.push(Compile.ref(peer, { separator, ancestor: 0, prefix: false }));
+    }
+    //Cast key
+    if (key !== null)
+        key = Compile.ref(key, { separator, ancestor: 0, prefix: false });
+    //Add rule
+    const obj = schema.clone();
+    obj.$_terms.dependencies = obj.$_terms.dependencies || [];
+    obj.$_terms.dependencies.push(new Dependency(rel, key, paths, peers, options));
+    return obj;
+}
+const dependencies = {
+    and(schema, dep, value, state, prefs) {
+        const missing = [];
+        const present = [];
+        const count = dep.peers.length;
+        const isPresentFn = isPresent(dep.options);
+        for (const peer of dep.peers) {
+            if (isPresentFn(peer.resolve(value, state, prefs, null, { shadow: false })) === false) {
+                missing.push(peer.key);
+            }
+            else {
+                present.push(peer.key);
+            }
+        }
+        if (missing.length !== count &&
+            present.length !== count) {
+            return {
+                code: 'object.and',
+                context: {
+                    present,
+                    presentWithLabels: keysToLabels(schema, present),
+                    missing,
+                    missingWithLabels: keysToLabels(schema, missing)
+                }
+            };
+        }
+    },
+    nand(schema, dep, value, state, prefs) {
+        const present = [];
+        const isPresentFn = isPresent(dep.options);
+        for (const peer of dep.peers) {
+            if (isPresentFn(peer.resolve(value, state, prefs, null, { shadow: false })))
+                present.push(peer.key);
+        }
+        if (present.length !== dep.peers.length)
+            return;
+        const main = dep.paths[0];
+        const values = dep.paths.slice(1);
+        return {
+            code: 'object.nand',
+            context: {
+                main,
+                mainWithLabel: keysToLabels(schema, main),
+                peers: values,
+                peersWithLabels: keysToLabels(schema, values)
+            }
+        };
+    },
+    or(schema, dep, value, state, prefs) {
+        const isPresentFn = isPresent(dep.options);
+        for (const peer of dep.peers) {
+            if (isPresentFn(peer.resolve(value, state, prefs, null, { shadow: false })))
+                return;
+        }
+        return {
+            code: 'object.missing',
+            context: {
+                peers: dep.paths,
+                peersWithLabels: keysToLabels(schema, dep.paths)
+            }
+        };
+    },
+    oxor(schema, dep, value, state, prefs) {
+        const present = [];
+        const isPresentFn = isPresent(dep.options);
+        for (const peer of dep.peers) {
+            if (isPresentFn(peer.resolve(value, state, prefs, null, { shadow: false })))
+                present.push(peer.key);
+        }
+        if (!present.length ||
+            present.length === 1) {
+            return;
+        }
+        const context = { peers: dep.paths, peersWithLabels: keysToLabels(schema, dep.paths) };
+        context.present = present;
+        context.presentWithLabels = keysToLabels(schema, present);
+        return { code: 'object.oxor', context };
+    },
+    with(schema, dep, value, state, prefs) {
+        const isPresentFn = isPresent(dep.options);
+        for (const peer of dep.peers) {
+            if (isPresentFn(peer.resolve(value, state, prefs, null, { shadow: false })) === false) {
+                return {
+                    code: 'object.with',
+                    context: {
+                        main: dep.key.key,
+                        mainWithLabel: keysToLabels(schema, dep.key.key),
+                        peer: peer.key,
+                        peerWithLabel: keysToLabels(schema, peer.key)
+                    }
+                };
+            }
+        }
+    },
+    without(schema, dep, value, state, prefs) {
+        const isPresentFn = isPresent(dep.options);
+        for (const peer of dep.peers) {
+            if (isPresentFn(peer.resolve(value, state, prefs, null, { shadow: false }))) {
+                return {
+                    code: 'object.without',
+                    context: {
+                        main: dep.key.key,
+                        mainWithLabel: keysToLabels(schema, dep.key.key),
+                        peer: peer.key,
+                        peerWithLabel: keysToLabels(schema, peer.key)
+                    }
+                };
+            }
+        }
+    },
+    xor(schema, dep, value, state, prefs) {
+        const present = [];
+        const isPresentFn = isPresent(dep.options);
+        for (const peer of dep.peers) {
+            if (isPresentFn(peer.resolve(value, state, prefs, null, { shadow: false })))
+                present.push(peer.key);
+        }
+        if (present.length === 1)
+            return;
+        const context = { peers: dep.paths, peersWithLabels: keysToLabels(schema, dep.paths) };
+        if (present.length === 0)
+            return { code: 'object.missing', context };
+        context.present = present;
+        context.presentWithLabels = keysToLabels(schema, present);
+        return { code: 'object.xor', context };
+    }
+};
+/**
+ * The labels of keys (a key, or an array of keys)
+ * @param schema
+ * @param keys
+ */
+function keysToLabels(schema, keys) {
+    if (Array.isArray(keys))
+        return keys.map((key) => schema.$_mapLabels(key));
+    return schema.$_mapLabels(keys);
+}
+/**
+ * The presence check of a dependency
+ * @param options
+ */
+function isPresent(options) {
+    return typeof options.isPresent === 'function' ? options.isPresent : (resolved) => resolved !== undefined;
+}
+/**
+ * Rename the keys of the (cloned) value, returning false to abort early
+ * @param schema
+ * @param value
+ * @param state
+ * @param prefs
+ * @param errors
+ */
+function rename(schema, value, state, prefs, errors) {
+    const renamed = {};
+    for (const rename of schema.$_terms.renames) {
+        const matches = [];
+        const pattern = typeof rename.from !== 'string';
+        if (!pattern) {
+            if (Object.prototype.hasOwnProperty.call(value, rename.from) &&
+                (value[rename.from] !== undefined || !rename.options.ignoreUndefined)) {
+                matches.push(rename);
+            }
+        }
+        else {
+            for (const from in value) {
+                if (value[from] === undefined &&
+                    rename.options.ignoreUndefined) {
+                    continue;
+                }
+                if (from === rename.to)
+                    continue;
+                const match = rename.from.exec(from);
+                if (!match)
+                    continue;
+                matches.push({ from, to: rename.to, match });
+            }
+        }
+        for (const match of matches) {
+            const from = match.from;
+            let to = match.to;
+            if (to instanceof Template)
+                to = to.render(value, state, prefs, match.match);
+            if (from === to)
+                continue;
+            if (!rename.options.multiple &&
+                renamed[to]) {
+                errors.push(schema.$_createError('object.rename.multiple', value, { from, to, pattern }, state, prefs));
+                if (prefs.abortEarly)
+                    return false;
+            }
+            if (Object.prototype.hasOwnProperty.call(value, to) &&
+                !rename.options.override &&
+                !renamed[to]) {
+                errors.push(schema.$_createError('object.rename.override', value, { from, to, pattern }, state, prefs));
+                if (prefs.abortEarly)
+                    return false;
+            }
+            if (value[from] === undefined) {
+                delete value[to];
+            }
+            else {
+                value[to] = value[from];
+            }
+            renamed[to] = true;
+            if (!rename.options.alias)
+                delete value[from];
+        }
+    }
+    return true;
+}
+/**
+ * Validate the unprocessed keys against the patterns, then strip or forbid the unknown keys
+ * @param schema
+ * @param value
+ * @param unprocessed
+ * @param errors
+ * @param state
+ * @param prefs
+ */
+function unknown(schema, value, unprocessed, errors, state, prefs) {
+    if (schema.$_terms.patterns) {
+        let hasMatches = false;
+        const matches = schema.$_terms.patterns.map((pattern) => {
+            if (pattern.matches) {
+                hasMatches = true;
+                return [];
+            }
+        });
+        const ancestors = [value, ...state.ancestors];
+        for (const key of unprocessed) {
+            const item = value[key];
+            const path = [...state.path, key];
+            for (let i = 0; i < schema.$_terms.patterns.length; ++i) {
+                const pattern = schema.$_terms.patterns[i];
+                if (pattern.regex) {
+                    const match = pattern.regex.test(key);
+                    state.mainstay.tracer.debug(state, 'rule', `pattern.${i}`, match ? 'pass' : 'error');
+                    if (!match)
+                        continue;
+                }
+                else {
+                    if (!pattern.schema.$_match(key, state.nest(pattern.schema, `pattern.${i}`), prefs))
+                        continue;
+                }
+                unprocessed.delete(key);
+                const localState = state.localize(path, ancestors, { schema: pattern.rule, key });
+                const result = pattern.rule.$_validate(item, localState, prefs);
+                if (result.errors) {
+                    if (prefs.abortEarly)
+                        return { value, errors: result.errors };
+                    errors.push(...result.errors);
+                }
+                if (pattern.matches)
+                    matches[i].push(key);
+                value[key] = result.value;
+                if (!pattern.fallthrough)
+                    break;
+            }
+        }
+        //Validate pattern matches rules
+        if (hasMatches) {
+            for (let i = 0; i < matches.length; ++i) {
+                const match = matches[i];
+                if (!match)
+                    continue;
+                const stpm = schema.$_terms.patterns[i].matches;
+                const localState = state.localize(state.path, ancestors, stpm);
+                const result = stpm.$_validate(match, localState, prefs);
+                if (result.errors) {
+                    const details = Errors.details(result.errors, { override: false });
+                    details.matches = match;
+                    const report = schema.$_createError('object.pattern.match', value, details, state, prefs);
+                    if (prefs.abortEarly)
+                        return { value, errors: report };
+                    errors.push(report);
+                }
+            }
+        }
+    }
+    //A schema for the unknown keys (lakutata's own)
+    const unknownSchema = schema._flags.unknown;
+    if (typeof unknownSchema === 'object') {
+        const ancestors = [value, ...state.ancestors];
+        for (const key of unprocessed) {
+            const localState = state.localize([...state.path, key], ancestors, { schema: unknownSchema, key });
+            const result = unknownSchema.$_validate(value[key], localState, prefs);
+            if (result.errors) {
+                if (prefs.abortEarly)
+                    return { value, errors: result.errors };
+                errors.push(...result.errors);
+            }
+            value[key] = result.value;
+        }
+        return;
+    }
+    //If no keys or patterns specified, unknown keys allowed
+    if (!unprocessed.size ||
+        !schema.$_terms.keys && !schema.$_terms.patterns) {
+        return;
+    }
+    if (prefs.stripUnknown && typeof schema._flags.unknown === 'undefined' ||
+        prefs.skipFunctions) {
+        const stripUnknown = prefs.stripUnknown ? (prefs.stripUnknown === true ? true : !!prefs.stripUnknown.objects) : false;
+        for (const key of unprocessed) {
+            if (stripUnknown) {
+                delete value[key];
+                unprocessed.delete(key);
+            }
+            else if (typeof value[key] === 'function') {
+                unprocessed.delete(key);
+            }
+        }
+    }
+    const forbidUnknown = !Common.defaultValue(schema._flags.unknown, prefs.allowUnknown);
+    if (forbidUnknown) {
+        for (const unprocessedKey of unprocessed) {
+            const localState = state.localize([...state.path, unprocessedKey], []);
+            const report = schema.$_createError('object.unknown', value[unprocessedKey], { child: unprocessedKey }, localState, prefs, { flags: false });
+            if (prefs.abortEarly)
+                return { value, errors: report };
+            errors.push(report);
+        }
+    }
+}
+/**
+ * An item of the dependencies term
+ */
+class Dependency {
+    constructor(rel, key, peers, paths, options) {
+        this.rel = rel;
+        this.key = key;
+        this.peers = peers;
+        this.paths = paths;
+        this.options = options;
+    }
+    describe() {
+        const desc = {
+            rel: this.rel,
+            peers: this.paths
+        };
+        if (this.key !== null)
+            desc.key = this.key.key;
+        if (this.peers[0].separator !== '.')
+            desc.options = { ...desc.options, separator: this.peers[0].separator };
+        if (this.options.isPresent)
+            desc.options = { ...desc.options, isPresent: this.options.isPresent };
+        return desc;
+    }
+}
+/**
+ * The keys term: an array of children which concatenates by key
+ */
+class Keys extends Array {
+    concat(source) {
+        const result = this.slice();
+        const keys = new Map();
+        for (let i = 0; i < result.length; ++i)
+            keys.set(result[i].key, i);
+        for (const item of source) {
+            const key = item.key;
+            const pos = keys.get(key);
+            if (pos !== undefined) {
+                result[pos] = { key, schema: result[pos].schema.concat(item.schema) };
+            }
+            else {
+                result.push(item);
+            }
+        }
+        return result;
+    }
+}