@nocobase/plugin-flow-engine 2.1.0-alpha.13 → 2.1.0-alpha.14

package/dist/node_modules/ajv/dist/compile/codegen/scope.d.ts

@@ -1,79 +0,0 @@
-import { Code, Name } from "./code";
-interface NameGroup {
-    prefix: string;
-    index: number;
-}
-export interface NameValue {
-    ref: ValueReference;
-    key?: unknown;
-    code?: Code;
-}
-export type ValueReference = unknown;
-interface ScopeOptions {
-    prefixes?: Set<string>;
-    parent?: Scope;
-}
-interface ValueScopeOptions extends ScopeOptions {
-    scope: ScopeStore;
-    es5?: boolean;
-    lines?: boolean;
-}
-export type ScopeStore = Record<string, ValueReference[] | undefined>;
-type ScopeValues = {
-    [Prefix in string]?: Map<unknown, ValueScopeName>;
-};
-export type ScopeValueSets = {
-    [Prefix in string]?: Set<ValueScopeName>;
-};
-export declare enum UsedValueState {
-    Started = 0,
-    Completed = 1
-}
-export type UsedScopeValues = {
-    [Prefix in string]?: Map<ValueScopeName, UsedValueState | undefined>;
-};
-export declare const varKinds: {
-    const: Name;
-    let: Name;
-    var: Name;
-};
-export declare class Scope {
-    protected readonly _names: {
-        [Prefix in string]?: NameGroup;
-    };
-    protected readonly _prefixes?: Set<string>;
-    protected readonly _parent?: Scope;
-    constructor({ prefixes, parent }?: ScopeOptions);
-    toName(nameOrPrefix: Name | string): Name;
-    name(prefix: string): Name;
-    protected _newName(prefix: string): string;
-    private _nameGroup;
-}
-interface ScopePath {
-    property: string;
-    itemIndex: number;
-}
-export declare class ValueScopeName extends Name {
-    readonly prefix: string;
-    value?: NameValue;
-    scopePath?: Code;
-    constructor(prefix: string, nameStr: string);
-    setValue(value: NameValue, { property, itemIndex }: ScopePath): void;
-}
-interface VSOptions extends ValueScopeOptions {
-    _n: Code;
-}
-export declare class ValueScope extends Scope {
-    protected readonly _values: ScopeValues;
-    protected readonly _scope: ScopeStore;
-    readonly opts: VSOptions;
-    constructor(opts: ValueScopeOptions);
-    get(): ScopeStore;
-    name(prefix: string): ValueScopeName;
-    value(nameOrPrefix: ValueScopeName | string, value: NameValue): ValueScopeName;
-    getValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined;
-    scopeRefs(scopeName: Name, values?: ScopeValues | ScopeValueSets): Code;
-    scopeCode(values?: ScopeValues | ScopeValueSets, usedValues?: UsedScopeValues, getCode?: (n: ValueScopeName) => Code | undefined): Code;
-    private _reduceValues;
-}
-export {};

package/dist/node_modules/ajv/dist/compile/codegen/scope.js

