@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/esm/lib/validation/engine/schema/base.js

@@ -0,0 +1,797 @@
+/**
+ * Derived from the upstream lib/base.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { clone, deepEqual, merge } from '../utils/index.js';
+import { assert } from './assert.js';
+import { SchemaValidationException } from '../../exceptions/SchemaValidationException.js';
+import * as Cache from './cache.js';
+import * as Common from './common.js';
+import * as Compile from './compile.js';
+import * as Errors from './errors.js';
+import * as Extend from './extend.js';
+import * as Manifest from './manifest.js';
+import * as Messages from './messages.js';
+import * as Modify from './modify.js';
+import * as Ref from './ref.js';
+import * as Trace from './trace.js';
+import * as Validator from './validator.js';
+import { Values } from './values.js';
+/**
+ * The preferences of $_match() by parent preferences (lakutata: upstream makes a new copy on each call)
+ */
+const matchPreferencesCache = new WeakMap();
+/**
+ * The parent preferences, aborting early and without external rules (preferences are never mutated)
+ * @param prefs
+ */
+function matchPreferences(prefs) {
+    let matched = matchPreferencesCache.get(prefs);
+    if (!matched) {
+        //Shallow cloned
+        matched = Object.assign({}, prefs);
+        matched.abortEarly = true;
+        matched._externals = false;
+        matchPreferencesCache.set(prefs, matched);
+    }
+    return matched;
+}
+/**
+ * The base schema: rules, flags, terms and validation shared by all the types
+ */
+export class Base {
+    constructor(type) {
+        this.type = type;
+        this.$_root = null;
+        this._definition = {};
+        this._reset();
+    }
+    _reset() {
+        this._ids = new Modify.Ids();
+        this._preferences = null;
+        this._refs = new Ref.Manager();
+        this._cache = null;
+        this._valids = null;
+        this._invalids = null;
+        this._flags = {};
+        this._rules = [];
+        this._singleRules = new Map();
+        this.$_terms = {};
+        this.$_temp = {
+            ruleset: null,
+            whens: {}
+        };
+    }
+    //Manifest
+    describe() {
+        assert(typeof Manifest.describe === 'function', 'Manifest functionality disabled');
+        return Manifest.describe(this);
+    }
+    //Rules
+    allow(...values) {
+        Common.verifyFlat(values, 'allow');
+        return this._values(values, '_valids');
+    }
+    alter(targets) {
+        assert(targets && typeof targets === 'object' && !Array.isArray(targets), 'Invalid targets argument');
+        assert(!this._inRuleset(), 'Cannot set alterations inside a ruleset');
+        const obj = this.clone();
+        obj.$_terms.alterations = obj.$_terms.alterations || [];
+        for (const target in targets) {
+            const adjuster = targets[target];
+            assert(typeof adjuster === 'function', 'Alteration adjuster for', target, 'must be a function');
+            obj.$_terms.alterations.push({ target, adjuster });
+        }
+        obj.$_temp.ruleset = false;
+        return obj;
+    }
+    artifact(id) {
+        assert(id !== undefined, 'Artifact cannot be undefined');
+        assert(!this._cache, 'Cannot set an artifact with a rule cache');
+        return this.$_setFlag('artifact', id);
+    }
+    cast(to) {
+        assert(to === false || typeof to === 'string', 'Invalid to value');
+        assert(to === false || this._definition.cast[to], 'Type', this.type, 'does not support casting to', to);
+        return this.$_setFlag('cast', to === false ? undefined : to);
+    }
+    default(value, options) {
+        return this._default('default', value, options);
+    }
+    description(desc) {
+        assert(desc && typeof desc === 'string', 'Description must be a non-empty string');
+        return this.$_setFlag('description', desc);
+    }
+    empty(schema) {
+        const obj = this.clone();
+        if (schema !== undefined)
+            schema = obj.$_compile(schema, { override: false });
+        return obj.$_setFlag('empty', schema, { clone: false });
+    }
+    error(err) {
+        assert(err, 'Missing error');
+        assert(err instanceof Error || typeof err === 'function', 'Must provide a valid Error object or a function');
+        return this.$_setFlag('error', err);
+    }
+    example(example, options = {}) {
+        assert(example !== undefined, 'Missing example');
+        Common.assertOptions(options, ['override']);
+        return this._inner('examples', example, { single: true, override: options.override });
+    }
+    external(method, description) {
+        if (typeof method === 'object') {
+            assert(!description, 'Cannot combine options with description');
+            description = method.description;
+            method = method.method;
+        }
+        assert(typeof method === 'function', 'Method must be a function');
+        assert(description === undefined || description && typeof description === 'string', 'Description must be a non-empty string');
+        return this._inner('externals', { method, description }, { single: true });
+    }
+    failover(value, options) {
+        return this._default('failover', value, options);
+    }
+    forbidden() {
+        return this.presence('forbidden');
+    }
+    id(id) {
+        if (!id)
+            return this.$_setFlag('id', undefined);
+        assert(typeof id === 'string', 'id must be a non-empty string');
+        assert(/^[^\.]+$/.test(id), 'id cannot contain period character');
+        return this.$_setFlag('id', id);
+    }
+    invalid(...values) {
+        return this._values(values, '_invalids');
+    }
+    label(name) {
+        assert(name && typeof name === 'string', 'Label name must be a non-empty string');
+        return this.$_setFlag('label', name);
+    }
+    meta(meta) {
+        assert(meta !== undefined, 'Meta cannot be undefined');
+        return this._inner('metas', meta, { single: true });
+    }
+    note(...notes) {
+        assert(notes.length, 'Missing notes');
+        for (const note of notes)
+            assert(note && typeof note === 'string', 'Notes must be non-empty strings');
+        return this._inner('notes', notes);
+    }
+    only(mode = true) {
+        assert(typeof mode === 'boolean', 'Invalid mode:', mode);
+        return this.$_setFlag('only', mode);
+    }
+    optional() {
+        return this.presence('optional');
+    }
+    prefs(prefs) {
+        assert(prefs, 'Missing preferences');
+        assert(prefs.context === undefined, 'Cannot override context');
+        assert(prefs.externals === undefined, 'Cannot override externals');
+        assert(prefs.warnings === undefined, 'Cannot override warnings');
+        assert(prefs.debug === undefined, 'Cannot override debug');
+        Common.checkPreferences(prefs);
+        const obj = this.clone();
+        obj._preferences = Common.preferences(obj._preferences, prefs);
+        return obj;
+    }
+    presence(mode) {
+        assert(['optional', 'required', 'forbidden'].includes(mode), 'Unknown presence mode', mode);
+        return this.$_setFlag('presence', mode);
+    }
+    raw(enabled = true) {
+        return this.$_setFlag('result', enabled ? 'raw' : undefined);
+    }
+    result(mode) {
+        assert(['raw', 'strip'].includes(mode), 'Unknown result mode', mode);
+        return this.$_setFlag('result', mode);
+    }
+    required() {
+        return this.presence('required');
+    }
+    strict(enabled) {
+        const obj = this.clone();
+        const convert = enabled === undefined ? false : !enabled;
+        obj._preferences = Common.preferences(obj._preferences, { convert });
+        return obj;
+    }
+    strip(enabled = true) {
+        return this.$_setFlag('result', enabled ? 'strip' : undefined);
+    }
+    tag(...tags) {
+        assert(tags.length, 'Missing tags');
+        for (const tag of tags)
+            assert(tag && typeof tag === 'string', 'Tags must be non-empty strings');
+        return this._inner('tags', tags);
+    }
+    unit(name) {
+        assert(name && typeof name === 'string', 'Unit name must be a non-empty string');
+        return this.$_setFlag('unit', name);
+    }
+    valid(...values) {
+        Common.verifyFlat(values, 'valid');
+        const obj = this.allow(...values);
+        obj.$_setFlag('only', !!obj._valids, { clone: false });
+        return obj;
+    }
+    when(condition, options) {
+        const obj = this.clone();
+        if (!obj.$_terms.whens)
+            obj.$_terms.whens = [];
+        const when = Compile.when(obj, condition, options);
+        if (!['any', 'link'].includes(obj.type)) {
+            const conditions = when.is ? [when] : when.switch;
+            for (const item of conditions) {
+                assert(!item.then || item.then.type === 'any' || item.then.type === obj.type, 'Cannot combine', obj.type, 'with', item.then && item.then.type);
+                assert(!item.otherwise || item.otherwise.type === 'any' || item.otherwise.type === obj.type, 'Cannot combine', obj.type, 'with', item.otherwise && item.otherwise.type);
+            }
+        }
+        obj.$_terms.whens.push(when);
+        return obj.$_mutateRebuild();
+    }
+    //Helpers
+    cache(cache) {
+        assert(!this._inRuleset(), 'Cannot set caching inside a ruleset');
+        assert(!this._cache, 'Cannot override schema cache');
+        assert(this._flags.artifact === undefined, 'Cannot cache a rule with an artifact');
+        const obj = this.clone();
+        obj._cache = cache || Cache.provider.provision();
+        obj.$_temp.ruleset = false;
+        return obj;
+    }
+    clone() {
+        const obj = Object.create(Object.getPrototypeOf(this));
+        return this._assign(obj);
+    }
+    concat(source) {
+        assert(Common.isSchema(source), 'Invalid schema object');
+        assert(this.type === 'any' || source.type === 'any' || source.type === this.type, 'Cannot merge type', this.type, 'with another type:', source.type);
+        assert(!this._inRuleset(), 'Cannot concatenate onto a schema with open ruleset');
+        assert(!source._inRuleset(), 'Cannot concatenate a schema with open ruleset');
+        let obj = this.clone();
+        if (this.type === 'any' && source.type !== 'any') {
+            //Change obj to match source type
+            const tmpObj = source.clone();
+            for (const key of Object.keys(obj)) {
+                if (key !== 'type')
+                    tmpObj[key] = obj[key];
+            }
+            obj = tmpObj;
+        }
+        obj._ids.concat(source._ids);
+        obj._refs.register(source, Ref.toSibling);
+        obj._preferences = obj._preferences ? Common.preferences(obj._preferences, source._preferences) : source._preferences;
+        obj._valids = Values.merge(obj._valids, source._valids, source._invalids);
+        obj._invalids = Values.merge(obj._invalids, source._invalids, source._valids);
+        //Remove unique rules present in source
+        for (const name of source._singleRules.keys()) {
+            if (obj._singleRules.has(name)) {
+                obj._rules = obj._rules.filter((target) => target.keep || target.name !== name);
+                obj._singleRules.delete(name);
+            }
+        }
+        //Rules
+        for (const test of source._rules) {
+            if (!source._definition.rules[test.method].multi)
+                obj._singleRules.set(test.name, test);
+            obj._rules.push(test);
+        }
+        //Flags
+        if (obj._flags.empty && source._flags.empty) {
+            obj._flags.empty = obj._flags.empty.concat(source._flags.empty);
+            const flags = Object.assign({}, source._flags);
+            delete flags.empty;
+            merge(obj._flags, flags);
+        }
+        else if (source._flags.empty) {
+            obj._flags.empty = source._flags.empty;
+            const flags = Object.assign({}, source._flags);
+            delete flags.empty;
+            merge(obj._flags, flags);
+        }
+        else {
+            merge(obj._flags, source._flags);
+        }
+        //Terms
+        for (const key in source.$_terms) {
+            const terms = source.$_terms[key];
+            if (!terms) {
+                if (!obj.$_terms[key])
+                    obj.$_terms[key] = terms;
+                continue;
+            }
+            if (!obj.$_terms[key]) {
+                obj.$_terms[key] = terms.slice();
+                continue;
+            }
+            obj.$_terms[key] = obj.$_terms[key].concat(terms);
+        }
+        //Tracing
+        if (this.$_root._tracer)
+            this.$_root._tracer._combine(obj, [this, source]);
+        //Rebuild
+        return obj.$_mutateRebuild();
+    }
+    /**
+     * A new type extending the type of this schema
+     * @param options the type definition, where S is the schema type of the new type
+     */
+    extend(options) {
+        assert(!options.base, 'Cannot extend type with another base');
+        return Extend.type(this, options);
+    }
+    extract(path) {
+        path = Array.isArray(path) ? path : path.split('.');
+        return this._ids.reach(path);
+    }
+    fork(paths, adjuster) {
+        assert(!this._inRuleset(), 'Cannot fork inside a ruleset');
+        let obj = this;
+        for (let path of [].concat(paths)) {
+            path = Array.isArray(path) ? path : path.split('.');
+            obj = obj._ids.fork(path, adjuster, obj);
+        }
+        obj.$_temp.ruleset = false;
+        return obj;
+    }
+    isAsync() {
+        if (this.$_terms.externals?.length)
+            return true;
+        if (this.$_terms.whens) {
+            for (const when of this.$_terms.whens) {
+                if (when.then?.isAsync())
+                    return true;
+                if (when.otherwise?.isAsync())
+                    return true;
+                if (when.switch) {
+                    for (const item of when.switch) {
+                        if (item.then?.isAsync())
+                            return true;
+                        if (item.otherwise?.isAsync())
+                            return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    rule(options) {
+        const def = this._definition;
+        Common.assertOptions(options, Object.keys(def.modifiers));
+        assert(this.$_temp.ruleset !== false, 'Cannot apply rules to empty ruleset or the last rule added does not support rule properties');
+        const start = this.$_temp.ruleset === null ? this._rules.length - 1 : this.$_temp.ruleset;
+        assert(start >= 0 && start < this._rules.length, 'Cannot apply rules to empty ruleset');
+        const obj = this.clone();
+        for (let i = start; i < obj._rules.length; ++i) {
+            const original = obj._rules[i];
+            const rule = clone(original);
+            for (const name in options) {
+                def.modifiers[name](rule, options[name]);
+                assert(rule.name === original.name, 'Cannot change rule name');
+            }
+            obj._rules[i] = rule;
+            if (obj._singleRules.get(rule.name) === original)
+                obj._singleRules.set(rule.name, rule);
+        }
+        obj.$_temp.ruleset = false;
+        return obj.$_mutateRebuild();
+    }
+    get ruleset() {
+        assert(!this._inRuleset(), 'Cannot start a new ruleset without closing the previous one');
+        const obj = this.clone();
+        obj.$_temp.ruleset = obj._rules.length;
+        return obj;
+    }
+    get $() {
+        return this.ruleset;
+    }
+    tailor(targets) {
+        targets = [].concat(targets);
+        assert(!this._inRuleset(), 'Cannot tailor inside a ruleset');
+        let obj = this;
+        if (this.$_terms.alterations) {
+            for (const { target, adjuster } of this.$_terms.alterations) {
+                if (targets.includes(target)) {
+                    obj = adjuster(obj);
+                    assert(Common.isSchema(obj), 'Alteration adjuster for', target, 'failed to return a schema object');
+                }
+            }
+        }
+        obj = obj.$_modify({ each: (item) => item.tailor(targets), ref: false });
+        obj.$_temp.ruleset = false;
+        return obj.$_mutateRebuild();
+    }
+    tracer() {
+        return Trace.location ? Trace.location(this) : this;
+    }
+    validate(value, options) {
+        return Validator.entry(value, this, options);
+    }
+    validateAsync(value, options) {
+        return Validator.entryAsync(value, this, options);
+    }
+    //Extensions
+    $_addRule(options) {
+        //Normalize rule
+        if (typeof options === 'string')
+            options = { name: options };
+        assert(options && typeof options === 'object', 'Invalid options');
+        assert(options.name && typeof options.name === 'string', 'Invalid rule name');
+        for (const key in options)
+            assert(key[0] !== '_', 'Cannot set private rule properties');
+        //Shallow cloned
+        const rule = Object.assign({}, options);
+        rule._resolve = [];
+        rule.method = rule.method || rule.name;
+        const definition = this._definition.rules[rule.method];
+        const args = rule.args;
+        assert(definition, 'Unknown rule', rule.method);
+        //Args
+        const obj = this.clone();
+        if (args) {
+            assert(Object.keys(args).length === 1 || Object.keys(args).length === this._definition.rules[rule.name].args.length, 'Invalid rule definition for', this.type, rule.name);
+            for (const key in args) {
+                let arg = args[key];
+                if (definition.argsByName) {
+                    const resolver = definition.argsByName.get(key);
+                    if (resolver.ref && Common.isResolvable(arg)) {
+                        rule._resolve.push(key);
+                        obj.$_mutateRegister(arg);
+                    }
+                    else {
+                        if (resolver.normalize) {
+                            arg = resolver.normalize(arg);
+                            args[key] = arg;
+                        }
+                        if (resolver.assert) {
+                            const error = Common.validateArg(arg, key, resolver);
+                            assert(!error, error, 'or reference');
+                        }
+                    }
+                }
+                if (arg === undefined) {
+                    delete args[key];
+                    continue;
+                }
+                args[key] = arg;
+            }
+        }
+        //Unique rules
+        if (!definition.multi) {
+            obj._ruleRemove(rule.name, { clone: false });
+            obj._singleRules.set(rule.name, rule);
+        }
+        if (obj.$_temp.ruleset === false)
+            obj.$_temp.ruleset = null;
+        if (definition.priority) {
+            obj._rules.unshift(rule);
+        }
+        else {
+            obj._rules.push(rule);
+        }
+        return obj;
+    }
+    $_compile(schema, options) {
+        return Compile.schema(this.$_root, schema, options);
+    }
+    $_createError(code, value, local, state, prefs, options = {}) {
+        const flags = options.flags !== false ? this._flags : {};
+        const messages = options.messages ? Messages.merge(this._definition.messages, options.messages) : this._definition.messages;
+        return new Errors.Report(code, value, local, flags, messages, state, prefs);
+    }
+    $_getFlag(name) {
+        return this._flags[name];
+    }
+    $_getRule(name) {
+        return this._singleRules.get(name);
+    }
+    $_mapLabels(path) {
+        path = Array.isArray(path) ? path : path.split('.');
+        return this._ids.labels(path);
+    }
+    $_match(value, state, prefs, overrides) {
+        prefs = matchPreferences(prefs);
+        state.snapshot();
+        const result = !Validator.validate(value, this, state, prefs, overrides).errors;
+        state.restore();
+        return result;
+    }
+    $_modify(options) {
+        Common.assertOptions(options, ['each', 'once', 'ref', 'schema']);
+        return Modify.schema(this, options) || this;
+    }
+    $_mutateRebuild() {
+        assert(!this._inRuleset(), 'Cannot add this rule inside a ruleset');
+        this._refs.reset();
+        this._ids.reset();
+        const each = (item, { source, name, key }) => {
+            const definitions = this._definition[source];
+            const family = definitions[name] && definitions[name].register;
+            if (family !== false)
+                this.$_mutateRegister(item, { family, key });
+        };
+        this.$_modify({ each });
+        if (this._definition.rebuild)
+            this._definition.rebuild(this);
+        this.$_temp.ruleset = false;
+        return this;
+    }
+    $_mutateRegister(schema, { family, key } = {}) {
+        this._refs.register(schema, family);
+        this._ids.register(schema, { key: key || undefined });
+    }
+    $_property(name) {
+        return this._definition.properties[name];
+    }
+    $_reach(path) {
+        return this._ids.reach(path);
+    }
+    $_rootReferences() {
+        return this._refs.roots();
+    }
+    $_setFlag(name, value, options = {}) {
+        assert(name[0] === '_' || !this._inRuleset(), 'Cannot set flag inside a ruleset');
+        const flag = this._definition.flags[name] || {};
+        if (deepEqual(value, flag.default))
+            value = undefined;
+        if (deepEqual(value, this._flags[name]))
+            return this;
+        const obj = options.clone !== false ? this.clone() : this;
+        if (value !== undefined) {
+            obj._flags[name] = value;
+            obj.$_mutateRegister(value);
+        }
+        else {
+            delete obj._flags[name];
+        }
+        if (name[0] !== '_')
+            obj.$_temp.ruleset = false;
+        return obj;
+    }
+    $_parent(method, ...args) {
+        const overridden = this[method];
+        return overridden[Common.symbols.parent].call(this, ...args);
+    }
+    $_validate(value, state, prefs) {
+        return Validator.validate(value, this, state, prefs);
+    }
+    //Internals
+    _assign(target) {
+        const assigned = target;
+        assigned.type = this.type;
+        assigned.$_root = this.$_root;
+        assigned.$_temp = Object.assign({}, this.$_temp);
+        assigned.$_temp.whens = {};
+        assigned._ids = this._ids.clone();
+        assigned._preferences = this._preferences;
+        assigned._valids = this._valids && this._valids.clone();
+        assigned._invalids = this._invalids && this._invalids.clone();
+        assigned._rules = this._rules.slice();
+        assigned._singleRules = clone(this._singleRules, { shallow: true });
+        assigned._refs = this._refs.clone();
+        assigned._flags = Object.assign({}, this._flags);
+        assigned._cache = null;
+        assigned.$_terms = {};
+        for (const key in this.$_terms)
+            assigned.$_terms[key] = this.$_terms[key] ? this.$_terms[key].slice() : null;
+        //Backwards compatibility
+        assigned.$_super = {};
+        for (const override in this.$_super)
+            assigned.$_super[override] = this._super[override].bind(assigned);
+        return target;
+    }
+    _bare() {
+        const obj = this.clone();
+        obj._reset();
+        const terms = obj._definition.terms;
+        for (const name in terms) {
+            const term = terms[name];
+            obj.$_terms[name] = term.init;
+        }
+        return obj.$_mutateRebuild();
+    }
+    _default(flag, value, options = {}) {
+        Common.assertOptions(options, 'literal');
+        assert(value !== undefined, 'Missing', flag, 'value');
+        assert(typeof value === 'function' || !options.literal, 'Only function value supports literal option');
+        if (typeof value === 'function' && options.literal) {
+            value = {
+                [Common.symbols.literal]: true,
+                literal: value
+            };
+        }
+        const obj = this.$_setFlag(flag, value);
+        return obj;
+    }
+    _generate(value, state, prefs) {
+        if (!this.$_terms.whens)
+            return { schema: this };
+        //Collect matching whens
+        const whens = [];
+        const ids = [];
+        const terms = this.$_terms.whens;
+        for (let i = 0; i < terms.length; ++i) {
+            const when = terms[i];
+            if (when.concat) {
+                whens.push(when.concat);
+                ids.push(`${i}.concat`);
+                continue;
+            }
+            const input = when.ref ? when.ref.resolve(value, state, prefs, undefined) : value;
+            const tests = when.is ? [when] : when.switch;
+            const before = ids.length;
+            for (let j = 0; j < tests.length; ++j) {
+                const { is, then, otherwise } = tests[j];
+                const baseId = `${i}${when.switch ? '.' + j : ''}`;
+                if (is.$_match(input, state.nest(is, `${baseId}.is`), prefs)) {
+                    if (then) {
+                        const localState = state.localize([...state.path, `${baseId}.then`], state.ancestors, state.schemas);
+                        const { schema: generated, id } = then._generate(value, localState, prefs);
+                        whens.push(generated);
+                        ids.push(`${baseId}.then${id ? `(${id})` : ''}`);
+                        break;
+                    }
+                }
+                else if (otherwise) {
+                    const localState = state.localize([...state.path, `${baseId}.otherwise`], state.ancestors, state.schemas);
+                    const { schema: generated, id } = otherwise._generate(value, localState, prefs);
+                    whens.push(generated);
+                    ids.push(`${baseId}.otherwise${id ? `(${id})` : ''}`);
+                    break;
+                }
+            }
+            //Something matched
+            if (when.break && ids.length > before)
+                break;
+        }
+        //Check cache
+        const id = ids.join(', ');
+        state.mainstay.tracer.debug(state, 'rule', 'when', id);
+        if (!id)
+            return { schema: this };
+        if (!state.mainstay.tracer.active && this.$_temp.whens[id])
+            return { schema: this.$_temp.whens[id], id };
+        //Generate dynamic schema
+        let obj = this;
+        if (this._definition.generate)
+            obj = this._definition.generate(this, value, state, prefs);
+        //Apply whens
+        for (const when of whens)
+            obj = obj.concat(when);
+        //Tracing
+        if (this.$_root._tracer)
+            this.$_root._tracer._combine(obj, [this, ...whens]);
+        //Cache result
+        this.$_temp.whens[id] = obj;
+        return { schema: obj, id };
+    }
+    _inner(type, values, options = {}) {
+        assert(!this._inRuleset(), `Cannot set ${type} inside a ruleset`);
+        const obj = this.clone();
+        if (!obj.$_terms[type] || options.override)
+            obj.$_terms[type] = [];
+        const term = obj.$_terms[type];
+        if (options.single) {
+            term.push(values);
+        }
+        else {
+            term.push(...values);
+        }
+        obj.$_temp.ruleset = false;
+        return obj;
+    }
+    _inRuleset() {
+        return this.$_temp.ruleset !== null && this.$_temp.ruleset !== false;
+    }
+    _ruleRemove(name, options = {}) {
+        if (!this._singleRules.has(name))
+            return this;
+        const obj = options.clone !== false ? this.clone() : this;
+        obj._singleRules.delete(name);
+        const filtered = [];
+        for (let i = 0; i < obj._rules.length; ++i) {
+            const test = obj._rules[i];
+            if (test.name === name && !test.keep) {
+                if (obj._inRuleset() && i < obj.$_temp.ruleset)
+                    --obj.$_temp.ruleset;
+                continue;
+            }
+            filtered.push(test);
+        }
+        obj._rules = filtered;
+        return obj;
+    }
+    _values(values, key) {
+        Common.verifyFlat(values, key.slice(1, -1));
+        const obj = this.clone();
+        const override = values[0] === Common.symbols.override;
+        if (override)
+            values = values.slice(1);
+        if (!obj[key] && values.length) {
+            obj[key] = new Values();
+        }
+        else if (override) {
+            obj[key] = values.length ? new Values() : null;
+            obj.$_mutateRebuild();
+        }
+        if (!obj[key])
+            return obj;
+        const set = obj[key];
+        if (override)
+            set.override();
+        for (const value of values) {
+            assert(value !== undefined, 'Cannot call allow/valid/invalid with undefined');
+            assert(value !== Common.symbols.override, 'Override must be the first value');
+            const other = key === '_invalids' ? '_valids' : '_invalids';
+            const otherSet = obj[other];
+            if (otherSet) {
+                otherSet.remove(value);
+                if (!otherSet.length) {
+                    assert(key === '_valids' || !obj._flags.only, 'Setting invalid value', value, 'leaves schema rejecting all values due to previous valid rule');
+                    obj[other] = null;
+                }
+            }
+            set.add(value, obj._refs);
+        }
+        return obj;
+    }
+    //Standard Schema
+    get '~standard'() {
+        const mapToStandardError = (error) => {
+            let issues;
+            if (SchemaValidationException.isError(error)) {
+                issues = error.details.map(({ message, path }) => ({
+                    message,
+                    path
+                }));
+            }
+            else {
+                issues = [{
+                        message: error.message
+                    }];
+            }
+            return {
+                issues
+            };
+        };
+        const mapToStandardValue = (value) => ({ value });
+        return {
+            version: 1,
+            vendor: 'lakutata',
+            validate: (value) => {
+                const result = Validator.standard(value, this);
+                if (result instanceof Promise)
+                    return result.then(mapToStandardValue, mapToStandardError);
+                if (!result.error)
+                    return mapToStandardValue(result.value);
+                return mapToStandardError(result.error);
+            }
+        };
+    }
+}
+Object.defineProperty(Base.prototype, Common.symbols.any, {
+    value: {
+        version: Common.version,
+        compile: Compile.compile,
+        root: '$_root'
+    },
+    writable: true,
+    enumerable: true,
+    configurable: true
+});
+//Prevents clone() from deep cloning schema objects (must be on prototype)
+Object.defineProperty(Base.prototype, 'isImmutable', { value: true, writable: true, enumerable: true, configurable: true });
+//Aliases
+for (const [alias, method] of [
+    ['deny', 'invalid'],
+    ['disallow', 'invalid'],
+    ['equal', 'valid'],
+    ['exist', 'required'],
+    ['not', 'invalid'],
+    ['options', 'prefs'],
+    ['preferences', 'prefs']
+]) {
+    Object.defineProperty(Base.prototype, alias, { value: Base.prototype[method], writable: true, enumerable: true, configurable: true });
+}
+const base = new Base();
+export default base;