@@ -1,143 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
-const code_1 = require("./code");
-class ValueError extends Error {
-    constructor(name) {
-        super(`CodeGen: "code" for ${name} not defined`);
-        this.value = name.value;
-    }
-}
-var UsedValueState;
-(function (UsedValueState) {
-    UsedValueState[UsedValueState["Started"] = 0] = "Started";
-    UsedValueState[UsedValueState["Completed"] = 1] = "Completed";
-})(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
-exports.varKinds = {
-    const: new code_1.Name("const"),
-    let: new code_1.Name("let"),
-    var: new code_1.Name("var"),
-};
-class Scope {
-    constructor({ prefixes, parent } = {}) {
-        this._names = {};
-        this._prefixes = prefixes;
-        this._parent = parent;
-    }
-    toName(nameOrPrefix) {
-        return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
-    }
-    name(prefix) {
-        return new code_1.Name(this._newName(prefix));
-    }
-    _newName(prefix) {
-        const ng = this._names[prefix] || this._nameGroup(prefix);
-        return `${prefix}${ng.index++}`;
-    }
-    _nameGroup(prefix) {
-        var _a, _b;
-        if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || (this._prefixes && !this._prefixes.has(prefix))) {
-            throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
-        }
-        return (this._names[prefix] = { prefix, index: 0 });
-    }
-}
-exports.Scope = Scope;
-class ValueScopeName extends code_1.Name {
-    constructor(prefix, nameStr) {
-        super(nameStr);
-        this.prefix = prefix;
-    }
-    setValue(value, { property, itemIndex }) {
-        this.value = value;
-        this.scopePath = (0, code_1._) `.${new code_1.Name(property)}[${itemIndex}]`;
-    }
-}
-exports.ValueScopeName = ValueScopeName;
-const line = (0, code_1._) `\n`;
-class ValueScope extends Scope {
-    constructor(opts) {
-        super(opts);
-        this._values = {};
-        this._scope = opts.scope;
-        this.opts = { ...opts, _n: opts.lines ? line : code_1.nil };
-    }
-    get() {
-        return this._scope;
-    }
-    name(prefix) {
-        return new ValueScopeName(prefix, this._newName(prefix));
-    }
-    value(nameOrPrefix, value) {
-        var _a;
-        if (value.ref === undefined)
-            throw new Error("CodeGen: ref must be passed in value");
-        const name = this.toName(nameOrPrefix);
-        const { prefix } = name;
-        const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
-        let vs = this._values[prefix];
-        if (vs) {
-            const _name = vs.get(valueKey);
-            if (_name)
-                return _name;
-        }
-        else {
-            vs = this._values[prefix] = new Map();
-        }
-        vs.set(valueKey, name);
-        const s = this._scope[prefix] || (this._scope[prefix] = []);
-        const itemIndex = s.length;
-        s[itemIndex] = value.ref;
-        name.setValue(value, { property: prefix, itemIndex });
-        return name;
-    }
-    getValue(prefix, keyOrRef) {
-        const vs = this._values[prefix];
-        if (!vs)
-            return;
-        return vs.get(keyOrRef);
-    }
-    scopeRefs(scopeName, values = this._values) {
-        return this._reduceValues(values, (name) => {
-            if (name.scopePath === undefined)
-                throw new Error(`CodeGen: name "${name}" has no value`);
-            return (0, code_1._) `${scopeName}${name.scopePath}`;
-        });
-    }
-    scopeCode(values = this._values, usedValues, getCode) {
-        return this._reduceValues(values, (name) => {
-            if (name.value === undefined)
-                throw new Error(`CodeGen: name "${name}" has no value`);
-            return name.value.code;
-        }, usedValues, getCode);
-    }
-    _reduceValues(values, valueCode, usedValues = {}, getCode) {
-        let code = code_1.nil;
-        for (const prefix in values) {
-            const vs = values[prefix];
-            if (!vs)
-                continue;
-            const nameSet = (usedValues[prefix] = usedValues[prefix] || new Map());
-            vs.forEach((name) => {
-                if (nameSet.has(name))
-                    return;
-                nameSet.set(name, UsedValueState.Started);
-                let c = valueCode(name);
-                if (c) {
-                    const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;
-                    code = (0, code_1._) `${code}${def} ${name} = ${c};${this.opts._n}`;
-                }
-                else if ((c = getCode === null || getCode === void 0 ? void 0 : getCode(name))) {
-                    code = (0, code_1._) `${code}${c}${this.opts._n}`;
-                }
-                else {
-                    throw new ValueError(name);
-                }
-                nameSet.set(name, UsedValueState.Completed);
-            });
-        }
-        return code;
-    }
-}
-exports.ValueScope = ValueScope;
-//# sourceMappingURL=scope.js.map

package/dist/node_modules/ajv/dist/compile/errors.d.ts

@@ -1,13 +0,0 @@
-import type { KeywordErrorCxt, KeywordErrorDefinition } from "../types";
-import { CodeGen, Code, Name } from "./codegen";
-export declare const keywordError: KeywordErrorDefinition;
-export declare const keyword$DataError: KeywordErrorDefinition;
-export interface ErrorPaths {
-    instancePath?: Code;
-    schemaPath?: string;
-    parentSchema?: boolean;
-}
-export declare function reportError(cxt: KeywordErrorCxt, error?: KeywordErrorDefinition, errorPaths?: ErrorPaths, overrideAllErrors?: boolean): void;
-export declare function reportExtraError(cxt: KeywordErrorCxt, error?: KeywordErrorDefinition, errorPaths?: ErrorPaths): void;
-export declare function resetErrorsCount(gen: CodeGen, errsCount: Name): void;
-export declare function extendErrors({ gen, keyword, schemaValue, data, errsCount, it, }: KeywordErrorCxt): void;

package/dist/node_modules/ajv/dist/compile/errors.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;
-const codegen_1 = require("./codegen");
-const util_1 = require("./util");
-const names_1 = require("./names");
-exports.keywordError = {
-    message: ({ keyword }) => (0, codegen_1.str) `must pass "${keyword}" keyword validation`,
-};
-exports.keyword$DataError = {
-    message: ({ keyword, schemaType }) => schemaType
-        ? (0, codegen_1.str) `"${keyword}" keyword must be ${schemaType} ($data)`
-        : (0, codegen_1.str) `"${keyword}" keyword is invalid ($data)`,
-};
-function reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) {
-    const { it } = cxt;
-    const { gen, compositeRule, allErrors } = it;
-    const errObj = errorObjectCode(cxt, error, errorPaths);
-    if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : (compositeRule || allErrors)) {
-        addError(gen, errObj);
-    }
-    else {
-        returnErrors(it, (0, codegen_1._) `[${errObj}]`);
-    }
-}
-exports.reportError = reportError;
-function reportExtraError(cxt, error = exports.keywordError, errorPaths) {
-    const { it } = cxt;
-    const { gen, compositeRule, allErrors } = it;
-    const errObj = errorObjectCode(cxt, error, errorPaths);
-    addError(gen, errObj);
-    if (!(compositeRule || allErrors)) {
-        returnErrors(it, names_1.default.vErrors);
-    }
-}
-exports.reportExtraError = reportExtraError;
-function resetErrorsCount(gen, errsCount) {
-    gen.assign(names_1.default.errors, errsCount);
-    gen.if((0, codegen_1._) `${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._) `${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null)));
-}
-exports.resetErrorsCount = resetErrorsCount;
-function extendErrors({ gen, keyword, schemaValue, data, errsCount, it, }) {
-    /* istanbul ignore if */
-    if (errsCount === undefined)
-        throw new Error("ajv implementation error");
-    const err = gen.name("err");
-    gen.forRange("i", errsCount, names_1.default.errors, (i) => {
-        gen.const(err, (0, codegen_1._) `${names_1.default.vErrors}[${i}]`);
-        gen.if((0, codegen_1._) `${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._) `${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
-        gen.assign((0, codegen_1._) `${err}.schemaPath`, (0, codegen_1.str) `${it.errSchemaPath}/${keyword}`);
-        if (it.opts.verbose) {
-            gen.assign((0, codegen_1._) `${err}.schema`, schemaValue);
-            gen.assign((0, codegen_1._) `${err}.data`, data);
-        }
-    });
-}
-exports.extendErrors = extendErrors;
-function addError(gen, errObj) {
-    const err = gen.const("err", errObj);
-    gen.if((0, codegen_1._) `${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._) `[${err}]`), (0, codegen_1._) `${names_1.default.vErrors}.push(${err})`);
-    gen.code((0, codegen_1._) `${names_1.default.errors}++`);
-}
-function returnErrors(it, errs) {
-    const { gen, validateName, schemaEnv } = it;
-    if (schemaEnv.$async) {
-        gen.throw((0, codegen_1._) `new ${it.ValidationError}(${errs})`);
-    }
-    else {
-        gen.assign((0, codegen_1._) `${validateName}.errors`, errs);
-        gen.return(false);
-    }
-}
-const E = {
-    keyword: new codegen_1.Name("keyword"),
-    schemaPath: new codegen_1.Name("schemaPath"), // also used in JTD errors
-    params: new codegen_1.Name("params"),
-    propertyName: new codegen_1.Name("propertyName"),
-    message: new codegen_1.Name("message"),
-    schema: new codegen_1.Name("schema"),
-    parentSchema: new codegen_1.Name("parentSchema"),
-};
-function errorObjectCode(cxt, error, errorPaths) {
-    const { createErrors } = cxt.it;
-    if (createErrors === false)
-        return (0, codegen_1._) `{}`;
-    return errorObject(cxt, error, errorPaths);
-}
-function errorObject(cxt, error, errorPaths = {}) {
-    const { gen, it } = cxt;
-    const keyValues = [
-        errorInstancePath(it, errorPaths),
-        errorSchemaPath(cxt, errorPaths),
-    ];
-    extraErrorProps(cxt, error, keyValues);
-    return gen.object(...keyValues);
-}
-function errorInstancePath({ errorPath }, { instancePath }) {
-    const instPath = instancePath
-        ? (0, codegen_1.str) `${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}`
-        : errorPath;
-    return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)];
-}
-function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
-    let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str) `${errSchemaPath}/${keyword}`;
-    if (schemaPath) {
-        schPath = (0, codegen_1.str) `${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
-    }
-    return [E.schemaPath, schPath];
-}
-function extraErrorProps(cxt, { params, message }, keyValues) {
-    const { keyword, data, schemaValue, it } = cxt;
-    const { opts, propertyName, topSchemaRef, schemaPath } = it;
-    keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._) `{}`]);
-    if (opts.messages) {
-        keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]);
-    }
-    if (opts.verbose) {
-        keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._) `${topSchemaRef}${schemaPath}`], [names_1.default.data, data]);
-    }
-    if (propertyName)
-        keyValues.push([E.propertyName, propertyName]);
-}
-//# sourceMappingURL=errors.js.map

package/dist/node_modules/ajv/dist/compile/index.d.ts

@@ -1,80 +0,0 @@
-import type { AnySchema, AnySchemaObject, AnyValidateFunction, EvaluatedProperties, EvaluatedItems } from "../types";
-import type Ajv from "../core";
-import type { InstanceOptions } from "../core";
-import { CodeGen, Name, Code, ValueScopeName } from "./codegen";
-import { LocalRefs } from "./resolve";
-import { JSONType } from "./rules";
-export type SchemaRefs = {
-    [Ref in string]?: SchemaEnv | AnySchema;
-};
-export interface SchemaCxt {
-    readonly gen: CodeGen;
-    readonly allErrors?: boolean;
-    readonly data: Name;
-    readonly parentData: Name;
-    readonly parentDataProperty: Code | number;
-    readonly dataNames: Name[];
-    readonly dataPathArr: (Code | number)[];
-    readonly dataLevel: number;
-    dataTypes: JSONType[];
-    definedProperties: Set<string>;
-    readonly topSchemaRef: Code;
-    readonly validateName: Name;
-    evaluated?: Name;
-    readonly ValidationError?: Name;
-    readonly schema: AnySchema;
-    readonly schemaEnv: SchemaEnv;
-    readonly rootId: string;
-    baseId: string;
-    readonly schemaPath: Code;
-    readonly errSchemaPath: string;
-    readonly errorPath: Code;
-    readonly propertyName?: Name;
-    readonly compositeRule?: boolean;
-    props?: EvaluatedProperties | Name;
-    items?: EvaluatedItems | Name;
-    jtdDiscriminator?: string;
-    jtdMetadata?: boolean;
-    readonly createErrors?: boolean;
-    readonly opts: InstanceOptions;
-    readonly self: Ajv;
-}
-export interface SchemaObjCxt extends SchemaCxt {
-    readonly schema: AnySchemaObject;
-}
-interface SchemaEnvArgs {
-    readonly schema: AnySchema;
-    readonly schemaId?: "$id" | "id";
-    readonly root?: SchemaEnv;
-    readonly baseId?: string;
-    readonly schemaPath?: string;
-    readonly localRefs?: LocalRefs;
-    readonly meta?: boolean;
-}
-export declare class SchemaEnv implements SchemaEnvArgs {
-    readonly schema: AnySchema;
-    readonly schemaId?: "$id" | "id";
-    readonly root: SchemaEnv;
-    baseId: string;
-    schemaPath?: string;
-    localRefs?: LocalRefs;
-    readonly meta?: boolean;
-    readonly $async?: boolean;
-    readonly refs: SchemaRefs;
-    readonly dynamicAnchors: {
-        [Ref in string]?: true;
-    };
-    validate?: AnyValidateFunction;
-    validateName?: ValueScopeName;
-    serialize?: (data: unknown) => string;
-    serializeName?: ValueScopeName;
-    parse?: (data: string) => unknown;
-    parseName?: ValueScopeName;
-    constructor(env: SchemaEnvArgs);
-}
-export declare function compileSchema(this: Ajv, sch: SchemaEnv): SchemaEnv;
-export declare function resolveRef(this: Ajv, root: SchemaEnv, baseId: string, ref: string): AnySchema | SchemaEnv | undefined;
-export declare function getCompilingSchema(this: Ajv, schEnv: SchemaEnv): SchemaEnv | void;
-export declare function resolveSchema(this: Ajv, root: SchemaEnv, // root object with properties schema, refs TODO below SchemaEnv is assigned to it
-ref: string): SchemaEnv | undefined;
-export {};

package/dist/node_modules/ajv/dist/compile/index.js

@@ -1,242 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
-const codegen_1 = require("./codegen");
-const validation_error_1 = require("../runtime/validation_error");
-const names_1 = require("./names");
-const resolve_1 = require("./resolve");
-const util_1 = require("./util");
-const validate_1 = require("./validate");
-class SchemaEnv {
-    constructor(env) {
-        var _a;
-        this.refs = {};
-        this.dynamicAnchors = {};
-        let schema;
-        if (typeof env.schema == "object")
-            schema = env.schema;
-        this.schema = env.schema;
-        this.schemaId = env.schemaId;
-        this.root = env.root || this;
-        this.baseId = (_a = env.baseId) !== null && _a !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]);
-        this.schemaPath = env.schemaPath;
-        this.localRefs = env.localRefs;
-        this.meta = env.meta;
-        this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
-        this.refs = {};
-    }
-}
-exports.SchemaEnv = SchemaEnv;
-// let codeSize = 0
-// let nodeCount = 0
-// Compiles schema in SchemaEnv
-function compileSchema(sch) {
-    // TODO refactor - remove compilations
-    const _sch = getCompilingSchema.call(this, sch);
-    if (_sch)
-        return _sch;
-    const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId); // TODO if getFullPath removed 1 tests fails
-    const { es5, lines } = this.opts.code;
-    const { ownProperties } = this.opts;
-    const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });
-    let _ValidationError;
-    if (sch.$async) {
-        _ValidationError = gen.scopeValue("Error", {
-            ref: validation_error_1.default,
-            code: (0, codegen_1._) `require("ajv/dist/runtime/validation_error").default`,
-        });
-    }
-    const validateName = gen.scopeName("validate");
-    sch.validateName = validateName;
-    const schemaCxt = {
-        gen,
-        allErrors: this.opts.allErrors,
-        data: names_1.default.data,
-        parentData: names_1.default.parentData,
-        parentDataProperty: names_1.default.parentDataProperty,
-        dataNames: [names_1.default.data],
-        dataPathArr: [codegen_1.nil], // TODO can its length be used as dataLevel if nil is removed?
-        dataLevel: 0,
-        dataTypes: [],
-        definedProperties: new Set(),
-        topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true
-            ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) }
-            : { ref: sch.schema }),
-        validateName,
-        ValidationError: _ValidationError,
-        schema: sch.schema,
-        schemaEnv: sch,
-        rootId,
-        baseId: sch.baseId || rootId,
-        schemaPath: codegen_1.nil,
-        errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"),
-        errorPath: (0, codegen_1._) `""`,
-        opts: this.opts,
-        self: this,
-    };
-    let sourceCode;
-    try {
-        this._compilations.add(sch);
-        (0, validate_1.validateFunctionCode)(schemaCxt);
-        gen.optimize(this.opts.code.optimize);
-        // gen.optimize(1)
-        const validateCode = gen.toString();
-        sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
-        // console.log((codeSize += sourceCode.length), (nodeCount += gen.nodeCount))
-        if (this.opts.code.process)
-            sourceCode = this.opts.code.process(sourceCode, sch);
-        // console.log("\n\n\n *** \n", sourceCode)
-        const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
-        const validate = makeValidate(this, this.scope.get());
-        this.scope.value(validateName, { ref: validate });
-        validate.errors = null;
-        validate.schema = sch.schema;
-        validate.schemaEnv = sch;
-        if (sch.$async)
-            validate.$async = true;
-        if (this.opts.code.source === true) {
-            validate.source = { validateName, validateCode, scopeValues: gen._values };
-        }
-        if (this.opts.unevaluated) {
-            const { props, items } = schemaCxt;
-            validate.evaluated = {
-                props: props instanceof codegen_1.Name ? undefined : props,
-                items: items instanceof codegen_1.Name ? undefined : items,
-                dynamicProps: props instanceof codegen_1.Name,
-                dynamicItems: items instanceof codegen_1.Name,
-            };
-            if (validate.source)
-                validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
-        }
-        sch.validate = validate;
-        return sch;
-    }
-    catch (e) {
-        delete sch.validate;
-        delete sch.validateName;
-        if (sourceCode)
-            this.logger.error("Error compiling schema, function code:", sourceCode);
-        // console.log("\n\n\n *** \n", sourceCode, this.opts)
-        throw e;
-    }
-    finally {
-        this._compilations.delete(sch);
-    }
-}
-exports.compileSchema = compileSchema;
-function resolveRef(root, baseId, ref) {
-    var _a;
-    ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
-    const schOrFunc = root.refs[ref];
-    if (schOrFunc)
-        return schOrFunc;
-    let _sch = resolve.call(this, root, ref);
-    if (_sch === undefined) {
-        const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref]; // TODO maybe localRefs should hold SchemaEnv
-        const { schemaId } = this.opts;
-        if (schema)
-            _sch = new SchemaEnv({ schema, schemaId, root, baseId });
-    }
-    if (_sch === undefined)
-        return;
-    return (root.refs[ref] = inlineOrCompile.call(this, _sch));
-}
-exports.resolveRef = resolveRef;
-function inlineOrCompile(sch) {
-    if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
-        return sch.schema;
-    return sch.validate ? sch : compileSchema.call(this, sch);
-}
-// Index of schema compilation in the currently compiled list
-function getCompilingSchema(schEnv) {
-    for (const sch of this._compilations) {
-        if (sameSchemaEnv(sch, schEnv))
-            return sch;
-    }
-}
-exports.getCompilingSchema = getCompilingSchema;
-function sameSchemaEnv(s1, s2) {
-    return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
-}
-// resolve and compile the references ($ref)
-// TODO returns AnySchemaObject (if the schema can be inlined) or validation function
-function resolve(root, // information about the root schema for the current schema
-ref // reference to resolve
-) {
-    let sch;
-    while (typeof (sch = this.refs[ref]) == "string")
-        ref = sch;
-    return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
-}
-// Resolve schema, its root and baseId
-function resolveSchema(root, // root object with properties schema, refs TODO below SchemaEnv is assigned to it
-ref // reference to resolve
-) {
-    const p = this.opts.uriResolver.parse(ref);
-    const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
-    let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, undefined);
-    // TODO `Object.keys(root.schema).length > 0` should not be needed - but removing breaks 2 tests
-    if (Object.keys(root.schema).length > 0 && refPath === baseId) {
-        return getJsonPointer.call(this, p, root);
-    }
-    const id = (0, resolve_1.normalizeId)(refPath);
-    const schOrRef = this.refs[id] || this.schemas[id];
-    if (typeof schOrRef == "string") {
-        const sch = resolveSchema.call(this, root, schOrRef);
-        if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object")
-            return;
-        return getJsonPointer.call(this, p, sch);
-    }
-    if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object")
-        return;
-    if (!schOrRef.validate)
-        compileSchema.call(this, schOrRef);
-    if (id === (0, resolve_1.normalizeId)(ref)) {
-        const { schema } = schOrRef;
-        const { schemaId } = this.opts;
-        const schId = schema[schemaId];
-        if (schId)
-            baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
-        return new SchemaEnv({ schema, schemaId, root, baseId });
-    }
-    return getJsonPointer.call(this, p, schOrRef);
-}
-exports.resolveSchema = resolveSchema;
-const PREVENT_SCOPE_CHANGE = new Set([
-    "properties",
-    "patternProperties",
-    "enum",
-    "dependencies",
-    "definitions",
-]);
-function getJsonPointer(parsedRef, { baseId, schema, root }) {
-    var _a;
-    if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/")
-        return;
-    for (const part of parsedRef.fragment.slice(1).split("/")) {
-        if (typeof schema === "boolean")
-            return;
-        const partSchema = schema[(0, util_1.unescapeFragment)(part)];
-        if (partSchema === undefined)
-            return;
-        schema = partSchema;
-        // TODO PREVENT_SCOPE_CHANGE could be defined in keyword def?
-        const schId = typeof schema === "object" && schema[this.opts.schemaId];
-        if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
-            baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
-        }
-    }
-    let env;
-    if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
-        const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
-        env = resolveSchema.call(this, root, $ref);
-    }
-    // even though resolution failed we need to return SchemaEnv to throw exception
-    // so that compileAsync loads missing schema.
-    const { schemaId } = this.opts;
-    env = env || new SchemaEnv({ schema, schemaId, root, baseId });
-    if (env.schema !== env.root.schema)
-        return env;
-    return undefined;
-}
-//# sourceMappingURL=index.js.map

package/dist/node_modules/ajv/dist/compile/jtd/parse.d.ts

@@ -1,4 +0,0 @@
-import type Ajv from "../../core";
-import { SchemaObjectMap } from "./types";
-import { SchemaEnv } from "..";
-export default function compileParser(this: Ajv, sch: SchemaEnv, definitions: SchemaObjectMap): SchemaEnv;